Table Of Contents

Previous topic

1. Math library

Next topic

3. Algorithm library

This Page

2. Scene Graph library

2.2. openalea.plantgl.scenegraph module

class AmapSymbol

The AmapSymbol describes an object of class of Mesh stored in the SMB file format of the Amap software.This is provided for ascendant compatibility.AmapSymbol

The AmapSymbol describes an object of class of Mesh stored in the SMB file format of the Amap software. This is provided for ascendant compatibility.
Parameters:
  • FileName – specifies the name of the SMB file to bind to the symbol. It must contain the full path and .smb extension if needed. The corresponding file must exist.
  • Solid – specifies whether the symbol represents a closed surface. (default is False)
Example :
from openalea.plantgl.scenegraph import AmapSymbol
from openalea.plantgl.all import get_shared_data, Viewer, Scene
from os.path import join as pj
sym = AmapSymbol(get_shared_data(pj('amapsymbols','enpomf.smb')))
scene = Scene()
scene += sym
Viewer.display(scene)   
Viewer.frameGL.saveImage('amapsymbol.png', 'png') 
../_images/amapsymbol.png ../_images/amapsymbol2.png
__init__( (object)arg1 [, (str)arg2 [, (bool)arg3]]) -> None :

AmapSymbol(filename)

C++ signature :
void __init__(_object* [,std::string [,bool]])
deepcopy()

deepcopy( (AmapSymbol)arg1) -> AmapSymbol :

C++ signature :
TOOLS::RefCountPtr<PGL::AmapSymbol> deepcopy(PGL::AmapSymbol {lvalue})

deepcopy( (AmapSymbol)arg1, (DeepCopier)copier) -> AmapSymbol :

C++ signature :
TOOLS::RefCountPtr<PGL::AmapSymbol> deepcopy(PGL::AmapSymbol {lvalue},PGL::DeepCopier {lvalue})
filename
readFile()

readFile( (AmapSymbol)arg1, (str)arg2) -> bool :

C++ signature :
bool readFile(PGL::AmapSymbol {lvalue},std::string)
recast()

recast( (AmapSymbol)arg1) -> AmapSymbol :

C++ signature :
TOOLS::RefCountPtr<PGL::AmapSymbol> recast(PGL::AmapSymbol*)
class Appearance

Abstract base class for all appearance objects.

Raises an exception This class cannot be instantiated from Python

isTexture()
isTexture( (Appearance)arg1) -> bool :

Tell wether self is of type texture

C++ signature :
bool isTexture(PGL::Appearance {lvalue})
class AsymmetricHull

An Asymmetric Hull describes an anvelop defined by 6 morphological points. This is an implementation of the asymmetric crowns introduced by [Koop,89] and [Cescatti,97].The two first morphological points are the bottom and top points of the hull.The four other points are used to defined the peripheral line of the hull (P1,P2,P3,P4).The two first points are located along the x -axis (P1,P2) and the two other along the y-axis (P3,P4).As such Pi points are described with only two dimensions, i.e. a radius and a height using corresponding parametersFinally, the shape coefficients are versatile indices which describe the curvature of the hull above and below the peripheral line.

__init__( (object)arg1 [, (float)negXRadius=0.5 [, (float)posXRadius=0.5 [, (float)negYRadius=0.5 [, (float)posYRadius=0.5 [, (float)negXHeight=0.0 [, (float)posXHeight=0.0 [, (float)negYHeight=0.0 [, (float)posYHeight=0.0 [, (Vector3)bottom=Vector3(0,0,-0.5) [, (Vector3)top=Vector3(0,0,0.5) [, (float)bottomShape=2.0 [, (float)topShape=2.0 [, (int)slices=4 [, (int)stacks=4]]]]]]]]]]]]]]) -> None :

AsymmetricHull([negXRadius,posXRadius,negYRadius,posYRadius,negXHeight,posXHeight,negYHeight,posYHeight,bottom, top, bottomShape, topShape, slices, stacks])

C++ signature :
void __init__(_object* [,double=0.5 [,double=0.5 [,double=0.5 [,double=0.5 [,double=0.0 [,double=0.0 [,double=0.0 [,double=0.0 [,TOOLS::Vector3=Vector3(0,0,-0.5) [,TOOLS::Vector3=Vector3(0,0,0.5) [,double=2.0 [,double=2.0 [,unsigned char=4 [,unsigned char=4]]]]]]]]]]]]]])
bottom
bottomShape
deepcopy()

deepcopy( (AsymmetricHull)arg1) -> AsymmetricHull :

C++ signature :
TOOLS::RefCountPtr<PGL::AsymmetricHull> deepcopy(PGL::AsymmetricHull {lvalue})

deepcopy( (AsymmetricHull)arg1, (DeepCopier)copier) -> AsymmetricHull :

C++ signature :
TOOLS::RefCountPtr<PGL::AsymmetricHull> deepcopy(PGL::AsymmetricHull {lvalue},PGL::DeepCopier {lvalue})
isBottomShapeToDefault()

isBottomShapeToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isBottomShapeToDefault(PGL::AsymmetricHull {lvalue})
isBottomToDefault()

isBottomToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isBottomToDefault(PGL::AsymmetricHull {lvalue})
isNegXHeightToDefault()

isNegXHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isNegXHeightToDefault(PGL::AsymmetricHull {lvalue})
isNegXRadiusToDefault()

isNegXRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isNegXRadiusToDefault(PGL::AsymmetricHull {lvalue})
isNegYHeightToDefault()

isNegYHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isNegYHeightToDefault(PGL::AsymmetricHull {lvalue})
isNegYRadiusToDefault()

isNegYRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isNegYRadiusToDefault(PGL::AsymmetricHull {lvalue})
isPosXHeightToDefault()

isPosXHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isPosXHeightToDefault(PGL::AsymmetricHull {lvalue})
isPosXRadiusToDefault()

isPosXRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isPosXRadiusToDefault(PGL::AsymmetricHull {lvalue})
isPosYHeightToDefault()

isPosYHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isPosYHeightToDefault(PGL::AsymmetricHull {lvalue})
isPosYRadiusToDefault()

isPosYRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isPosYRadiusToDefault(PGL::AsymmetricHull {lvalue})
isSlicesToDefault()

isSlicesToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isSlicesToDefault(PGL::AsymmetricHull {lvalue})
isStacksToDefault()

isStacksToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isStacksToDefault(PGL::AsymmetricHull {lvalue})
isTopShapeToDefault()

isTopShapeToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isTopShapeToDefault(PGL::AsymmetricHull {lvalue})
isTopToDefault()

isTopToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :
bool isTopToDefault(PGL::AsymmetricHull {lvalue})
negXHeight
negXRadius
negYHeight
negYRadius
posXHeight
posXRadius
posYHeight
posYRadius
recast()

recast( (AsymmetricHull)arg1) -> AsymmetricHull :

C++ signature :
TOOLS::RefCountPtr<PGL::AsymmetricHull> recast(PGL::AsymmetricHull*)
slices
stacks
top
topShape
class AxisRotated

The AxisRotated describes an object to which it has been applied a rotation of a specified angle about a specified axis. The rotation is given by the matrix: |(1-c)x2 + c (1-c)xy - sz (1-c)xy + sy|

|(1-c)xy + sz (1-c)y2 + c (1-c)yz - sx| |(1-c)xz - sy (1-c)yz + sx (1-c)z2 + c |

where s = sin(angle), c = cos(angle), x,y and z the coordinates of the axis.

__init__( (object)arg1 [, (Vector3)axis=Vector3(0,0,1) [, (float)angle=0.0 [, (Geometry)geometry=None]]]) -> None :

AxisRotated( Vector3 axis, radian angle, geometry)

C++ signature :
void __init__(_object* [,TOOLS::Vector3=Vector3(0,0,1) [,double=0.0 [,TOOLS::RefCountPtr<PGL::Geometry>=None]]])
angle
axis
deepcopy()

deepcopy( (AxisRotated)arg1) -> AxisRotated :

C++ signature :
TOOLS::RefCountPtr<PGL::AxisRotated> deepcopy(PGL::AxisRotated {lvalue})

deepcopy( (AxisRotated)arg1, (DeepCopier)copier) -> AxisRotated :

C++ signature :
TOOLS::RefCountPtr<PGL::AxisRotated> deepcopy(PGL::AxisRotated {lvalue},PGL::DeepCopier {lvalue})
isAngleToDefault()

isAngleToDefault( (AxisRotated)arg1) -> bool :

C++ signature :
bool isAngleToDefault(PGL::AxisRotated {lvalue})
isAxisToDefault()

isAxisToDefault( (AxisRotated)arg1) -> bool :

C++ signature :
bool isAxisToDefault(PGL::AxisRotated {lvalue})
recast()

recast( (AxisRotated)arg1) -> AxisRotated :

C++ signature :
TOOLS::RefCountPtr<PGL::AxisRotated> recast(PGL::AxisRotated*)
class AxisRotation

__init__( (object)arg1, (Vector3)arg2, (float)arg3) -> None :

C++ signature :
void __init__(_object*,TOOLS::Vector3,double)
class BaseOrientation

__init__( (object)arg1, (Vector3)arg2, (Vector3)arg3) -> None :

C++ signature :
void __init__(_object*,TOOLS::Vector3,TOOLS::Vector3)
class BezierCurve

BezierCurve describes rational and non rational Bezier curve. It is defined by a degree n and a list of control Points Pi and using the parametric equation C(u) = Sum(i=0,n)(Bi,n(u)Pi) with u in [0,1] where Bi,n(u) are the classical n-th degree Bernstein polynomials.

__init__( (object)arg1, (Point3Array)ctrlPointList [, (int)stride [, (int)width]]) -> None :

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,unsigned int [,unsigned char]])
__init__( (object)arg1, (Point4Array)ctrlPointList [, (int)stride=30 [, (int)width=1]]) -> None :

Create a BezierCurve from a list of 3d points.

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Array> [,unsigned int=30 [,unsigned char=1]])
bernstein()
bernstein( (int)i, (int)n, (float)u) -> float :

float bernstein( int i, int n, float u )Computes the value of i-th Bernstein polynomial for a fixed u.See the Nurbs Book p20. usefull for Bezier Curve computation.

C++ signature :
double bernstein(unsigned int,unsigned int,double)
bernstein_factors()
bernstein_factors( (int)n, (float)u) -> object :

[float] bernstein_factors( int n, float u )Computes the n + 1 th degree Bernstein polynomials for a fixed u.See the Nurbs Book p21 . usefull for Bezier Curve computation.

C++ signature :
boost::python::api::object bernstein_factors(unsigned int,double)
ctrlPointList
deepcopy()

deepcopy( (BezierCurve)arg1) -> BezierCurve :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierCurve> deepcopy(PGL::BezierCurve {lvalue})

deepcopy( (BezierCurve)arg1, (DeepCopier)copier) -> BezierCurve :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierCurve> deepcopy(PGL::BezierCurve {lvalue},PGL::DeepCopier {lvalue})
isStrideToDefault()

isStrideToDefault( (BezierCurve)arg1) -> bool :

C++ signature :
bool isStrideToDefault(PGL::BezierCurve {lvalue})
recast()

recast( (BezierCurve)arg1) -> BezierCurve :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierCurve> recast(PGL::BezierCurve*)
stride
class BezierCurve2D

BezierCurve2D describes rational and non rational 2D Bezier curve. It is represented by a degree and a list of control Points. See BezierCurve.

__init__( (object)arg1, (Point2Array)ctrlPointList [, (int)stride [, (int)width]]) -> None :

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned int [,unsigned char]])
__init__( (object)arg1, (Point3Array)ctrlPointList [, (int)stride=30 [, (int)width=1]]) -> None :

Create a BezierCurve from a list of 3d points.

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,unsigned int=30 [,unsigned char=1]])
ctrlPointList
deepcopy()

deepcopy( (BezierCurve2D)arg1) -> BezierCurve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierCurve2D> deepcopy(PGL::BezierCurve2D {lvalue})

deepcopy( (BezierCurve2D)arg1, (DeepCopier)copier) -> BezierCurve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierCurve2D> deepcopy(PGL::BezierCurve2D {lvalue},PGL::DeepCopier {lvalue})
isStrideToDefault()

isStrideToDefault( (BezierCurve2D)arg1) -> bool :

C++ signature :
bool isStrideToDefault(PGL::BezierCurve2D {lvalue})
recast()

recast( (BezierCurve2D)arg1) -> BezierCurve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierCurve2D> recast(PGL::BezierCurve2D*)
stride
class BezierPatch

BezierPatch describes rational and non rational Bezier surface. It is defined by two degrees n and m and a matrix of control Points Pi,j and using the parametric equation S(u,v) = Sum(i=0,n)Sum(j=0,m)(Bi,n(u)Bj,m(v)Pi,j) with u and v in [0,1] where Bi,n(u) and Bi,m(v) are the classical n and m-th degree Bernstein polynomials.

__init__( (object)arg1, (Point4Matrix)ctrlPointList [, (int)ustride=30 [, (int)vstride=30 [, (bool)ccw=True]]]) -> None :

BezierPatch(Point4Matrix ctrlPointList [,ustride,vstride,ccw])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Matrix> [,unsigned int=30 [,unsigned int=30 [,bool=True]]])
ctrlPointMatrix
deepcopy()

deepcopy( (BezierPatch)arg1) -> BezierPatch :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierPatch> deepcopy(PGL::BezierPatch {lvalue})

deepcopy( (BezierPatch)arg1, (DeepCopier)copier) -> BezierPatch :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierPatch> deepcopy(PGL::BezierPatch {lvalue},PGL::DeepCopier {lvalue})
getPointAt()

getPointAt( (BezierPatch)arg1, (float)arg2, (float)arg3) -> Vector3 :

C++ signature :
TOOLS::Vector3 getPointAt(PGL::BezierPatch {lvalue},double,double)
getUSection()
getUSection( (BezierPatch)arg1, (float)u) -> LineicModel :

Compute a section line of the patch corresponding to a constant u value.

C++ signature :
TOOLS::RefCountPtr<PGL::LineicModel> getUSection(PGL::BezierPatch {lvalue},double)
getVSection()
getVSection( (BezierPatch)arg1, (float)v) -> LineicModel :

Compute a section line of the patch corresponding to a constant v value.

C++ signature :
TOOLS::RefCountPtr<PGL::LineicModel> getVSection(PGL::BezierPatch {lvalue},double)
isUStrideToDefault()

isUStrideToDefault( (BezierPatch)arg1) -> bool :

C++ signature :
bool isUStrideToDefault(PGL::BezierPatch {lvalue})
isVStrideToDefault()

isVStrideToDefault( (BezierPatch)arg1) -> bool :

C++ signature :
bool isVStrideToDefault(PGL::BezierPatch {lvalue})
recast()

recast( (BezierPatch)arg1) -> BezierPatch :

C++ signature :
TOOLS::RefCountPtr<PGL::BezierPatch> recast(PGL::BezierPatch*)
udegree
ustride
vdegree
vstride
class BoundingBox

An axis aligned box represented by 2 opposite corners.

__init__( (object)arg1 [, (Vector3)lowerLeft=Vector3(0,0,0) [, (Vector3)upperRight=Vector3(0,0,0)]]) -> None :

BoundingBox(Vector3 lowerLeft, Vector3 upperRight) Constructs a BoundingBox with the 2 opposing corners lowerLeft and upperRight.

C++ signature :
void __init__(_object* [,TOOLS::Vector3=Vector3(0,0,0) [,TOOLS::Vector3=Vector3(0,0,0)]])
__init__( (object)arg1, (object)arg2) -> object :

BoundingBox(geometry|scene) Constructs a BoundingBox from some geometries.

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
change()
change( (BoundingBox)arg1, (Vector3)arg2, (Vector3)arg3) -> None :

change(center)

C++ signature :
void change(PGL::BoundingBox {lvalue},TOOLS::Vector3,TOOLS::Vector3)
contains()

contains( (BoundingBox)arg1, (BoundingBox)arg2) -> bool :

C++ signature :
bool contains(PGL::BoundingBox*,PGL::BoundingBox*)

contains( (BoundingBox)arg1, (Vector3)arg2) -> bool :

C++ signature :
bool contains(PGL::BoundingBox*,TOOLS::Vector3)
getCenter()

getCenter( (BoundingBox)arg1) -> Vector3 :

C++ signature :
TOOLS::Vector3 getCenter(PGL::BoundingBox {lvalue})
getId()

getId( (BoundingBox)arg1) -> int :

C++ signature :
unsigned long getId(PGL::BoundingBox {lvalue})
getSize()
getSize( (BoundingBox)arg1) -> Vector3 :

size of the half diagonal of self along the x-axis, y-axis and z-axis.

C++ signature :
TOOLS::Vector3 getSize(PGL::BoundingBox {lvalue})
getXMax()

getXMax( (BoundingBox)arg1) -> float :

C++ signature :
double getXMax(PGL::BoundingBox {lvalue})
getXMin()

getXMin( (BoundingBox)arg1) -> float :

C++ signature :
double getXMin(PGL::BoundingBox {lvalue})
getXRange()

getXRange( (BoundingBox)arg1) -> float :

C++ signature :
double getXRange(PGL::BoundingBox {lvalue})
getYMax()

getYMax( (BoundingBox)arg1) -> float :

C++ signature :
double getYMax(PGL::BoundingBox {lvalue})
getYMin()

getYMin( (BoundingBox)arg1) -> float :

C++ signature :
double getYMin(PGL::BoundingBox {lvalue})
getYRange()

getYRange( (BoundingBox)arg1) -> float :

C++ signature :
double getYRange(PGL::BoundingBox {lvalue})
getZMax()

getZMax( (BoundingBox)arg1) -> float :

C++ signature :
double getZMax(PGL::BoundingBox {lvalue})
getZMin()

getZMin( (BoundingBox)arg1) -> float :

C++ signature :
double getZMin(PGL::BoundingBox {lvalue})
getZRange()

getZRange( (BoundingBox)arg1) -> float :

C++ signature :
double getZRange(PGL::BoundingBox {lvalue})
lowerLeftCorner
scale()

scale( (BoundingBox)arg1, (Vector3)arg2) -> None :

C++ signature :
void scale(PGL::BoundingBox {lvalue},TOOLS::Vector3)
set()
set( (BoundingBox)arg1, (Vector3)arg2, (Vector3)arg3) -> None :

set(lowerLeft,upperRight)

C++ signature :
void set(PGL::BoundingBox {lvalue},TOOLS::Vector3,TOOLS::Vector3)
transform()

transform( (BoundingBox)arg1, (Matrix4)arg2) -> None :

C++ signature :
void transform(PGL::BoundingBox {lvalue},TOOLS::Matrix4)

transform( (BoundingBox)arg1, (Matrix3)arg2) -> None :

C++ signature :
void transform(PGL::BoundingBox {lvalue},TOOLS::Matrix3)
translate()

translate( (BoundingBox)arg1, (Vector3)arg2) -> None :

C++ signature :
void translate(PGL::BoundingBox {lvalue},TOOLS::Vector3)
upperRightCorner
class Box

The Box describes a rectangular axis-aligned box centered at origin and whose extension along the x, y and z-axis is specified with the size vector.

__init__( (object)arg1 [, (Vector3)size=Vector3(0.5,0.5,0.5)]) -> None :

Box(Vector3(x,y,z))

C++ signature :
void __init__(_object* [,TOOLS::Vector3=Vector3(0.5,0.5,0.5)])

__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> object :

C++ signature :
void* __init__(boost::python::api::object,double,double,double)

__init__( (object)arg1, (float)arg2) -> object :

C++ signature :
void* __init__(boost::python::api::object,double)
deepcopy()

deepcopy( (Box)arg1) -> Box :

C++ signature :
TOOLS::RefCountPtr<PGL::Box> deepcopy(PGL::Box {lvalue})

deepcopy( (Box)arg1, (DeepCopier)copier) -> Box :

C++ signature :
TOOLS::RefCountPtr<PGL::Box> deepcopy(PGL::Box {lvalue},PGL::DeepCopier {lvalue})
isSizeToDefault()

isSizeToDefault( (Box)arg1) -> bool :

C++ signature :
bool isSizeToDefault(PGL::Box {lvalue})
recast()

recast( (Box)arg1) -> Box :

C++ signature :
TOOLS::RefCountPtr<PGL::Box> recast(PGL::Box*)
size
class Color3

A 3 components color expressed in red, green and blue.

__init__( (object)arg1, (Color3)other) -> None :

C++ signature :
void __init__(_object*,PGL::Color3)
__init__( (object)arg1 [, (int)red=0 [, (int)green=0 [, (int)blue=0]]]) -> None :

Color3(red,green,blue)

C++ signature :
void __init__(_object* [,unsigned char=0 [,unsigned char=0 [,unsigned char=0]]])

__init__( (object)arg1 [, (int)value=0]) -> None :

C++ signature :
void __init__(_object* [,unsigned char=0])

__init__( (object)arg1, (Color4)other) -> None :

C++ signature :
void __init__(_object*,PGL::Color4)
blue
clampedBlue()

clampedBlue( (Color3)arg1) -> float :

C++ signature :
double clampedBlue(PGL::Color3*)
clampedGreen()

clampedGreen( (Color3)arg1) -> float :

C++ signature :
double clampedGreen(PGL::Color3*)
clampedRed()

clampedRed( (Color3)arg1) -> float :

C++ signature :
double clampedRed(PGL::Color3*)
fromUint()

fromUint( (int)arg1) -> Color3 :

C++ signature :
PGL::Color3 fromUint(unsigned int)
getAverage()

getAverage( (Color3)arg1) -> float :

C++ signature :
double getAverage(PGL::Color3 {lvalue})
getAverageClamped()

getAverageClamped( (Color3)arg1) -> float :

C++ signature :
double getAverageClamped(PGL::Color3 {lvalue})
green
red
setClampedBlue()

setClampedBlue( (Color3)arg1, (float)arg2) -> None :

C++ signature :
void setClampedBlue(PGL::Color3*,double)
setClampedGreen()

setClampedGreen( (Color3)arg1, (float)arg2) -> None :

C++ signature :
void setClampedGreen(PGL::Color3*,double)
setClampedRed()

setClampedRed( (Color3)arg1, (float)arg2) -> None :

C++ signature :
void setClampedRed(PGL::Color3*,double)
toUint()

toUint( (Color3)arg1) -> int :

C++ signature :
unsigned int toUint(PGL::Color3 {lvalue})
class Color3Array
__init__( (object)arg1, (int)size) -> None :

Color3Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Color3Array([Index3(i,j,k),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Color3Array)arg1, (Color3)arg2) -> None :

C++ signature :
void append(PGL::Color3Array*,PGL::Color3)

append( (Color3Array)arg1, (Color3Array)arg2) -> None :

C++ signature :
void append(PGL::Color3Array*,PGL::Color3Array*)
clear()

clear( (Color3Array)arg1) -> None :

C++ signature :
void clear(PGL::Color3Array {lvalue})
getId()

getId( (Color3Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Color3Array*)
getPglId()

getPglId( (Color3Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Color3Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Color3Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Color3Array {lvalue})
insert()

insert( (Color3Array)arg1, (int)arg2, (Color3)arg3) -> None :

C++ signature :
void insert(PGL::Color3Array*,int,PGL::Color3)
pop()

pop( (Color3Array)arg1 [, (int)arg2]) -> Color3 :

C++ signature :
PGL::Color3 pop(PGL::Color3Array* [,int])
prepend()

prepend( (Color3Array)arg1, (Color3)arg2) -> None :

C++ signature :
void prepend(PGL::Color3Array*,PGL::Color3)

prepend( (Color3Array)arg1, (Color3Array)arg2) -> None :

C++ signature :
void prepend(PGL::Color3Array*,PGL::Color3Array*)
reverse()

reverse( (Color3Array)arg1) -> None :

C++ signature :
void reverse(PGL::Color3Array {lvalue})
class Color4

A 4 component color expressed in red, green, blue and alpha.

__init__( (object)arg1, (Color4)other) -> None :

C++ signature :
void __init__(_object*,PGL::Color4)
__init__( (object)arg1 [, (int)red=0 [, (int)green=0 [, (int)blue=0 [, (int)alpha=0]]]]) -> None :

Color4(red,green,blue,alpha)

C++ signature :
void __init__(_object* [,unsigned char=0 [,unsigned char=0 [,unsigned char=0 [,unsigned char=0]]]])

__init__( (object)arg1 [, (int)value=0]) -> None :

C++ signature :
void __init__(_object* [,unsigned char=0])

__init__( (object)arg1 [, (Color3)other=0 [, (int)alpha=0]]) -> None :

C++ signature :
void __init__(_object* [,PGL::Color3=0 [,unsigned char=0]])
alpha
blue
clampedAlpha()

clampedAlpha( (Color4)arg1) -> float :

C++ signature :
double clampedAlpha(PGL::Color4*)
clampedBlue()

clampedBlue( (Color4)arg1) -> float :

C++ signature :
double clampedBlue(PGL::Color4*)
clampedGreen()

clampedGreen( (Color4)arg1) -> float :

C++ signature :
double clampedGreen(PGL::Color4*)
clampedRed()

clampedRed( (Color4)arg1) -> float :

C++ signature :
double clampedRed(PGL::Color4*)
fromUint()

fromUint( (int)arg1) -> Color4 :

C++ signature :
PGL::Color4 fromUint(unsigned int)
getAverage()

getAverage( (Color4)arg1) -> float :

C++ signature :
double getAverage(PGL::Color4 {lvalue})
getAverageClamped()

getAverageClamped( (Color4)arg1) -> float :

C++ signature :
double getAverageClamped(PGL::Color4 {lvalue})
getRGBAverage()

getRGBAverage( (Color4)arg1) -> float :

C++ signature :
double getRGBAverage(PGL::Color4 {lvalue})
getRGBAverageClamped()

getRGBAverageClamped( (Color4)arg1) -> float :

C++ signature :
double getRGBAverageClamped(PGL::Color4 {lvalue})
green
red
setClampedAlpha()

setClampedAlpha( (Color4)arg1, (float)arg2) -> None :

C++ signature :
void setClampedAlpha(PGL::Color4*,double)
setClampedBlue()

setClampedBlue( (Color4)arg1, (float)arg2) -> None :

C++ signature :
void setClampedBlue(PGL::Color4*,double)
setClampedGreen()

setClampedGreen( (Color4)arg1, (float)arg2) -> None :

C++ signature :
void setClampedGreen(PGL::Color4*,double)
setClampedRed()

setClampedRed( (Color4)arg1, (float)arg2) -> None :

C++ signature :
void setClampedRed(PGL::Color4*,double)
toUint()

toUint( (Color4)arg1) -> int :

C++ signature :
unsigned int toUint(PGL::Color4 {lvalue})
class Color4Array
__init__( (object)arg1, (int)size) -> None :

Color4Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Color4Array([Index4(i,j,k,l),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Color4Array)arg1, (Color4)arg2) -> None :

C++ signature :
void append(PGL::Color4Array*,PGL::Color4)

append( (Color4Array)arg1, (Color4Array)arg2) -> None :

C++ signature :
void append(PGL::Color4Array*,PGL::Color4Array*)
clear()

clear( (Color4Array)arg1) -> None :

C++ signature :
void clear(PGL::Color4Array {lvalue})
getId()

getId( (Color4Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Color4Array*)
getPglId()

getPglId( (Color4Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Color4Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Color4Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Color4Array {lvalue})
insert()

insert( (Color4Array)arg1, (int)arg2, (Color4)arg3) -> None :

C++ signature :
void insert(PGL::Color4Array*,int,PGL::Color4)
pop()

pop( (Color4Array)arg1 [, (int)arg2]) -> Color4 :

C++ signature :
PGL::Color4 pop(PGL::Color4Array* [,int])
prepend()

prepend( (Color4Array)arg1, (Color4)arg2) -> None :

C++ signature :
void prepend(PGL::Color4Array*,PGL::Color4)

prepend( (Color4Array)arg1, (Color4Array)arg2) -> None :

C++ signature :
void prepend(PGL::Color4Array*,PGL::Color4Array*)
reverse()

reverse( (Color4Array)arg1) -> None :

C++ signature :
void reverse(PGL::Color4Array {lvalue})
class Cone

A cone structure defined by a radius and a height. Its base is centered at origin.

__init__( (object)arg1 [, (float)radius=0.5 [, (float)height=1.0 [, (bool)solid=True [, (int)slices=8]]]]) -> None :

Cone(radius, height [, solid, slices])

C++ signature :
void __init__(_object* [,double=0.5 [,double=1.0 [,bool=True [,unsigned char=8]]]])
deepcopy()

deepcopy( (Cone)arg1) -> Cone :

C++ signature :
TOOLS::RefCountPtr<PGL::Cone> deepcopy(PGL::Cone {lvalue})

deepcopy( (Cone)arg1, (DeepCopier)copier) -> Cone :

C++ signature :
TOOLS::RefCountPtr<PGL::Cone> deepcopy(PGL::Cone {lvalue},PGL::DeepCopier {lvalue})
height
isHeightToDefault()

isHeightToDefault( (Cone)arg1) -> bool :

C++ signature :
bool isHeightToDefault(PGL::Cone {lvalue})
isRadiusToDefault()

isRadiusToDefault( (Cone)arg1) -> bool :

C++ signature :
bool isRadiusToDefault(PGL::Cone {lvalue})
isSolidToDefault()

isSolidToDefault( (Cone)arg1) -> bool :

C++ signature :
bool isSolidToDefault(PGL::Cone {lvalue})
radius
recast()

recast( (Cone)arg1) -> Cone :

C++ signature :
TOOLS::RefCountPtr<PGL::Cone> recast(PGL::Cone*)
solid
class Curve2D

Abstract base class for objects of type of 2D parametric curve.

Raises an exception This class cannot be instantiated from Python

findClosest()
findClosest( (Curve2D)arg1, (Vector2)point) -> object :

findClosest(point) : return closestpoint, u

C++ signature :
boost::python::api::object findClosest(PGL::Curve2D*,TOOLS::Vector2)
firstKnot
getArcLengthToUMapping()
getArcLengthToUMapping( (Curve2D)arg1) -> QuantisedFunction :

getArcLengthToUMapping() : Return a function that gives for each arc length the u parametrization of the curve.

C++ signature :
TOOLS::RefCountPtr<PGL::QuantisedFunction> getArcLengthToUMapping(PGL::Curve2D {lvalue})
getLength()

getLength( (Curve2D)arg1) -> float :

C++ signature :
double getLength(PGL::Curve2D {lvalue})

getLength( (Curve2D)arg1, (float)begin) -> float :

C++ signature :
double getLength(PGL::Curve2D {lvalue},double)
getLength( (Curve2D)arg1, (float)begin, (float)end) -> float :

getLength([begin,end]) : Return length of the curve from u = begin to u = end.

C++ signature :
double getLength(PGL::Curve2D {lvalue},double,double)
getNormalAt()

getNormalAt( (Curve2D)arg1, (float)u) -> Vector2 :

C++ signature :
TOOLS::Vector2 getNormalAt(PGL::Curve2D const*,double)
getPointAt()

getPointAt( (Curve2D)arg1, (float)u) -> Vector2 :

C++ signature :
TOOLS::Vector2 getPointAt(PGL::Curve2D const*,double)
getTangentAt()

getTangentAt( (Curve2D)arg1, (float)u) -> Vector2 :

C++ signature :
TOOLS::Vector2 getTangentAt(PGL::Curve2D const*,double)
getUToArcLengthMapping()
getUToArcLengthMapping( (Curve2D)arg1) -> QuantisedFunction :

getUToArcLengthMapping() : Return a function that gives for each u the arc length parametrization of the curve.

C++ signature :
TOOLS::RefCountPtr<PGL::QuantisedFunction> getUToArcLengthMapping(PGL::Curve2D {lvalue})
isWidthToDefault()

isWidthToDefault( (Curve2D)arg1) -> bool :

C++ signature :
bool isWidthToDefault(PGL::Curve2D {lvalue})
lastKnot
stride
width
class Curve2DArray
__init__( (object)arg1, (int)size) -> None :

Curve2DArray(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Curve2DArray([Curve2D,...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Curve2DArray)arg1, (Curve2D)arg2) -> None :

C++ signature :
void append(PGL::Curve2DArray*,TOOLS::RefCountPtr<PGL::Curve2D>)

append( (Curve2DArray)arg1, (Curve2DArray)arg2) -> None :

C++ signature :
void append(PGL::Curve2DArray*,PGL::Curve2DArray*)
clear()

clear( (Curve2DArray)arg1) -> None :

C++ signature :
void clear(PGL::Curve2DArray {lvalue})
getId()

getId( (Curve2DArray)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Curve2DArray*)
getPglId()

getPglId( (Curve2DArray)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Curve2DArray {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Curve2DArray)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Curve2DArray {lvalue})
insert()

insert( (Curve2DArray)arg1, (int)arg2, (Curve2D)arg3) -> None :

C++ signature :
void insert(PGL::Curve2DArray*,int,TOOLS::RefCountPtr<PGL::Curve2D>)
pop()

pop( (Curve2DArray)arg1 [, (int)arg2]) -> Curve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Curve2D> pop(PGL::Curve2DArray* [,int])
prepend()

prepend( (Curve2DArray)arg1, (Curve2D)arg2) -> None :

C++ signature :
void prepend(PGL::Curve2DArray*,TOOLS::RefCountPtr<PGL::Curve2D>)

prepend( (Curve2DArray)arg1, (Curve2DArray)arg2) -> None :

C++ signature :
void prepend(PGL::Curve2DArray*,PGL::Curve2DArray*)
reverse()

reverse( (Curve2DArray)arg1) -> None :

C++ signature :
void reverse(PGL::Curve2DArray {lvalue})
class CurveArray
__init__( (object)arg1, (int)size) -> None :

CurveArray(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

CurveArray([Curve,...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (CurveArray)arg1, (LineicModel)arg2) -> None :

C++ signature :
void append(PGL::CurveArray*,TOOLS::RefCountPtr<PGL::LineicModel>)

append( (CurveArray)arg1, (CurveArray)arg2) -> None :

C++ signature :
void append(PGL::CurveArray*,PGL::CurveArray*)
clear()

clear( (CurveArray)arg1) -> None :

C++ signature :
void clear(PGL::CurveArray {lvalue})
getId()

getId( (CurveArray)arg1) -> int :

C++ signature :
unsigned long getId(PGL::CurveArray*)
getPglId()

getPglId( (CurveArray)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::CurveArray {lvalue})
getPglReferenceCount()

getPglReferenceCount( (CurveArray)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::CurveArray {lvalue})
insert()

insert( (CurveArray)arg1, (int)arg2, (LineicModel)arg3) -> None :

C++ signature :
void insert(PGL::CurveArray*,int,TOOLS::RefCountPtr<PGL::LineicModel>)
pop()

pop( (CurveArray)arg1 [, (int)arg2]) -> LineicModel :

C++ signature :
TOOLS::RefCountPtr<PGL::LineicModel> pop(PGL::CurveArray* [,int])
prepend()

prepend( (CurveArray)arg1, (LineicModel)arg2) -> None :

C++ signature :
void prepend(PGL::CurveArray*,TOOLS::RefCountPtr<PGL::LineicModel>)

prepend( (CurveArray)arg1, (CurveArray)arg2) -> None :

C++ signature :
void prepend(PGL::CurveArray*,PGL::CurveArray*)
reverse()

reverse( (CurveArray)arg1) -> None :

C++ signature :
void reverse(PGL::CurveArray {lvalue})
class Cylinder

A cylinder structure defined by a radius and a height. Its base is centered at origin.

__init__( (object)arg1 [, (float)radius=0.5 [, (float)height=1.0 [, (bool)solid=True [, (int)slices=8]]]]) -> None :

Cylinder([radius, height, solid, slices])

C++ signature :
void __init__(_object* [,double=0.5 [,double=1.0 [,bool=True [,unsigned char=8]]]])
deepcopy()

deepcopy( (Cylinder)arg1) -> Cylinder :

C++ signature :
TOOLS::RefCountPtr<PGL::Cylinder> deepcopy(PGL::Cylinder {lvalue})

deepcopy( (Cylinder)arg1, (DeepCopier)copier) -> Cylinder :

C++ signature :
TOOLS::RefCountPtr<PGL::Cylinder> deepcopy(PGL::Cylinder {lvalue},PGL::DeepCopier {lvalue})
recast()

recast( (Cylinder)arg1) -> Cylinder :

C++ signature :
TOOLS::RefCountPtr<PGL::Cylinder> recast(PGL::Cylinder*)
class DeepCopier

Base class for recursive deep copy of a scene.

__init__( (object)arg1) -> None :

DeepCopier

C++ signature :
void __init__(_object*)
clear()

clear( (DeepCopier)arg1) -> None :

C++ signature :
void clear(PGL::DeepCopier {lvalue})
class Deformation

Raises an exception This class cannot be instantiated from Python

class Disc

A 2D disc structure centered on origin and defined by a radius.

__init__( (object)arg1 [, (float)radius=0.5 [, (int)slices=8]]) -> None :

Disc(radius, slices)

C++ signature :
void __init__(_object* [,double=0.5 [,unsigned char=8]])
deepcopy()

deepcopy( (Disc)arg1) -> Disc :

C++ signature :
TOOLS::RefCountPtr<PGL::Disc> deepcopy(PGL::Disc {lvalue})

deepcopy( (Disc)arg1, (DeepCopier)copier) -> Disc :

C++ signature :
TOOLS::RefCountPtr<PGL::Disc> deepcopy(PGL::Disc {lvalue},PGL::DeepCopier {lvalue})
isRadiusToDefault()

isRadiusToDefault( (Disc)arg1) -> bool :

C++ signature :
bool isRadiusToDefault(PGL::Disc {lvalue})
radius
recast()

recast( (Disc)arg1) -> Disc :

C++ signature :
TOOLS::RefCountPtr<PGL::Disc> recast(PGL::Disc*)
class ElevationGrid

A regular grid of elevations.

__init__( (object)arg1, (RealArray2)heightList [, (float)xspacing=1.0 [, (float)yspacing=1.0 [, (bool)ccw=True]]]) -> None :

ElevationGrid(heightList [,xspacing,yspacing,ccw])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<TOOLS::RealArray2> [,double=1.0 [,double=1.0 [,bool=True]]])
deepcopy()

deepcopy( (ElevationGrid)arg1) -> ElevationGrid :

C++ signature :
TOOLS::RefCountPtr<PGL::ElevationGrid> deepcopy(PGL::ElevationGrid {lvalue})

deepcopy( (ElevationGrid)arg1, (DeepCopier)copier) -> ElevationGrid :

C++ signature :
TOOLS::RefCountPtr<PGL::ElevationGrid> deepcopy(PGL::ElevationGrid {lvalue},PGL::DeepCopier {lvalue})
getHeightAt()

getHeightAt( (ElevationGrid)arg1, (int)arg2, (int)arg3) -> float :

C++ signature :
double getHeightAt(PGL::ElevationGrid*,unsigned int,unsigned int)
getPointAt()

getPointAt( (ElevationGrid)arg1, (int)arg2, (int)arg3) -> Vector3 :

C++ signature :
TOOLS::Vector3 getPointAt(PGL::ElevationGrid {lvalue},unsigned int,unsigned int)
getXDim()

getXDim( (ElevationGrid)arg1) -> int :

C++ signature :
unsigned int getXDim(PGL::ElevationGrid {lvalue})
getXSize()

getXSize( (ElevationGrid)arg1) -> float :

C++ signature :
double getXSize(PGL::ElevationGrid {lvalue})
getYDim()

getYDim( (ElevationGrid)arg1) -> int :

C++ signature :
unsigned int getYDim(PGL::ElevationGrid {lvalue})
getYSize()

getYSize( (ElevationGrid)arg1) -> float :

C++ signature :
double getYSize(PGL::ElevationGrid {lvalue})
heightList
isXSpacingToDefault()

isXSpacingToDefault( (ElevationGrid)arg1) -> bool :

C++ signature :
bool isXSpacingToDefault(PGL::ElevationGrid {lvalue})
isYSpacingToDefault()

isYSpacingToDefault( (ElevationGrid)arg1) -> bool :

C++ signature :
bool isYSpacingToDefault(PGL::ElevationGrid {lvalue})
recast()

recast( (ElevationGrid)arg1) -> ElevationGrid :

C++ signature :
TOOLS::RefCountPtr<PGL::ElevationGrid> recast(PGL::ElevationGrid*)
xspacing
yspacing
class EulerRotated

The EulerRotated describes an object to which it has been applied a composition of 3 rotations. Rotations angles are the roll around the x-axis, the elevation around the rotated y-axis and azimuth around the rotated z -axis. The equivalent rotation is given by the matrix:

ca*ce ca*se*sr - sa*cr ca*se*cr + sa*sr |
sa*ce ca*cr + sa*se*sr sa*se*cr - ca*sr |
-se ce*sr ce*cr |

where cr = cos(roll), sr = sin(roll), ce = cos(elevation), se = sin(elevation), ca = cos(azimuth) and sa = sin(azimuth).

__init__( (object)arg1 [, (float)azimuth=0.0 [, (float)elevation=0.0 [, (float)roll=0.0 [, (Geometry)geometry=None]]]]) -> None :

EulerRotated(azimuth,elevation,roll,geometry)

C++ signature :
void __init__(_object* [,double=0.0 [,double=0.0 [,double=0.0 [,TOOLS::RefCountPtr<PGL::Geometry>=None]]]])
azimuth
deepcopy()

deepcopy( (EulerRotated)arg1) -> EulerRotated :

C++ signature :
TOOLS::RefCountPtr<PGL::EulerRotated> deepcopy(PGL::EulerRotated {lvalue})

deepcopy( (EulerRotated)arg1, (DeepCopier)copier) -> EulerRotated :

C++ signature :
TOOLS::RefCountPtr<PGL::EulerRotated> deepcopy(PGL::EulerRotated {lvalue},PGL::DeepCopier {lvalue})
elevation
isAzimuthToDefault()

isAzimuthToDefault( (EulerRotated)arg1) -> bool :

C++ signature :
bool isAzimuthToDefault(PGL::EulerRotated {lvalue})
isElevationToDefault()

isElevationToDefault( (EulerRotated)arg1) -> bool :

C++ signature :
bool isElevationToDefault(PGL::EulerRotated {lvalue})
isRollToDefault()

isRollToDefault( (EulerRotated)arg1) -> bool :

C++ signature :
bool isRollToDefault(PGL::EulerRotated {lvalue})
recast()

recast( (EulerRotated)arg1) -> EulerRotated :

C++ signature :
TOOLS::RefCountPtr<PGL::EulerRotated> recast(PGL::EulerRotated*)
roll
class EulerRotation

__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :

C++ signature :
void __init__(_object*,double,double,double)
class ExplicitModel

Explicit geometric representation based on a set of 3D points.

Raises an exception This class cannot be instantiated from Python

colorList
isColorListToDefault()

isColorListToDefault( (ExplicitModel)arg1) -> bool :

C++ signature :
bool isColorListToDefault(PGL::ExplicitModel {lvalue})
pointList
transform()

transform( (ExplicitModel)arg1, (Transformation3D)arg2) -> ExplicitModel :

C++ signature :
TOOLS::RefCountPtr<PGL::ExplicitModel> transform(PGL::ExplicitModel {lvalue},TOOLS::RefCountPtr<PGL::Transformation3D>)
class ExtrudedHull

A hull extruded by a vertical and an horizontal profiles.

__init__( (object)arg1, (Curve2D)vertical, (Curve2D)horizontal [, (bool)ccw=True]) -> None :

ExtrudedHull(vertical,horizontal) : Constructs a ExtrudedHull with the profiles ‘vertical’ and ‘horizontal’.

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2D>,TOOLS::RefCountPtr<PGL::Curve2D> [,bool=True])
ccw
deepcopy()

deepcopy( (ExtrudedHull)arg1) -> ExtrudedHull :

C++ signature :
TOOLS::RefCountPtr<PGL::ExtrudedHull> deepcopy(PGL::ExtrudedHull {lvalue})

deepcopy( (ExtrudedHull)arg1, (DeepCopier)copier) -> ExtrudedHull :

C++ signature :
TOOLS::RefCountPtr<PGL::ExtrudedHull> deepcopy(PGL::ExtrudedHull {lvalue},PGL::DeepCopier {lvalue})
horizontal
isCCWToDefault()

isCCWToDefault( (ExtrudedHull)arg1) -> bool :

C++ signature :
bool isCCWToDefault(PGL::ExtrudedHull {lvalue})
recast()

recast( (ExtrudedHull)arg1) -> ExtrudedHull :

C++ signature :
TOOLS::RefCountPtr<PGL::ExtrudedHull> recast(PGL::ExtrudedHull*)
vertical
class Extrusion

An Extrusion represented by an axis, a cross section and a tranformation function.

__init__( (object)arg1, (LineicModel)axis, (Curve2D)crossSection [, (Point2Array)scaleList=None [, (RealArray)orientationList=None [, (RealArray)knotList=None [, (bool)solid=False [, (bool)ccw=True [, (Vector3)initialNormal=Vector3(0,0,0)]]]]]]) -> None :

Extrusion (LineicModel axis, Curve2D crossSection,[Point2Array scale, RealArray orientation, RealArray knotList, bool solid, bool ccw, Vector3 initialVector])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::LineicModel>,TOOLS::RefCountPtr<PGL::Curve2D> [,TOOLS::RefCountPtr<PGL::Point2Array>=None [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,bool=False [,bool=True [,TOOLS::Vector3=Vector3(0,0,0)]]]]]])
axis
ccw
crossSection
deepcopy()

deepcopy( (Extrusion)arg1) -> Extrusion :

C++ signature :
TOOLS::RefCountPtr<PGL::Extrusion> deepcopy(PGL::Extrusion {lvalue})

deepcopy( (Extrusion)arg1, (DeepCopier)copier) -> Extrusion :

C++ signature :
TOOLS::RefCountPtr<PGL::Extrusion> deepcopy(PGL::Extrusion {lvalue},PGL::DeepCopier {lvalue})
getInitialNormalValue()

getInitialNormalValue( (Extrusion)arg1) -> Vector3 :

C++ signature :
TOOLS::Vector3 getInitialNormalValue(PGL::Extrusion {lvalue})
initialNormal
isCCWToDefault()

isCCWToDefault( (Extrusion)arg1) -> bool :

C++ signature :
bool isCCWToDefault(PGL::Extrusion {lvalue})
isInitialNormalToDefault()

isInitialNormalToDefault( (Extrusion)arg1) -> bool :

C++ signature :
bool isInitialNormalToDefault(PGL::Extrusion {lvalue})
isOrientationToDefault()

isOrientationToDefault( (Extrusion)arg1) -> bool :

C++ signature :
bool isOrientationToDefault(PGL::Extrusion {lvalue})
isScaleToDefault()

isScaleToDefault( (Extrusion)arg1) -> bool :

C++ signature :
bool isScaleToDefault(PGL::Extrusion {lvalue})
isSolidToDefault()

isSolidToDefault( (Extrusion)arg1) -> bool :

C++ signature :
bool isSolidToDefault(PGL::Extrusion {lvalue})
knotList
orientation
orientationList
recast()

recast( (Extrusion)arg1) -> Extrusion :

C++ signature :
TOOLS::RefCountPtr<PGL::Extrusion> recast(PGL::Extrusion*)
scale
scaleList
solid
class FaceSet

A FaceSet describes a surface formed by a set of connected faces. Faces are specified using set of tuples of n indices (Index) pointing to a list of points.

__init__( (object)arg1, (TriangleSet)obj) -> None :

Construct from TriangleSet

C++ signature :
void __init__(_object*,PGL::TriangleSet)
__init__( (object)arg1, (QuadSet)obj) -> None :

Construct from QuadSet

C++ signature :
void __init__(_object*,PGL::QuadSet)
__init__( (object)arg1 [, (Point3Array)pointList=None [, (IndexArray)indexList=None [, (Point3Array)normalList=None [, (IndexArray)normalIndexList=None [, (Color4Array)colorList=None [, (IndexArray)colorIndexList=None [, (Point2Array)texCoordList=None [, (IndexArray)texCoordIndexList=None [, (bool)normalPerVertex=True [, (bool)colorPerVertex=True [, (bool)ccw=True [, (bool)solid=False [, (Polyline)skeleton=None]]]]]]]]]]]]]) -> None :

__init__(Point3Array pointList, IndexArray indexList [, Point3Array normalList, IndexArray nomalIndexList, Color4Array colorList, IndexArray colorIndexList, Point2Array texCoordList, IndexArray texCoordIndexList, bool normalPerVertex, bool colorPerVertex, bool ccw, bool solid, Polyline skeleton])

C++ signature :
void __init__(_object* [,TOOLS::RefCountPtr<PGL::Point3Array>=None [,TOOLS::RefCountPtr<PGL::IndexArray>=None [,TOOLS::RefCountPtr<PGL::Point3Array>=None [,TOOLS::RefCountPtr<PGL::IndexArray>=None [,TOOLS::RefCountPtr<PGL::Color4Array>=None [,TOOLS::RefCountPtr<PGL::IndexArray>=None [,TOOLS::RefCountPtr<PGL::Point2Array>=None [,TOOLS::RefCountPtr<PGL::IndexArray>=None [,bool=True [,bool=True [,bool=True [,bool=False [,TOOLS::RefCountPtr<PGL::Polyline>=None]]]]]]]]]]]]])
colorAt()

colorAt( (FaceSet)arg1, (int)arg2) -> Color4 :

C++ signature :
PGL::Color4 colorAt(PGL::FaceSet {lvalue},unsigned int)
colorIndexAt()

colorIndexAt( (FaceSet)arg1, (int)arg2) -> Index :

C++ signature :
TOOLS::PglVector<unsigned int> colorIndexAt(PGL::FaceSet {lvalue},unsigned int)
colorIndexList
deepcopy()

deepcopy( (FaceSet)arg1) -> FaceSet :

C++ signature :
TOOLS::RefCountPtr<PGL::FaceSet> deepcopy(PGL::FaceSet {lvalue})

deepcopy( (FaceSet)arg1, (DeepCopier)copier) -> FaceSet :

C++ signature :
TOOLS::RefCountPtr<PGL::FaceSet> deepcopy(PGL::FaceSet {lvalue},PGL::DeepCopier {lvalue})
faceColorAt()

faceColorAt( (FaceSet)arg1, (int)arg2, (int)arg3) -> Color4 :

C++ signature :
PGL::Color4 faceColorAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)
faceNormalAt()

faceNormalAt( (FaceSet)arg1, (int)arg2, (int)arg3) -> Vector3 :

C++ signature :
TOOLS::Vector3 faceNormalAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)
faceTexCoordAt()

faceTexCoordAt( (FaceSet)arg1, (int)arg2, (int)arg3) -> Vector2 :

C++ signature :
TOOLS::Vector2 faceTexCoordAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)
indexAt()

indexAt( (FaceSet)arg1, (int)arg2) -> Index :

C++ signature :
TOOLS::PglVector<unsigned int> indexAt(PGL::FaceSet {lvalue},unsigned int)
indexList
isColorIndexListToDefault()

isColorIndexListToDefault( (FaceSet)arg1) -> bool :

C++ signature :
bool isColorIndexListToDefault(PGL::FaceSet {lvalue})
isNormalIndexListToDefault()

isNormalIndexListToDefault( (FaceSet)arg1) -> bool :

C++ signature :
bool isNormalIndexListToDefault(PGL::FaceSet {lvalue})
isTexCoordIndexListToDefault()

isTexCoordIndexListToDefault( (FaceSet)arg1) -> bool :

C++ signature :
bool isTexCoordIndexListToDefault(PGL::FaceSet {lvalue})
normalAt()

normalAt( (FaceSet)arg1, (int)arg2) -> Vector3 :

C++ signature :
TOOLS::Vector3 normalAt(PGL::FaceSet {lvalue},unsigned int)
normalIndexAt()

normalIndexAt( (FaceSet)arg1, (int)arg2) -> Index :

C++ signature :
TOOLS::PglVector<unsigned int> normalIndexAt(PGL::FaceSet {lvalue},unsigned int)
normalIndexList
recast()

recast( (FaceSet)arg1) -> FaceSet :

C++ signature :
TOOLS::RefCountPtr<PGL::FaceSet> recast(PGL::FaceSet*)
texCoordAt()

texCoordAt( (FaceSet)arg1, (int)arg2) -> Vector2 :

C++ signature :
TOOLS::Vector2 texCoordAt(PGL::FaceSet {lvalue},unsigned int)
texCoordIndexAt()

texCoordIndexAt( (FaceSet)arg1, (int)arg2) -> Index :

C++ signature :
TOOLS::PglVector<unsigned int> texCoordIndexAt(PGL::FaceSet {lvalue},unsigned int)
texCoordIndexList
class Font

Font describes how text is displayed.

__init__( (object)arg1 [, (str)family=’’ [, (int)size=10 [, (bool)bold=False [, (bool)italic=False]]]]) -> None :

Font([family,size,bold,italic])

C++ signature :
void __init__(_object* [,std::string=’’ [,int=10 [,bool=False [,bool=False]]]])
bold
deepcopy()

deepcopy( (Font)arg1) -> Font :

C++ signature :
TOOLS::RefCountPtr<PGL::Font> deepcopy(PGL::Font {lvalue})

deepcopy( (Font)arg1, (DeepCopier)copier) -> Font :

C++ signature :
TOOLS::RefCountPtr<PGL::Font> deepcopy(PGL::Font {lvalue},PGL::DeepCopier {lvalue})
family
isBoldToDefault()

isBoldToDefault( (Font)arg1) -> bool :

C++ signature :
bool isBoldToDefault(PGL::Font {lvalue})
isItalicToDefault()

isItalicToDefault( (Font)arg1) -> bool :

C++ signature :
bool isItalicToDefault(PGL::Font {lvalue})
isSizeToDefault()

isSizeToDefault( (Font)arg1) -> bool :

C++ signature :
bool isSizeToDefault(PGL::Font {lvalue})
italic
recast()

recast( (Font)arg1) -> Font :

C++ signature :
TOOLS::RefCountPtr<PGL::Font> recast(PGL::Font*)
size
class Frustum

A frustum structure defined by a base radius, a height and a taper factor. Its base is centered at origin.

__init__( (object)arg1 [, (float)radius=0.5 [, (float)height=1.0 [, (float)taper=0.5 [, (bool)solid=True [, (int)slices=8]]]]]) -> None :

Frustum([radius, height, taper, solid, slices])

C++ signature :
void __init__(_object* [,double=0.5 [,double=1.0 [,double=0.5 [,bool=True [,unsigned char=8]]]]])
deepcopy()

deepcopy( (Frustum)arg1) -> Frustum :

C++ signature :
TOOLS::RefCountPtr<PGL::Frustum> deepcopy(PGL::Frustum {lvalue})

deepcopy( (Frustum)arg1, (DeepCopier)copier) -> Frustum :

C++ signature :
TOOLS::RefCountPtr<PGL::Frustum> deepcopy(PGL::Frustum {lvalue},PGL::DeepCopier {lvalue})
isTaperToDefault()

isTaperToDefault( (Frustum)arg1) -> bool :

C++ signature :
bool isTaperToDefault(PGL::Frustum {lvalue})
recast()

recast( (Frustum)arg1) -> Frustum :

C++ signature :
TOOLS::RefCountPtr<PGL::Frustum> recast(PGL::Frustum*)
taper
class Geometry

Abstract base class for all geometrical structure.

Raises an exception This class cannot be instantiated from Python

isACurve()

isACurve( (Geometry)arg1) -> bool :

C++ signature :
bool isACurve(PGL::Geometry {lvalue})
isASurface()

isASurface( (Geometry)arg1) -> bool :

C++ signature :
bool isASurface(PGL::Geometry {lvalue})
isAVolume()

isAVolume( (Geometry)arg1) -> bool :

C++ signature :
bool isAVolume(PGL::Geometry {lvalue})
isExplicit()

isExplicit( (Geometry)arg1) -> bool :

C++ signature :
bool isExplicit(PGL::Geometry {lvalue})
class GeometryArray
__init__( (object)arg1, (int)size) -> None :

GeometryArray(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

GeometryArray([Geometry,...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (GeometryArray)arg1, (Geometry)arg2) -> None :

C++ signature :
void append(PGL::GeometryArray*,TOOLS::RefCountPtr<PGL::Geometry>)

append( (GeometryArray)arg1, (GeometryArray)arg2) -> None :

C++ signature :
void append(PGL::GeometryArray*,PGL::GeometryArray*)
clear()

clear( (GeometryArray)arg1) -> None :

C++ signature :
void clear(PGL::GeometryArray {lvalue})
getId()

getId( (GeometryArray)arg1) -> int :

C++ signature :
unsigned long getId(PGL::GeometryArray*)
getPglId()

getPglId( (GeometryArray)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::GeometryArray {lvalue})
getPglReferenceCount()

getPglReferenceCount( (GeometryArray)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::GeometryArray {lvalue})
insert()

insert( (GeometryArray)arg1, (int)arg2, (Geometry)arg3) -> None :

C++ signature :
void insert(PGL::GeometryArray*,int,TOOLS::RefCountPtr<PGL::Geometry>)
pop()

pop( (GeometryArray)arg1 [, (int)arg2]) -> Geometry :

C++ signature :
TOOLS::RefCountPtr<PGL::Geometry> pop(PGL::GeometryArray* [,int])
prepend()

prepend( (GeometryArray)arg1, (Geometry)arg2) -> None :

C++ signature :
void prepend(PGL::GeometryArray*,TOOLS::RefCountPtr<PGL::Geometry>)

prepend( (GeometryArray)arg1, (GeometryArray)arg2) -> None :

C++ signature :
void prepend(PGL::GeometryArray*,PGL::GeometryArray*)
reverse()

reverse( (GeometryArray)arg1) -> None :

C++ signature :
void reverse(PGL::GeometryArray {lvalue})
class Group

A Group of Geometry

__init__( (object)arg1, (GeometryArray)geometryList [, (Polyline)skeleton]) -> None :

Group(list geometryList [,Polyline skeleton])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::GeometryArray> [,TOOLS::RefCountPtr<PGL::Polyline>])

__init__( (object)arg1, (Geometry)arg2, (Geometry)arg3) -> object :

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>)

__init__( (object)arg1, (Geometry)arg2, (Geometry)arg3, (Geometry)arg4) -> object :

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>)

__init__( (object)arg1, (Geometry)arg2, (Geometry)arg3, (Geometry)arg4, (Geometry)arg5) -> object :

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>)

__init__( (object)arg1, (Geometry)arg2, (Geometry)arg3, (Geometry)arg4, (Geometry)arg5, (Geometry)arg6) -> object :

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>,TOOLS::RefCountPtr<PGL::Geometry>)
deepcopy()

deepcopy( (Group)arg1) -> Group :

C++ signature :
TOOLS::RefCountPtr<PGL::Group> deepcopy(PGL::Group {lvalue})

deepcopy( (Group)arg1, (DeepCopier)copier) -> Group :

C++ signature :
TOOLS::RefCountPtr<PGL::Group> deepcopy(PGL::Group {lvalue},PGL::DeepCopier {lvalue})
geometryList
isSkeletonToDefault()

isSkeletonToDefault( (Group)arg1) -> bool :

C++ signature :
bool isSkeletonToDefault(PGL::Group {lvalue})
recast()

recast( (Group)arg1) -> Group :

C++ signature :
TOOLS::RefCountPtr<PGL::Group> recast(PGL::Group*)
skeleton
class Hull

Abstract base class for objects of type of 3D envelope.

Raises an exception This class cannot be instantiated from Python

class IFS

The IFS is a recursive transformation applied to an object. Transformation are specified as a set of affine transformations. It is a method for generating fractals and the complexity is exponential with regard to numbers of iterations.

__init__( (object)arg1 [, (int)depth=1 [, (Transform4Array)transfoList=None [, (Geometry)geometry=None]]]) -> None :

IFS(depth, transfoList, geometry)

C++ signature :
void __init__(_object* [,unsigned char=1 [,TOOLS::RefCountPtr<PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > >=None [,TOOLS::RefCountPtr<PGL::Geometry>=None]]])
deepcopy()

deepcopy( (IFS)arg1) -> IFS :

C++ signature :
TOOLS::RefCountPtr<PGL::IFS> deepcopy(PGL::IFS {lvalue})

deepcopy( (IFS)arg1, (DeepCopier)copier) -> IFS :

C++ signature :
TOOLS::RefCountPtr<PGL::IFS> deepcopy(PGL::IFS {lvalue},PGL::DeepCopier {lvalue})
depth
geometry
getAllTransformations()

getAllTransformations( (IFS)arg1) -> Matrix4Array :

C++ signature :
TOOLS::RefCountPtr<TOOLS::Array1<TOOLS::Matrix4> > getAllTransformations(PGL::IFS*)
isDepthToDefault()

isDepthToDefault( (IFS)arg1) -> bool :

C++ signature :
bool isDepthToDefault(PGL::IFS {lvalue})
recast()

recast( (IFS)arg1) -> IFS :

C++ signature :
TOOLS::RefCountPtr<PGL::IFS> recast(PGL::IFS*)
transfoList
class ImageTexture

The image of a textured object.

__init__( (object)arg1, (str)filename [, (float)transparency=0.0 [, (bool)repeatS=True [, (bool)repeatT=True [, (bool)mipmaping=True]]]]) -> None :

ImageTexture(filename [, transparency, repeatS, repeatT, mipmaping])

C++ signature :
void __init__(_object*,std::string [,double=0.0 [,bool=True [,bool=True [,bool=True]]]])
__init__( (object)arg1, (str)name, (str)filename [, (float)transparency=0.0 [, (bool)repeatS=True [, (bool)repeatT=True [, (bool)mipmaping=True]]]]) -> None :

ImageTexture(name, filename [, transparency, repeatS, repeatT, mipmaping])

C++ signature :
void __init__(_object*,std::string,std::string [,double=0.0 [,bool=True [,bool=True [,bool=True]]]])
filename
isMipmapingToDefault()

isMipmapingToDefault( (ImageTexture)arg1) -> bool :

C++ signature :
bool isMipmapingToDefault(PGL::ImageTexture {lvalue})
isRepeatSToDefault()

isRepeatSToDefault( (ImageTexture)arg1) -> bool :

C++ signature :
bool isRepeatSToDefault(PGL::ImageTexture {lvalue})
isRepeatTToDefault()

isRepeatTToDefault( (ImageTexture)arg1) -> bool :

C++ signature :
bool isRepeatTToDefault(PGL::ImageTexture {lvalue})
isTransparencyToDefault()

isTransparencyToDefault( (ImageTexture)arg1) -> bool :

C++ signature :
bool isTransparencyToDefault(PGL::ImageTexture {lvalue})
mipmaping
repeatS
repeatT
transparency
class Index

A set of indices

__init__( (object)arg1, (int)size) -> None :

Index(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Index([int i, int j, int k, ...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4) -> object :

Index(int i, int j, int k)

C++ signature :
void* __init__(boost::python::api::object,unsigned int,unsigned int,unsigned int)
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> object :

Index(int i, int j, int k, int l)

C++ signature :
void* __init__(boost::python::api::object,unsigned int,unsigned int,unsigned int,unsigned int)
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5, (int)arg6) -> object :

Index(int i, int j, int k, int l, int m)

C++ signature :
void* __init__(boost::python::api::object,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)
append()

append( (Index)arg1, (int)arg2) -> None :

C++ signature :
void append(TOOLS::PglVector<unsigned int>*,unsigned int)

append( (Index)arg1, (Index)arg2) -> None :

C++ signature :
void append(TOOLS::PglVector<unsigned int>*,TOOLS::PglVector<unsigned int>*)
clear()

clear( (Index)arg1) -> None :

C++ signature :
void clear(TOOLS::PglVector<unsigned int> {lvalue})
getId()

getId( (Index)arg1) -> int :

C++ signature :
unsigned long getId(TOOLS::PglVector<unsigned int>*)
insert()

insert( (Index)arg1, (int)arg2, (int)arg3) -> None :

C++ signature :
void insert(TOOLS::PglVector<unsigned int>*,int,unsigned int)
pop()

pop( (Index)arg1 [, (int)arg2]) -> int :

C++ signature :
unsigned int pop(TOOLS::PglVector<unsigned int>* [,int])
prepend()

prepend( (Index)arg1, (int)arg2) -> None :

C++ signature :
void prepend(TOOLS::PglVector<unsigned int>*,unsigned int)

prepend( (Index)arg1, (Index)arg2) -> None :

C++ signature :
void prepend(TOOLS::PglVector<unsigned int>*,TOOLS::PglVector<unsigned int>*)
reverse()

reverse( (Index)arg1) -> None :

C++ signature :
void reverse(TOOLS::PglVector<unsigned int> {lvalue})
class Index3

A set of 3 indices

__init__( (object)arg1 [, (int)arg2 [, (int)arg3 [, (int)arg4]]]) -> None :

C++ signature :
void __init__(_object* [,unsigned long [,unsigned long [,unsigned long]]])
class Index3Array
__init__( (object)arg1, (int)size) -> None :

Index3Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Index3Array([Index3(i,j,k),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Index3Array)arg1, (Index3)arg2) -> None :

C++ signature :
void append(PGL::Index3Array*,TOOLS::Tuple3<unsigned int>)

append( (Index3Array)arg1, (Index3Array)arg2) -> None :

C++ signature :
void append(PGL::Index3Array*,PGL::Index3Array*)
clear()

clear( (Index3Array)arg1) -> None :

C++ signature :
void clear(PGL::Index3Array {lvalue})
getId()

getId( (Index3Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Index3Array*)
getPglId()

getPglId( (Index3Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Index3Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Index3Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Index3Array {lvalue})
insert()

insert( (Index3Array)arg1, (int)arg2, (Index3)arg3) -> None :

C++ signature :
void insert(PGL::Index3Array*,int,TOOLS::Tuple3<unsigned int>)
pop()

pop( (Index3Array)arg1 [, (int)arg2]) -> Index3 :

C++ signature :
TOOLS::Tuple3<unsigned int> pop(PGL::Index3Array* [,int])
prepend()

prepend( (Index3Array)arg1, (Index3)arg2) -> None :

C++ signature :
void prepend(PGL::Index3Array*,TOOLS::Tuple3<unsigned int>)

prepend( (Index3Array)arg1, (Index3Array)arg2) -> None :

C++ signature :
void prepend(PGL::Index3Array*,PGL::Index3Array*)
reverse()

reverse( (Index3Array)arg1) -> None :

C++ signature :
void reverse(PGL::Index3Array {lvalue})
class Index4

A set of 4 indices

__init__( (object)arg1 [, (int)arg2 [, (int)arg3 [, (int)arg4 [, (int)arg5]]]]) -> None :

C++ signature :
void __init__(_object* [,unsigned long [,unsigned long [,unsigned long [,unsigned long]]]])
class Index4Array
__init__( (object)arg1, (int)size) -> None :

Index4Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Index4Array([Index4(i,j,k,l),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Index4Array)arg1, (Index4)arg2) -> None :

C++ signature :
void append(PGL::Index4Array*,TOOLS::Tuple4<unsigned int>)

append( (Index4Array)arg1, (Index4Array)arg2) -> None :

C++ signature :
void append(PGL::Index4Array*,PGL::Index4Array*)
clear()

clear( (Index4Array)arg1) -> None :

C++ signature :
void clear(PGL::Index4Array {lvalue})
getId()

getId( (Index4Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Index4Array*)
getPglId()

getPglId( (Index4Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Index4Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Index4Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Index4Array {lvalue})
insert()

insert( (Index4Array)arg1, (int)arg2, (Index4)arg3) -> None :

C++ signature :
void insert(PGL::Index4Array*,int,TOOLS::Tuple4<unsigned int>)
pop()

pop( (Index4Array)arg1 [, (int)arg2]) -> Index4 :

C++ signature :
TOOLS::Tuple4<unsigned int> pop(PGL::Index4Array* [,int])
prepend()

prepend( (Index4Array)arg1, (Index4)arg2) -> None :

C++ signature :
void prepend(PGL::Index4Array*,TOOLS::Tuple4<unsigned int>)

prepend( (Index4Array)arg1, (Index4Array)arg2) -> None :

C++ signature :
void prepend(PGL::Index4Array*,PGL::Index4Array*)
reverse()

reverse( (Index4Array)arg1) -> None :

C++ signature :
void reverse(PGL::Index4Array {lvalue})
triangulate()

triangulate( (Index4Array)arg1) -> Index3Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Index3Array> triangulate(PGL::Index4Array {lvalue})
class IndexArray
__init__( (object)arg1, (int)size) -> None :

IndexArray(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

IndexArray([Index([i,j,..]),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (IndexArray)arg1, (Index)arg2) -> None :

C++ signature :
void append(PGL::IndexArray*,TOOLS::PglVector<unsigned int>)

append( (IndexArray)arg1, (IndexArray)arg2) -> None :

C++ signature :
void append(PGL::IndexArray*,PGL::IndexArray*)
clear()

clear( (IndexArray)arg1) -> None :

C++ signature :
void clear(PGL::IndexArray {lvalue})
getId()

getId( (IndexArray)arg1) -> int :

C++ signature :
unsigned long getId(PGL::IndexArray*)
getPglId()

getPglId( (IndexArray)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::IndexArray {lvalue})
getPglReferenceCount()

getPglReferenceCount( (IndexArray)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::IndexArray {lvalue})
insert()

insert( (IndexArray)arg1, (int)arg2, (Index)arg3) -> None :

C++ signature :
void insert(PGL::IndexArray*,int,TOOLS::PglVector<unsigned int>)
pop()

pop( (IndexArray)arg1 [, (int)arg2]) -> Index :

C++ signature :
TOOLS::PglVector<unsigned int> pop(PGL::IndexArray* [,int])
prepend()

prepend( (IndexArray)arg1, (Index)arg2) -> None :

C++ signature :
void prepend(PGL::IndexArray*,TOOLS::PglVector<unsigned int>)

prepend( (IndexArray)arg1, (IndexArray)arg2) -> None :

C++ signature :
void prepend(PGL::IndexArray*,PGL::IndexArray*)
reverse()

reverse( (IndexArray)arg1) -> None :

C++ signature :
void reverse(PGL::IndexArray {lvalue})
triangulate()

triangulate( (IndexArray)arg1) -> Index3Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Index3Array> triangulate(PGL::IndexArray {lvalue})
class LineicModel

Abstract base class for all lineic model.

Raises an exception This class cannot be instantiated from Python

findClosest()
findClosest( (LineicModel)arg1, (Vector3)point) -> object :

findClosest(point) : return closestpoint, u

C++ signature :
boost::python::api::object findClosest(PGL::LineicModel*,TOOLS::Vector3)
firstKnot
getArcLengthToUMapping()
getArcLengthToUMapping( (LineicModel)arg1) -> QuantisedFunction :

getArcLengthToUMapping() : Return a function that gives for each arc length the u parametrization of the curve.

C++ signature :
TOOLS::RefCountPtr<PGL::QuantisedFunction> getArcLengthToUMapping(PGL::LineicModel {lvalue})
getLength()

getLength( (LineicModel)arg1) -> float :

C++ signature :
double getLength(PGL::LineicModel {lvalue})

getLength( (LineicModel)arg1, (float)begin) -> float :

C++ signature :
double getLength(PGL::LineicModel {lvalue},double)
getLength( (LineicModel)arg1, (float)begin, (float)end) -> float :

getLength([begin,end]) : Return length of the curve from u = begin to u = end.

C++ signature :
double getLength(PGL::LineicModel {lvalue},double,double)
getNormalAt()

getNormalAt( (LineicModel)arg1, (float)u) -> Vector3 :

C++ signature :
TOOLS::Vector3 getNormalAt(PGL::LineicModel const*,double)
getPointAt()

getPointAt( (LineicModel)arg1, (float)u) -> Vector3 :

C++ signature :
TOOLS::Vector3 getPointAt(PGL::LineicModel const*,double)
getTangentAt()

getTangentAt( (LineicModel)arg1, (float)u) -> Vector3 :

C++ signature :
TOOLS::Vector3 getTangentAt(PGL::LineicModel const*,double)
getUToArcLengthMapping()
getUToArcLengthMapping( (LineicModel)arg1) -> QuantisedFunction :

getUToArcLengthMapping() : Return a function that gives for each u the arc length parametrization of the curve.

C++ signature :
TOOLS::RefCountPtr<PGL::QuantisedFunction> getUToArcLengthMapping(PGL::LineicModel {lvalue})
isWidthToDefault()

isWidthToDefault( (LineicModel)arg1) -> bool :

C++ signature :
bool isWidthToDefault(PGL::LineicModel {lvalue})
lastKnot
stride
width
class Material

The material of an object. It determine the way light reflect off an object to create color.

__init__( (object)arg1, (Material)arg2) -> None :

C++ signature :
void __init__(_object*,PGL::Material)
__init__( (object)arg1 [, (Color3)ambient=Color3(80,80,80) [, (float)diffuse=2.0 [, (Color3)specular=Color3(40,40,40) [, (Color3)emission=Color3(0,0,0) [, (float)shininess=1.0 [, (float)transparency=0.0]]]]]]) -> None :

Material( ambient=(160,160,160),diffuse=1,specular=(40,40,40),emission=(0,0,0),shininess=1,transparency=0)

C++ signature :
void __init__(_object* [,PGL::Color3=Color3(80,80,80) [,double=2.0 [,PGL::Color3=Color3(40,40,40) [,PGL::Color3=Color3(0,0,0) [,double=1.0 [,double=0.0]]]]]])
__init__( (object)arg1, (str)name [, (Color3)ambient=Color3(80,80,80) [, (float)diffuse=2.0 [, (Color3)specular=Color3(40,40,40) [, (Color3)emission=Color3(0,0,0) [, (float)shininess=1.0 [, (float)transparency=0.0]]]]]]) -> None :

Material( name, ambient=(160,160,160), diffuse=1, specular=(40,40,40), emission=(0,0,0), shininess=1, transparency=0)

C++ signature :
void __init__(_object*,std::string [,PGL::Color3=Color3(80,80,80) [,double=2.0 [,PGL::Color3=Color3(40,40,40) [,PGL::Color3=Color3(0,0,0) [,double=1.0 [,double=0.0]]]]]])
ambient
deepcopy()

deepcopy( (Material)arg1) -> Material :

C++ signature :
TOOLS::RefCountPtr<PGL::Material> deepcopy(PGL::Material {lvalue})

deepcopy( (Material)arg1, (DeepCopier)copier) -> Material :

C++ signature :
TOOLS::RefCountPtr<PGL::Material> deepcopy(PGL::Material {lvalue},PGL::DeepCopier {lvalue})
diffuse
emission
isAmbientToDefault()

isAmbientToDefault( (Material)arg1) -> bool :

C++ signature :
bool isAmbientToDefault(PGL::Material {lvalue})
isDiffuseToDefault()

isDiffuseToDefault( (Material)arg1) -> bool :

C++ signature :
bool isDiffuseToDefault(PGL::Material {lvalue})
isEmissionToDefault()

isEmissionToDefault( (Material)arg1) -> bool :

C++ signature :
bool isEmissionToDefault(PGL::Material {lvalue})
isShininessToDefault()

isShininessToDefault( (Material)arg1) -> bool :

C++ signature :
bool isShininessToDefault(PGL::Material {lvalue})
isSimilar()

isSimilar( (Material)arg1, (Material)arg2) -> bool :

C++ signature :
bool isSimilar(PGL::Material {lvalue},PGL::Material)
isSpecularToDefault()

isSpecularToDefault( (Material)arg1) -> bool :

C++ signature :
bool isSpecularToDefault(PGL::Material {lvalue})
isTransparencyToDefault()

isTransparencyToDefault( (Material)arg1) -> bool :

C++ signature :
bool isTransparencyToDefault(PGL::Material {lvalue})
recast()

recast( (Material)arg1) -> Material :

C++ signature :
TOOLS::RefCountPtr<PGL::Material> recast(PGL::Material*)
shininess
specular
transparency
class Matrix3Transformation

Raises an exception This class cannot be instantiated from Python

class Matrix4Array
__init__( (object)arg1, (int)size) -> None :

Matrix4Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Matrix4Array([Matrix4(...),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Matrix4Array)arg1, (Matrix4)arg2) -> None :

C++ signature :
void append(TOOLS::Array1<TOOLS::Matrix4>*,TOOLS::Matrix4)

append( (Matrix4Array)arg1, (Matrix4Array)arg2) -> None :

C++ signature :
void append(TOOLS::Array1<TOOLS::Matrix4>*,TOOLS::Array1<TOOLS::Matrix4>*)
clear()

clear( (Matrix4Array)arg1) -> None :

C++ signature :
void clear(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
getId()

getId( (Matrix4Array)arg1) -> int :

C++ signature :
unsigned long getId(TOOLS::Array1<TOOLS::Matrix4>*)
getPglId()

getPglId( (Matrix4Array)arg1) -> int :

C++ signature :
unsigned long getPglId(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Matrix4Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
insert()

insert( (Matrix4Array)arg1, (int)arg2, (Matrix4)arg3) -> None :

C++ signature :
void insert(TOOLS::Array1<TOOLS::Matrix4>*,int,TOOLS::Matrix4)
pop()

pop( (Matrix4Array)arg1 [, (int)arg2]) -> Matrix4 :

C++ signature :
TOOLS::Matrix4 pop(TOOLS::Array1<TOOLS::Matrix4>* [,int])
prepend()

prepend( (Matrix4Array)arg1, (Matrix4)arg2) -> None :

C++ signature :
void prepend(TOOLS::Array1<TOOLS::Matrix4>*,TOOLS::Matrix4)

prepend( (Matrix4Array)arg1, (Matrix4Array)arg2) -> None :

C++ signature :
void prepend(TOOLS::Array1<TOOLS::Matrix4>*,TOOLS::Array1<TOOLS::Matrix4>*)
reverse()

reverse( (Matrix4Array)arg1) -> None :

C++ signature :
void reverse(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
class Matrix4Transformation

Raises an exception This class cannot be instantiated from Python

getMatrix()

getMatrix( (Matrix4Transformation)arg1) -> Matrix4 :

C++ signature :
TOOLS::Matrix4 getMatrix(PGL::Matrix4Transformation {lvalue})
class MatrixTransformed

Abstract base class for objects on which a transformation that can be express as a matrix is applied.

Raises an exception This class cannot be instantiated from Python

geometry
class Mesh

Abstract base class for objects of type of mesh.

Raises an exception This class cannot be instantiated from Python

ccw
colorPerVertex
computeNormalList()

computeNormalList( (Mesh)arg1) -> None :

C++ signature :
void computeNormalList(PGL::Mesh {lvalue})
faceCenter()

faceCenter( (Mesh)arg1, (int)arg2) -> Vector3 :

C++ signature :
TOOLS::Vector3 faceCenter(PGL::Mesh {lvalue},unsigned int)
faceSize()

faceSize( (Mesh)arg1, (int)arg2) -> int :

C++ signature :
unsigned int faceSize(PGL::Mesh {lvalue},unsigned int)
indexListSize()

indexListSize( (Mesh)arg1) -> int :

C++ signature :
unsigned int indexListSize(PGL::Mesh {lvalue})
isCCWToDefault()

isCCWToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isCCWToDefault(PGL::Mesh {lvalue})
isColorPerVertexToDefault()

isColorPerVertexToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isColorPerVertexToDefault(PGL::Mesh {lvalue})
isNormalListToDefault()

isNormalListToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isNormalListToDefault(PGL::Mesh {lvalue})
isNormalPerVertexToDefault()

isNormalPerVertexToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isNormalPerVertexToDefault(PGL::Mesh {lvalue})
isSkeletonToDefault()

isSkeletonToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isSkeletonToDefault(PGL::Mesh {lvalue})
isSolidToDefault()

isSolidToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isSolidToDefault(PGL::Mesh {lvalue})
isTexCoordListToDefault()

isTexCoordListToDefault( (Mesh)arg1) -> bool :

C++ signature :
bool isTexCoordListToDefault(PGL::Mesh {lvalue})
normalList
normalPerVertex
pointAt()

pointAt( (Mesh)arg1, (int)arg2) -> Vector3 :

C++ signature :
TOOLS::Vector3 pointAt(PGL::Mesh {lvalue},unsigned int)

pointAt( (Mesh)arg1, (int)arg2, (int)arg3) -> Vector3 :

C++ signature :
TOOLS::Vector3 pointAt(PGL::Mesh {lvalue},unsigned int,unsigned int)
skeleton
solid
texCoordList
class MonoSpectral

Mono spectral appearance property of an object.

__init__( (object)arg1 [, (float)arg2 [, (float)arg3]]) -> None :

MonoSpectral([ reflectance, transmittance ])

C++ signature :
void __init__(_object* [,double [,double]])
deepcopy()

deepcopy( (MonoSpectral)arg1) -> MonoSpectral :

C++ signature :
TOOLS::RefCountPtr<PGL::MonoSpectral> deepcopy(PGL::MonoSpectral {lvalue})

deepcopy( (MonoSpectral)arg1, (DeepCopier)copier) -> MonoSpectral :

C++ signature :
TOOLS::RefCountPtr<PGL::MonoSpectral> deepcopy(PGL::MonoSpectral {lvalue},PGL::DeepCopier {lvalue})
recast()

recast( (MonoSpectral)arg1) -> MonoSpectral :

C++ signature :
TOOLS::RefCountPtr<PGL::MonoSpectral> recast(PGL::MonoSpectral*)
reflectance
transmittance
class MultiSpectral

Multi spectral appearance property of an object.

__init__( (object)arg1, (RealArray)arg2, (RealArray)arg3 [, (Index3)arg4]) -> None :

MultiSpectral(reflectance= RealArray, transmittance= RealArray [, filter= index3])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<TOOLS::RealArray>,TOOLS::RefCountPtr<TOOLS::RealArray> [,TOOLS::Tuple3<unsigned int>])
deepcopy()

deepcopy( (MultiSpectral)arg1) -> MultiSpectral :

C++ signature :
TOOLS::RefCountPtr<PGL::MultiSpectral> deepcopy(PGL::MultiSpectral {lvalue})

deepcopy( (MultiSpectral)arg1, (DeepCopier)copier) -> MultiSpectral :

C++ signature :
TOOLS::RefCountPtr<PGL::MultiSpectral> deepcopy(PGL::MultiSpectral {lvalue},PGL::DeepCopier {lvalue})
recast()

recast( (MultiSpectral)arg1) -> MultiSpectral :

C++ signature :
TOOLS::RefCountPtr<PGL::MultiSpectral> recast(PGL::MultiSpectral*)
class NurbsCurve

NURBS Curve describes rational and non rational B-Spline curves. It is defined from a list of control points Pi, a knots vector and a degree p.It uses the parametric equation C(u) = Sum(i=0,n)(Ri,p(u)Pi with u in [a,b]where the Ri,p(u) are p-th degree rational basis functions defined on the knot vector.

__init__( (object)arg1, (Point4Array)ctrlPointList [, (int)degree=3 [, (RealArray)knotList=None [, (int)stride=30 [, (int)width=1]]]]) -> None :

NurbsCurve(ctrlPointList[,degree,knotList,stride])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Array> [,unsigned int=3 [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,unsigned int=30 [,unsigned char=1]]]])

__init__( (object)arg1, (Point4Array)arg2, (RealArray)arg3 [, (int)arg4 [, (int)arg5 [, (int)arg6]]]) -> None :

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Array>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int [,unsigned int [,unsigned char]]])
static CBezier(ctrl_points, uniform=False, stride=60)

Construct a nurbs from a set of ctrl_points

ctrl_points are control points in space that define a cubic bezier nurbs as proposed in svg norm http://www.w3.org/TR/SVG/paths.html#PathDataCurveCommands

An arc i of the resulting curve will interpolate points 4 * i, 4 * i +1, 4 * i + 2, 4 * i + 3.

Parameters :
  • ctrl_points (list of Vector) - a list

    of control points

  • uniform (bool) - if True, the parameterization

    of the curve will be chosen such that each segment will be of length 1 in u space, wathever its real geometrical size.

  • stride (int) - number of points to discretize

    the curve

Returns Type:

:class:NurbsCurve

static CSpline(pts, is_closed=False, is_linear=False, distances=None)

Build a nurbs curve by interpolate (C1) the points pts. The resulting curve can be closed.

basisFunctions()
basisFunctions( (int)span, (float)u, (int)degree, (RealArray)knotList) -> RealArray :

[float] basisFunctions(int span, float u, int degree, [float] knotList).Compute the Basis Functions values at a given u for degree and on the knot vector knotList.See Algo 2.2 From The Nurbs Book p70.

C++ signature :
TOOLS::RefCountPtr<TOOLS::RealArray> basisFunctions(unsigned int,double,unsigned int,TOOLS::RefCountPtr<TOOLS::RealArray>)
deepcopy()

deepcopy( (NurbsCurve)arg1) -> NurbsCurve :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsCurve> deepcopy(PGL::NurbsCurve {lvalue})

deepcopy( (NurbsCurve)arg1, (DeepCopier)copier) -> NurbsCurve :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsCurve> deepcopy(PGL::NurbsCurve {lvalue},PGL::DeepCopier {lvalue})
defaultKnotList()
defaultKnotList( (int)nbCtrlPoints, (int)degree) -> RealArray :

Compute a default knot list for a curve of n control points and a degree d

C++ signature :
TOOLS::RefCountPtr<TOOLS::RealArray> defaultKnotList(unsigned int,unsigned int)
defaultKnotListTest()
defaultKnotListTest( (RealArray)knots, (int)nbCtrlPoints, (int)degree) -> bool :

Test whether knots corresponds to a default knot list for a curve of n control points and a degree d

C++ signature :
bool defaultKnotListTest(TOOLS::RefCountPtr<TOOLS::RealArray>,unsigned int,unsigned int)
degree
derivatesBasisFunctions()
derivatesBasisFunctions( (int)n, (float)u, (int)span, (int)degree, (RealArray)knotList) -> RealArray2 :

[float] derivatesBasisFunctions(int span, float u, int _degree, [float] _knotList).Compute the n-th Derivative Basis Functions values at a given u for degree and on the knot vector knotList.See Algo 2.2 From The Nurbs Book p70.

C++ signature :
TOOLS::RefCountPtr<TOOLS::RealArray2> derivatesBasisFunctions(int,double,int,unsigned int,TOOLS::RefCountPtr<TOOLS::RealArray>)
findSpan()
findSpan( (float)u, (int)degree, (RealArray)knotList) -> int :

int findSpan(float u, int degree, [float] knotList).Determine the knot Span index at a given u for degree and on the knot vector knotList.See the Nurbs Book : A2.1 p68

C++ signature :
unsigned int findSpan(double,unsigned int,TOOLS::RefCountPtr<TOOLS::RealArray>)
fit()
fit([ (Point3Array)points=None [, (int)degree=3 [, (int)nbctrlpoints=4]]]) -> object :

fit(points [, int degree, int nbctrlpoints])

C++ signature :
boost::python::api::object fit([ TOOLS::RefCountPtr<PGL::Point3Array>=None [,int=3 [,int=4]]])
getDerivativeAt()

getDerivativeAt( (NurbsCurve)arg1, (float)u, (int)d) -> Vector4 :

C++ signature :
TOOLS::Vector4 getDerivativeAt(PGL::NurbsCurve {lvalue},double,int)
getDerivativesAt()

getDerivativesAt( (NurbsCurve)arg1, (float)u) -> Point4Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Array> getDerivativesAt(PGL::NurbsCurve {lvalue},double)
isDegreeToDefault()

isDegreeToDefault( (NurbsCurve)arg1) -> bool :

C++ signature :
bool isDegreeToDefault(PGL::NurbsCurve {lvalue})
isKnotListToDefault()

isKnotListToDefault( (NurbsCurve)arg1) -> bool :

C++ signature :
bool isKnotListToDefault(PGL::NurbsCurve {lvalue})
knotList
recast()

recast( (NurbsCurve)arg1) -> NurbsCurve :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsCurve> recast(PGL::NurbsCurve*)
setKnotListToDefault()

setKnotListToDefault( (NurbsCurve)arg1) -> bool :

C++ signature :
bool setKnotListToDefault(PGL::NurbsCurve {lvalue})
class NurbsCurve2D

A 2D NURBS Curve represented by an array of control Points, a knots list and a degree. See NurbsCurve.

__init__( (object)arg1, (Point3Array)ctrlPointList [, (int)degree=3 [, (RealArray)knotList=None [, (int)stride=30 [, (int)width=1]]]]) -> None :

NurbsCurve2D(ctrlPointList[,degree,knotList,stride])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,unsigned int=3 [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,unsigned int=30 [,unsigned char=1]]]])

__init__( (object)arg1, (Point3Array)ctrlPointList, (RealArray)knotList [, (int)degree [, (int)stride [, (int)width]]]) -> None :

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int [,unsigned int [,unsigned char]]])
static CBezier(ctrl_points, uniform=False, stride=60)

Construct a nurbs from a set of ctrl_points

ctrl_points are control points in space that define a cubic bezier nurbs as proposed in svg norm http://www.w3.org/TR/SVG/paths.html#PathDataCurveCommands

An arc i of the resulting curve will interpolate points 4 * i, 4 * i +1, 4 * i + 2, 4 * i + 3.

Parameters :
  • ctrl_points (list of Vector) - a list

    of control points

  • uniform (bool) - if True, the parameterization

    of the curve will be chosen such that each segment will be of length 1 in u space, wathever its real geometrical size.

  • stride (int) - number of points to discretize

    the curve

Returns Type:

:class:NurbsCurve2D

deepcopy()

deepcopy( (NurbsCurve2D)arg1) -> NurbsCurve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsCurve2D> deepcopy(PGL::NurbsCurve2D {lvalue})

deepcopy( (NurbsCurve2D)arg1, (DeepCopier)copier) -> NurbsCurve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsCurve2D> deepcopy(PGL::NurbsCurve2D {lvalue},PGL::DeepCopier {lvalue})
degree
fit()

fit( (Point2Array)points) -> object :

C++ signature :
boost::python::api::object fit(TOOLS::RefCountPtr<PGL::Point2Array>)
fit( (Point2Array)points, (int)degree, (int)nbctrlpoints) -> object :

fit(points [, int degree, int nbctrlpoints])

C++ signature :
boost::python::api::object fit(TOOLS::RefCountPtr<PGL::Point2Array>,int,int)

fit( (Polyline2D)points) -> object :

C++ signature :
boost::python::api::object fit(PGL::Polyline2D*)

fit( (Polyline2D)points, (int)degree, (int)nbctrlpoints) -> object :

C++ signature :
boost::python::api::object fit(PGL::Polyline2D*,int,int)
isDegreeToDefault()

isDegreeToDefault( (NurbsCurve2D)arg1) -> bool :

C++ signature :
bool isDegreeToDefault(PGL::NurbsCurve2D {lvalue})
isKnotListToDefault()

isKnotListToDefault( (NurbsCurve2D)arg1) -> bool :

C++ signature :
bool isKnotListToDefault(PGL::NurbsCurve2D {lvalue})
knotList
recast()

recast( (NurbsCurve2D)arg1) -> NurbsCurve2D :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsCurve2D> recast(PGL::NurbsCurve2D*)
setKnotListToDefault()

setKnotListToDefault( (NurbsCurve2D)arg1) -> bool :

C++ signature :
bool setKnotListToDefault(PGL::NurbsCurve2D {lvalue})
class NurbsPatch

NurbsPatch describes rational and non rational Bezier surface. It is defined by two degrees n and m and a matrix of control Points Pi,j and using the parametric equation S(u,v) = Sum(i=0,n)Sum(j=0,m)(Ri,n(u)Rj,m(v)Pi,j) with u and v in [0,1] where Ri,n(u) and Ri,m(v) are classical n and m-th degree rational basis function.

__init__( (object)arg1, (Point4Matrix)arg2 [, (RealArray)arg3 [, (RealArray)arg4 [, (int)arg5 [, (int)arg6 [, (int)arg7 [, (int)arg8 [, (bool)arg9]]]]]]]) -> None :

NurbsPatch(Point4Matrix ctrlPointList, RealArray uKnotList,RealArray vKnotList [,uDeg, vDeg,ustride,vstride,ccw])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Matrix> [,TOOLS::RefCountPtr<TOOLS::RealArray> [,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int [,unsigned int [,unsigned int [,unsigned int [,bool]]]]]]])
__init__( (object)arg1, (Point4Matrix)ctrlPointList [, (int)udegree=3 [, (int)vdegree=3 [, (RealArray)uknotList=None [, (RealArray)vknotList=None [, (int)ustride=30 [, (int)vstride=30 [, (bool)ccw=True]]]]]]]) -> None :

NurbsPatch(Point4Matrix ctrlPointList, udegree, vdegree,uknotList, vknotList [,ustride,vstride,ccw])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Matrix> [,unsigned int=3 [,unsigned int=3 [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,unsigned int=30 [,unsigned int=30 [,bool=True]]]]]]])
deepcopy()

deepcopy( (NurbsPatch)arg1) -> NurbsPatch :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsPatch> deepcopy(PGL::NurbsPatch {lvalue})

deepcopy( (NurbsPatch)arg1, (DeepCopier)copier) -> NurbsPatch :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsPatch> deepcopy(PGL::NurbsPatch {lvalue},PGL::DeepCopier {lvalue})
deriveAt()

deriveAt( (NurbsPatch)arg1, (float)u, (float)v, (int)d, (int)uspan, (int)vspan) -> Point4Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Matrix> deriveAt(PGL::NurbsPatch {lvalue},double,double,int,int,int)
getDerivativeAt()
getDerivativeAt( (NurbsPatch)arg1, (float)u, (float)v, (int)du, (int)dv) -> Vector4 :

Return the derivative at u and v. du and dv specify how many time you want to derive with respect to u and v.

C++ signature :
TOOLS::Vector4 getDerivativeAt(PGL::NurbsPatch {lvalue},double,double,int,int)
getDerivativesAt()

getDerivativesAt( (NurbsPatch)arg1, (float)u, (float)v) -> Point4Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Matrix> getDerivativesAt(PGL::NurbsPatch {lvalue},double,double)
getNormalAt()

getNormalAt( (NurbsPatch)arg1, (float)u, (float)v) -> Vector3 :

C++ signature :
TOOLS::Vector3 getNormalAt(PGL::NurbsPatch {lvalue},double,double)
getUTangentAt()

getUTangentAt( (NurbsPatch)arg1, (float)u, (float)v) -> Vector3 :

C++ signature :
TOOLS::Vector3 getUTangentAt(PGL::NurbsPatch {lvalue},double,double)
getVTangentAt()

getVTangentAt( (NurbsPatch)arg1, (float)u, (float)v) -> Vector3 :

C++ signature :
TOOLS::Vector3 getVTangentAt(PGL::NurbsPatch {lvalue},double,double)
isUDegreeToDefault()

isUDegreeToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :
bool isUDegreeToDefault(PGL::NurbsPatch {lvalue})
isUKnotListToDefault()

isUKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :
bool isUKnotListToDefault(PGL::NurbsPatch {lvalue})
isVDegreeToDefault()

isVDegreeToDefault( (NurbsPatch)arg1) -> int :

C++ signature :
unsigned int isVDegreeToDefault(PGL::NurbsPatch {lvalue})
isVKnotListToDefault()

isVKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :
bool isVKnotListToDefault(PGL::NurbsPatch {lvalue})
recast()

recast( (NurbsPatch)arg1) -> NurbsPatch :

C++ signature :
TOOLS::RefCountPtr<PGL::NurbsPatch> recast(PGL::NurbsPatch*)
setUKnotListToDefault()

setUKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :
bool setUKnotListToDefault(PGL::NurbsPatch {lvalue})
setVKnotListToDefault()

setVKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :
bool setVKnotListToDefault(PGL::NurbsPatch {lvalue})
udegree
uknotList
vdegree
vknotList
class Oriented

Oriented describes an object to a change of coordinate specified by an orthonormal basis has been applied. The basis is expressed by the matrix: |px sx tx| |py sy ty| |pz sz tz| where (px, py, pz) denotes the primary direction, (sx,, sy, sz) the secondary direction and (tx,, ty, tz) the ternary direction, which is given by: t = p ^ s.

__init__( (object)arg1 [, (Vector3)primary=Vector3(1,0,0) [, (Vector3)secondary=Vector3(0,1,0) [, (Geometry)geometry=None]]]) -> None :

Oriented(primary,secondary,geometry) with primary,secondary: Vector3

C++ signature :
void __init__(_object* [,TOOLS::Vector3=Vector3(1,0,0) [,TOOLS::Vector3=Vector3(0,1,0) [,TOOLS::RefCountPtr<PGL::Geometry>=None]]])
deepcopy()

deepcopy( (Oriented)arg1) -> Oriented :

C++ signature :
TOOLS::RefCountPtr<PGL::Oriented> deepcopy(PGL::Oriented {lvalue})

deepcopy( (Oriented)arg1, (DeepCopier)copier) -> Oriented :

C++ signature :
TOOLS::RefCountPtr<PGL::Oriented> deepcopy(PGL::Oriented {lvalue},PGL::DeepCopier {lvalue})
isPrimaryToDefault()

isPrimaryToDefault( (Oriented)arg1) -> bool :

C++ signature :
bool isPrimaryToDefault(PGL::Oriented {lvalue})
isSecondaryToDefault()

isSecondaryToDefault( (Oriented)arg1) -> bool :

C++ signature :
bool isSecondaryToDefault(PGL::Oriented {lvalue})
primary
recast()

recast( (Oriented)arg1) -> Oriented :

C++ signature :
TOOLS::RefCountPtr<PGL::Oriented> recast(PGL::Oriented*)
secondary
class OrthoTransformed

Abstract base class for objects on which a transformation that can be express as an orthonormal matrix is applied.

Raises an exception This class cannot be instantiated from Python

class OrthonormalBasis3D

__init__( (object)arg1, (Matrix3)arg2) -> None :

C++ signature :
void __init__(_object*,TOOLS::Matrix3)
getMatrix()

getMatrix( (OrthonormalBasis3D)arg1) -> Matrix4 :

C++ signature :
TOOLS::Matrix4 getMatrix(PGL::OrthonormalBasis3D {lvalue})
getMatrix3()

getMatrix3( (OrthonormalBasis3D)arg1) -> Matrix3 :

C++ signature :
TOOLS::Matrix3 getMatrix3(PGL::OrthonormalBasis3D {lvalue})
class Paraboloid

A paraboloid structure defined by a base radius, a height and a shape factor. Its base is centered at origin.

__init__( (object)arg1 [, (float)radius=0.5 [, (float)height=1.0 [, (float)shape=2.0 [, (bool)solid=True [, (int)slices=8 [, (int)stacks=8]]]]]]) -> None :

Paraboloid([radius, height, shape , solid, slices, stacks])

C++ signature :
void __init__(_object* [,double=0.5 [,double=1.0 [,double=2.0 [,bool=True [,unsigned char=8 [,unsigned char=8]]]]]])
deepcopy()

deepcopy( (Paraboloid)arg1) -> Paraboloid :

C++ signature :
TOOLS::RefCountPtr<PGL::Paraboloid> deepcopy(PGL::Paraboloid {lvalue})

deepcopy( (Paraboloid)arg1, (DeepCopier)copier) -> Paraboloid :

C++ signature :
TOOLS::RefCountPtr<PGL::Paraboloid> deepcopy(PGL::Paraboloid {lvalue},PGL::DeepCopier {lvalue})
isShapeToDefault()

isShapeToDefault( (Paraboloid)arg1) -> bool :

C++ signature :
bool isShapeToDefault(PGL::Paraboloid {lvalue})
isStacksToDefault()

isStacksToDefault( (Paraboloid)arg1) -> bool :

C++ signature :
bool isStacksToDefault(PGL::Paraboloid {lvalue})
recast()

recast( (Paraboloid)arg1) -> Paraboloid :

C++ signature :
TOOLS::RefCountPtr<PGL::Paraboloid> recast(PGL::Paraboloid*)
shape
stacks
class ParametricModel

Abstract base class for all parametric primitives

Raises an exception This class cannot be instantiated from Python

class Patch

Abstract base class for patches.

Raises an exception This class cannot be instantiated from Python

ccw
isCCWToDefault()

isCCWToDefault( (Patch)arg1) -> bool :

C++ signature :
bool isCCWToDefault(PGL::Patch {lvalue})
class PlanarModel

Raises an exception This class cannot be instantiated from Python

class Point2Array
__init__( (object)arg1, (int)size) -> None :

Point2Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Point2Array([Vector2(x,y),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Point2Array)arg1, (Vector2)arg2) -> None :

C++ signature :
void append(PGL::Point2Array*,TOOLS::Vector2)

append( (Point2Array)arg1, (Point2Array)arg2) -> None :

C++ signature :
void append(PGL::Point2Array*,PGL::Point2Array*)
clear()

clear( (Point2Array)arg1) -> None :

C++ signature :
void clear(PGL::Point2Array {lvalue})
findClosest()
findClosest( (Point2Array)arg1, (Vector2)point) -> object :

Find closest point in the PointArray2 from arg

C++ signature :
boost::python::api::object findClosest(PGL::Point2Array*,TOOLS::Vector2)
getBounds()

getBounds( (Point2Array)arg1) -> object :

C++ signature :
boost::python::api::object getBounds(PGL::Point2Array const*)
getCenter()

getCenter( (Point2Array)arg1) -> Vector2 :

C++ signature :
TOOLS::Vector2 getCenter(PGL::Point2Array {lvalue})
getExtent()

getExtent( (Point2Array)arg1) -> Vector2 :

C++ signature :
TOOLS::Vector2 getExtent(PGL::Point2Array {lvalue})
getId()

getId( (Point2Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Point2Array*)
getLength()

getLength( (Point2Array)arg1) -> float :

C++ signature :
double getLength(PGL::Point2Array {lvalue})
getPglId()

getPglId( (Point2Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Point2Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Point2Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Point2Array {lvalue})
getXMaxIndex()

getXMaxIndex( (Point2Array)arg1) -> int :

C++ signature :
int getXMaxIndex(PGL::Point2Array const*)
getXMinAndMaxIndex()

getXMinAndMaxIndex( (Point2Array)arg1) -> object :

C++ signature :
boost::python::api::object getXMinAndMaxIndex(PGL::Point2Array const*)
getXMinIndex()

getXMinIndex( (Point2Array)arg1) -> int :

C++ signature :
int getXMinIndex(PGL::Point2Array const*)
getYMaxIndex()

getYMaxIndex( (Point2Array)arg1) -> int :

C++ signature :
int getYMaxIndex(PGL::Point2Array const*)
getYMinAndMaxIndex()

getYMinAndMaxIndex( (Point2Array)arg1) -> object :

C++ signature :
boost::python::api::object getYMinAndMaxIndex(PGL::Point2Array const*)
getYMinIndex()

getYMinIndex( (Point2Array)arg1) -> int :

C++ signature :
int getYMinIndex(PGL::Point2Array const*)
hausdorff_distance()

hausdorff_distance( (Point2Array)arg1, (Point2Array)arg2) -> float :

C++ signature :
double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point2Array>,TOOLS::RefCountPtr<PGL::Point2Array>)
insert()

insert( (Point2Array)arg1, (int)arg2, (Vector2)arg3) -> None :

C++ signature :
void insert(PGL::Point2Array*,int,TOOLS::Vector2)
normalize()

normalize( (Point2Array)arg1) -> None :

C++ signature :
void normalize(PGL::Point2Array {lvalue})
partition()

partition( (Point2Array)arg1, (object)arg2) -> list :

C++ signature :
boost::python::list partition(PGL::Point2Array*,boost::python::api::object)
pop()

pop( (Point2Array)arg1 [, (int)arg2]) -> Vector2 :

C++ signature :
TOOLS::Vector2 pop(PGL::Point2Array* [,int])
prepend()

prepend( (Point2Array)arg1, (Vector2)arg2) -> None :

C++ signature :
void prepend(PGL::Point2Array*,TOOLS::Vector2)

prepend( (Point2Array)arg1, (Point2Array)arg2) -> None :

C++ signature :
void prepend(PGL::Point2Array*,PGL::Point2Array*)
reverse()

reverse( (Point2Array)arg1) -> None :

C++ signature :
void reverse(PGL::Point2Array {lvalue})
sort()

sort( (Point2Array)arg1, (object)arg2) -> None :

C++ signature :
void sort(PGL::Point2Array*,boost::python::api::object)
sortX()

sortX( (Point2Array)arg1) -> None :

C++ signature :
void sortX(PGL::Point2Array*)
sortY()

sortY( (Point2Array)arg1) -> None :

C++ signature :
void sortY(PGL::Point2Array*)
transform()

transform( (Point2Array)arg1, (Matrix2)arg2) -> None :

C++ signature :
void transform(PGL::Point2Array {lvalue},TOOLS::Matrix2)
class Point2Matrix
__init__( (object)arg1, (int)rows, (int)cols) -> None :

Point2Matrix(int rows, int cols)

C++ signature :
void __init__(_object*,unsigned long,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Point2Matrix([[a,b,c],[d,e,f]])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
clear()

clear( (Point2Matrix)arg1) -> None :

C++ signature :
void clear(PGL::Point2Matrix {lvalue})
empty()

empty( (Point2Matrix)arg1) -> bool :

C++ signature :
bool empty(PGL::Point2Matrix {lvalue})
getColumn()

getColumn( (Point2Matrix)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getColumn(PGL::Point2Matrix*,unsigned long)
getColumnNb()

getColumnNb( (Point2Matrix)arg1) -> int :

C++ signature :
unsigned long getColumnNb(PGL::Point2Matrix*)
getDiagonal()

getDiagonal( (Point2Matrix)arg1) -> object :

C++ signature :
boost::python::api::object getDiagonal(PGL::Point2Matrix*)
getRow()

getRow( (Point2Matrix)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getRow(PGL::Point2Matrix*,unsigned long)
getRowNb()

getRowNb( (Point2Matrix)arg1) -> int :

C++ signature :
unsigned long getRowNb(PGL::Point2Matrix*)
insertColumn()

insertColumn( (Point2Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertColumn(PGL::Point2Matrix*,unsigned long,boost::python::api::object)
insertRow()

insertRow( (Point2Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertRow(PGL::Point2Matrix*,unsigned long,boost::python::api::object)
isUnique()

isUnique( (Point2Matrix)arg1) -> bool :

C++ signature :
bool isUnique(PGL::Point2Matrix {lvalue})
pushColumn()

pushColumn( (Point2Matrix)arg1, (object)arg2) -> None :

C++ signature :
void pushColumn(PGL::Point2Matrix*,boost::python::api::object)
pushRow()

pushRow( (Point2Matrix)arg1, (object)arg2) -> None :

C++ signature :
void pushRow(PGL::Point2Matrix*,boost::python::api::object)
submatrix()

submatrix( (Point2Matrix)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> Point2Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point2Matrix> submatrix(PGL::Point2Matrix*,unsigned int,unsigned int,unsigned int,unsigned int)
transpose()

transpose( (Point2Matrix)arg1) -> Point2Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point2Matrix> transpose(PGL::Point2Matrix*)
class Point3Array
__init__( (object)arg1, (int)size) -> None :

Point3Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Point3Array([Vector3(x,y,z),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
__init__( (object)arg1, (Point2Array)arg2, (float)arg3) -> object :

Point3Array(Point2Array a, z)

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Point2Array>,double)
append()

append( (Point3Array)arg1, (Vector3)arg2) -> None :

C++ signature :
void append(PGL::Point3Array*,TOOLS::Vector3)

append( (Point3Array)arg1, (Point3Array)arg2) -> None :

C++ signature :
void append(PGL::Point3Array*,PGL::Point3Array*)
clear()

clear( (Point3Array)arg1) -> None :

C++ signature :
void clear(PGL::Point3Array {lvalue})
findClosest()
findClosest( (Point3Array)arg1, (Vector3)point) -> object :

Find closest point in the PointArray3 from arg

C++ signature :
boost::python::api::object findClosest(PGL::Point3Array*,TOOLS::Vector3)
getBounds()

getBounds( (Point3Array)arg1) -> object :

C++ signature :
boost::python::api::object getBounds(PGL::Point3Array const*)
getCenter()

getCenter( (Point3Array)arg1) -> Vector3 :

C++ signature :
TOOLS::Vector3 getCenter(PGL::Point3Array {lvalue})
getExtent()

getExtent( (Point3Array)arg1) -> Vector3 :

C++ signature :
TOOLS::Vector3 getExtent(PGL::Point3Array {lvalue})
getId()

getId( (Point3Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Point3Array*)
getLength()

getLength( (Point3Array)arg1) -> float :

C++ signature :
double getLength(PGL::Point3Array {lvalue})
getPglId()

getPglId( (Point3Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Point3Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Point3Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Point3Array {lvalue})
getXMaxIndex()

getXMaxIndex( (Point3Array)arg1) -> int :

C++ signature :
int getXMaxIndex(PGL::Point3Array const*)
getXMinAndMaxIndex()

getXMinAndMaxIndex( (Point3Array)arg1) -> object :

C++ signature :
boost::python::api::object getXMinAndMaxIndex(PGL::Point3Array const*)
getXMinIndex()

getXMinIndex( (Point3Array)arg1) -> int :

C++ signature :
int getXMinIndex(PGL::Point3Array const*)
getYMaxIndex()

getYMaxIndex( (Point3Array)arg1) -> int :

C++ signature :
int getYMaxIndex(PGL::Point3Array const*)
getYMinAndMaxIndex()

getYMinAndMaxIndex( (Point3Array)arg1) -> object :

C++ signature :
boost::python::api::object getYMinAndMaxIndex(PGL::Point3Array const*)
getYMinIndex()

getYMinIndex( (Point3Array)arg1) -> int :

C++ signature :
int getYMinIndex(PGL::Point3Array const*)
getZMaxIndex()

getZMaxIndex( (Point3Array)arg1) -> int :

C++ signature :
int getZMaxIndex(PGL::Point3Array const*)
getZMinAndMaxIndex()

getZMinAndMaxIndex( (Point3Array)arg1) -> object :

C++ signature :
boost::python::api::object getZMinAndMaxIndex(PGL::Point3Array const*)
getZMinIndex()

getZMinIndex( (Point3Array)arg1) -> int :

C++ signature :
int getZMinIndex(PGL::Point3Array const*)
hausdorff_distance()

hausdorff_distance( (Point3Array)arg1, (Point3Array)arg2) -> float :

C++ signature :
double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point3Array>,TOOLS::RefCountPtr<PGL::Point3Array>)
insert()

insert( (Point3Array)arg1, (int)arg2, (Vector3)arg3) -> None :

C++ signature :
void insert(PGL::Point3Array*,int,TOOLS::Vector3)
normalize()

normalize( (Point3Array)arg1) -> None :

C++ signature :
void normalize(PGL::Point3Array {lvalue})
partition()

partition( (Point3Array)arg1, (object)arg2) -> list :

C++ signature :
boost::python::list partition(PGL::Point3Array*,boost::python::api::object)
pop()

pop( (Point3Array)arg1 [, (int)arg2]) -> Vector3 :

C++ signature :
TOOLS::Vector3 pop(PGL::Point3Array* [,int])
prepend()

prepend( (Point3Array)arg1, (Vector3)arg2) -> None :

C++ signature :
void prepend(PGL::Point3Array*,TOOLS::Vector3)

prepend( (Point3Array)arg1, (Point3Array)arg2) -> None :

C++ signature :
void prepend(PGL::Point3Array*,PGL::Point3Array*)
project()

project( (Point3Array)arg1) -> Point2Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point2Array> project(PGL::Point3Array {lvalue})
reverse()

reverse( (Point3Array)arg1) -> None :

C++ signature :
void reverse(PGL::Point3Array {lvalue})
sort()

sort( (Point3Array)arg1, (object)arg2) -> None :

C++ signature :
void sort(PGL::Point3Array*,boost::python::api::object)
sortX()

sortX( (Point3Array)arg1) -> None :

C++ signature :
void sortX(PGL::Point3Array*)
sortY()

sortY( (Point3Array)arg1) -> None :

C++ signature :
void sortY(PGL::Point3Array*)
sortZ()

sortZ( (Point3Array)arg1) -> None :

C++ signature :
void sortZ(PGL::Point3Array*)
transform()

transform( (Point3Array)arg1, (Matrix3)arg2) -> None :

C++ signature :
void transform(PGL::Point3Array {lvalue},TOOLS::Matrix3)

transform( (Point3Array)arg1, (Matrix4)arg2) -> None :

C++ signature :
void transform(PGL::Point3Array {lvalue},TOOLS::Matrix4)
class Point3Matrix
__init__( (object)arg1, (int)rows, (int)cols) -> None :

Point3Matrix(int rows, int cols)

C++ signature :
void __init__(_object*,unsigned long,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Point3Matrix([[a,b,c],[d,e,f]])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
clear()

clear( (Point3Matrix)arg1) -> None :

C++ signature :
void clear(PGL::Point3Matrix {lvalue})
empty()

empty( (Point3Matrix)arg1) -> bool :

C++ signature :
bool empty(PGL::Point3Matrix {lvalue})
getColumn()

getColumn( (Point3Matrix)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getColumn(PGL::Point3Matrix*,unsigned long)
getColumnNb()

getColumnNb( (Point3Matrix)arg1) -> int :

C++ signature :
unsigned long getColumnNb(PGL::Point3Matrix*)
getDiagonal()

getDiagonal( (Point3Matrix)arg1) -> object :

C++ signature :
boost::python::api::object getDiagonal(PGL::Point3Matrix*)
getRow()

getRow( (Point3Matrix)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getRow(PGL::Point3Matrix*,unsigned long)
getRowNb()

getRowNb( (Point3Matrix)arg1) -> int :

C++ signature :
unsigned long getRowNb(PGL::Point3Matrix*)
insertColumn()

insertColumn( (Point3Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertColumn(PGL::Point3Matrix*,unsigned long,boost::python::api::object)
insertRow()

insertRow( (Point3Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertRow(PGL::Point3Matrix*,unsigned long,boost::python::api::object)
isUnique()

isUnique( (Point3Matrix)arg1) -> bool :

C++ signature :
bool isUnique(PGL::Point3Matrix {lvalue})
pushColumn()

pushColumn( (Point3Matrix)arg1, (object)arg2) -> None :

C++ signature :
void pushColumn(PGL::Point3Matrix*,boost::python::api::object)
pushRow()

pushRow( (Point3Matrix)arg1, (object)arg2) -> None :

C++ signature :
void pushRow(PGL::Point3Matrix*,boost::python::api::object)
submatrix()

submatrix( (Point3Matrix)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> Point3Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Matrix> submatrix(PGL::Point3Matrix*,unsigned int,unsigned int,unsigned int,unsigned int)
transpose()

transpose( (Point3Matrix)arg1) -> Point3Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Matrix> transpose(PGL::Point3Matrix*)
class Point4Array
__init__( (object)arg1, (int)size) -> None :

Point4Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Point4Array([Vector4(x,y,z,w),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
__init__( (object)arg1, (Point2Array)arg2, (float)arg3, (float)arg4) -> object :

Point4Array(Point2Array a, z, w)

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Point2Array>,double,double)
__init__( (object)arg1, (Point3Array)arg2, (float)arg3) -> object :

Point4Array(Point3Array a, w)

C++ signature :
void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Point3Array>,double)
append()

append( (Point4Array)arg1, (Vector4)arg2) -> None :

C++ signature :
void append(PGL::Point4Array*,TOOLS::Vector4)

append( (Point4Array)arg1, (Point4Array)arg2) -> None :

C++ signature :
void append(PGL::Point4Array*,PGL::Point4Array*)
clear()

clear( (Point4Array)arg1) -> None :

C++ signature :
void clear(PGL::Point4Array {lvalue})
findClosest()
findClosest( (Point4Array)arg1, (Vector4)point) -> object :

Find closest point in the PointArray4 from arg

C++ signature :
boost::python::api::object findClosest(PGL::Point4Array*,TOOLS::Vector4)
getBounds()

getBounds( (Point4Array)arg1) -> object :

C++ signature :
boost::python::api::object getBounds(PGL::Point4Array const*)
getCenter()

getCenter( (Point4Array)arg1) -> Vector4 :

C++ signature :
TOOLS::Vector4 getCenter(PGL::Point4Array {lvalue})
getExtent()

getExtent( (Point4Array)arg1) -> Vector4 :

C++ signature :
TOOLS::Vector4 getExtent(PGL::Point4Array {lvalue})
getId()

getId( (Point4Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Point4Array*)
getLength()

getLength( (Point4Array)arg1) -> float :

C++ signature :
double getLength(PGL::Point4Array {lvalue})
getPglId()

getPglId( (Point4Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::Point4Array {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Point4Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Point4Array {lvalue})
getWMaxIndex()

getWMaxIndex( (Point4Array)arg1) -> int :

C++ signature :
int getWMaxIndex(PGL::Point4Array const*)
getWMinAndMaxIndex()

getWMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :
boost::python::api::object getWMinAndMaxIndex(PGL::Point4Array const*)
getWMinIndex()

getWMinIndex( (Point4Array)arg1) -> int :

C++ signature :
int getWMinIndex(PGL::Point4Array const*)
getXMaxIndex()

getXMaxIndex( (Point4Array)arg1) -> int :

C++ signature :
int getXMaxIndex(PGL::Point4Array const*)
getXMinAndMaxIndex()

getXMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :
boost::python::api::object getXMinAndMaxIndex(PGL::Point4Array const*)
getXMinIndex()

getXMinIndex( (Point4Array)arg1) -> int :

C++ signature :
int getXMinIndex(PGL::Point4Array const*)
getYMaxIndex()

getYMaxIndex( (Point4Array)arg1) -> int :

C++ signature :
int getYMaxIndex(PGL::Point4Array const*)
getYMinAndMaxIndex()

getYMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :
boost::python::api::object getYMinAndMaxIndex(PGL::Point4Array const*)
getYMinIndex()

getYMinIndex( (Point4Array)arg1) -> int :

C++ signature :
int getYMinIndex(PGL::Point4Array const*)
getZMaxIndex()

getZMaxIndex( (Point4Array)arg1) -> int :

C++ signature :
int getZMaxIndex(PGL::Point4Array const*)
getZMinAndMaxIndex()

getZMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :
boost::python::api::object getZMinAndMaxIndex(PGL::Point4Array const*)
getZMinIndex()

getZMinIndex( (Point4Array)arg1) -> int :

C++ signature :
int getZMinIndex(PGL::Point4Array const*)
hausdorff_distance()

hausdorff_distance( (Point4Array)arg1, (Point4Array)arg2) -> float :

C++ signature :
double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point4Array>,TOOLS::RefCountPtr<PGL::Point4Array>)
insert()

insert( (Point4Array)arg1, (int)arg2, (Vector4)arg3) -> None :

C++ signature :
void insert(PGL::Point4Array*,int,TOOLS::Vector4)
normalize()

normalize( (Point4Array)arg1) -> None :

C++ signature :
void normalize(PGL::Point4Array {lvalue})
partition()

partition( (Point4Array)arg1, (object)arg2) -> list :

C++ signature :
boost::python::list partition(PGL::Point4Array*,boost::python::api::object)
pop()

pop( (Point4Array)arg1 [, (int)arg2]) -> Vector4 :

C++ signature :
TOOLS::Vector4 pop(PGL::Point4Array* [,int])
prepend()

prepend( (Point4Array)arg1, (Vector4)arg2) -> None :

C++ signature :
void prepend(PGL::Point4Array*,TOOLS::Vector4)

prepend( (Point4Array)arg1, (Point4Array)arg2) -> None :

C++ signature :
void prepend(PGL::Point4Array*,PGL::Point4Array*)
project()

project( (Point4Array)arg1) -> Point3Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Array> project(PGL::Point4Array {lvalue})
reverse()

reverse( (Point4Array)arg1) -> None :

C++ signature :
void reverse(PGL::Point4Array {lvalue})
sort()

sort( (Point4Array)arg1, (object)arg2) -> None :

C++ signature :
void sort(PGL::Point4Array*,boost::python::api::object)
sortW()

sortW( (Point4Array)arg1) -> None :

C++ signature :
void sortW(PGL::Point4Array*)
sortX()

sortX( (Point4Array)arg1) -> None :

C++ signature :
void sortX(PGL::Point4Array*)
sortY()

sortY( (Point4Array)arg1) -> None :

C++ signature :
void sortY(PGL::Point4Array*)
sortZ()

sortZ( (Point4Array)arg1) -> None :

C++ signature :
void sortZ(PGL::Point4Array*)
transform()

transform( (Point4Array)arg1, (Matrix4)arg2) -> None :

C++ signature :
void transform(PGL::Point4Array {lvalue},TOOLS::Matrix4)
class Point4Matrix
__init__( (object)arg1, (int)rows, (int)cols) -> None :

Point4Matrix(int rows, int cols)

C++ signature :
void __init__(_object*,unsigned long,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Point4Matrix([[a,b,c],[d,e,f]])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
clear()

clear( (Point4Matrix)arg1) -> None :

C++ signature :
void clear(PGL::Point4Matrix {lvalue})
empty()

empty( (Point4Matrix)arg1) -> bool :

C++ signature :
bool empty(PGL::Point4Matrix {lvalue})
getColumn()

getColumn( (Point4Matrix)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getColumn(PGL::Point4Matrix*,unsigned long)
getColumnNb()

getColumnNb( (Point4Matrix)arg1) -> int :

C++ signature :
unsigned long getColumnNb(PGL::Point4Matrix*)
getDiagonal()

getDiagonal( (Point4Matrix)arg1) -> object :

C++ signature :
boost::python::api::object getDiagonal(PGL::Point4Matrix*)
getRow()

getRow( (Point4Matrix)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getRow(PGL::Point4Matrix*,unsigned long)
getRowNb()

getRowNb( (Point4Matrix)arg1) -> int :

C++ signature :
unsigned long getRowNb(PGL::Point4Matrix*)
insertColumn()

insertColumn( (Point4Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertColumn(PGL::Point4Matrix*,unsigned long,boost::python::api::object)
insertRow()

insertRow( (Point4Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertRow(PGL::Point4Matrix*,unsigned long,boost::python::api::object)
isUnique()

isUnique( (Point4Matrix)arg1) -> bool :

C++ signature :
bool isUnique(PGL::Point4Matrix {lvalue})
pushColumn()

pushColumn( (Point4Matrix)arg1, (object)arg2) -> None :

C++ signature :
void pushColumn(PGL::Point4Matrix*,boost::python::api::object)
pushRow()

pushRow( (Point4Matrix)arg1, (object)arg2) -> None :

C++ signature :
void pushRow(PGL::Point4Matrix*,boost::python::api::object)
submatrix()

submatrix( (Point4Matrix)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> Point4Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Matrix> submatrix(PGL::Point4Matrix*,unsigned int,unsigned int,unsigned int,unsigned int)
transpose()

transpose( (Point4Matrix)arg1) -> Point4Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Matrix> transpose(PGL::Point4Matrix*)
class PointSet

PointSet describes an explicit set of points

__init__( (object)arg1, (Point3Array)pointList [, (Color4Array)colorList=None [, (int)width=1]]) -> None :

PointSet(Point3Array pointList, Color4Array colorList = None)

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,TOOLS::RefCountPtr<PGL::Color4Array>=None [,unsigned char=1]])
convertToShapes()

convertToShapes( (PointSet)arg1 [, (Vector3)translation=Vector3(0,0,0)]) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> convertToShapes(PGL::PointSet* [,TOOLS::Vector3=Vector3(0,0,0)])
deepcopy()

deepcopy( (PointSet)arg1) -> PointSet :

C++ signature :
TOOLS::RefCountPtr<PGL::PointSet> deepcopy(PGL::PointSet {lvalue})

deepcopy( (PointSet)arg1, (DeepCopier)copier) -> PointSet :

C++ signature :
TOOLS::RefCountPtr<PGL::PointSet> deepcopy(PGL::PointSet {lvalue},PGL::DeepCopier {lvalue})
findClosest()
findClosest( (PointSet)arg1, (Vector3)point) -> object :

Find closest point in the PointSet from arg

C++ signature :
boost::python::api::object findClosest(PGL::PointSet*,TOOLS::Vector3)
isWidthToDefault()

isWidthToDefault( (PointSet)arg1) -> bool :

C++ signature :
bool isWidthToDefault(PGL::PointSet {lvalue})
recast()

recast( (PointSet)arg1) -> PointSet :

C++ signature :
TOOLS::RefCountPtr<PGL::PointSet> recast(PGL::PointSet*)
transform()

transform( (PointSet)arg1, (Transformation3D)arg2) -> ExplicitModel :

C++ signature :
TOOLS::RefCountPtr<PGL::ExplicitModel> transform(PGL::PointSet {lvalue},TOOLS::RefCountPtr<PGL::Transformation3D>)
width
class PointSet2D

PointSet2D describes an explicit set of 2D points. See PointSet.

__init__( (object)arg1, (Point2Array)pointList [, (int)width=1]) -> None :

PointSet2D(pointList[,width])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned char=1])
deepcopy()

deepcopy( (PointSet2D)arg1) -> PointSet2D :

C++ signature :
TOOLS::RefCountPtr<PGL::PointSet2D> deepcopy(PGL::PointSet2D {lvalue})

deepcopy( (PointSet2D)arg1, (DeepCopier)copier) -> PointSet2D :

C++ signature :
TOOLS::RefCountPtr<PGL::PointSet2D> deepcopy(PGL::PointSet2D {lvalue},PGL::DeepCopier {lvalue})
findClosest()
findClosest( (PointSet2D)arg1, (Vector2)point) -> object :

Find closest point in the PointSet from arg

C++ signature :
boost::python::api::object findClosest(PGL::PointSet2D*,TOOLS::Vector2)
isWidthToDefault()

isWidthToDefault( (PointSet2D)arg1) -> bool :

C++ signature :
bool isWidthToDefault(PGL::PointSet2D {lvalue})
pointList
recast()

recast( (PointSet2D)arg1) -> PointSet2D :

C++ signature :
TOOLS::RefCountPtr<PGL::PointSet2D> recast(PGL::PointSet2D*)
width
class Polyline

A Polyline describes a curve formed by connected segments. It is defined by a set of points. A color can be associated to each point for visualisation.

__init__( (object)arg1, (Point3Array)pointList [, (Color4Array)colorList]) -> None :

Polyline(Point3Array pointList, Color4Array colorList = None)

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,TOOLS::RefCountPtr<PGL::Color4Array>])
__init__( (object)arg1, (Point3Array)pointList, (Color4Array)colorList [, (int)width=1]) -> None :

Polyline(Point3Array pointList, Color4Array colorList = None, width = 1)

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array>,TOOLS::RefCountPtr<PGL::Color4Array> [,unsigned char=1])
__init__( (object)arg1, (Point3Array)pointList [, (int)width=1]) -> None :

Polyline(Point3Array pointList, width = 1)

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,unsigned char=1])
deepcopy()

deepcopy( (Polyline)arg1) -> Polyline :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline> deepcopy(PGL::Polyline {lvalue})

deepcopy( (Polyline)arg1, (DeepCopier)copier) -> Polyline :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline> deepcopy(PGL::Polyline {lvalue},PGL::DeepCopier {lvalue})
recast()

recast( (Polyline)arg1) -> Polyline :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline> recast(PGL::Polyline*)
split()

split( (Polyline)arg1, (float)u) -> object :

C++ signature :
boost::python::api::object split(PGL::Polyline*,double)
class Polyline2D

A Polyline2D describes a curve formed by connected 2D segments. It is defined by a set of 2D points. See Polyline.

__init__( (object)arg1, (Point2Array)pointList [, (int)width=1]) -> None :

Polyline2D(pointList[,width])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned char=1])
ArcOfCircle()

ArcOfCircle([ (float)radius=0.5 [, (float)starting_angle=0 [, (float)angle_range=3.141592653589793 [, (int)slices=8]]]]) -> Polyline2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline2D> ArcOfCircle([ double=0.5 [,double=0 [,double=3.141592653589793 [,unsigned char=8]]]])
Circle()

Circle([ (float)radius=0.5 [, (int)slices=8]]) -> Polyline2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline2D> Circle([ double=0.5 [,unsigned char=8]])
SuperEllipsis()

SuperEllipsis([ (float)radius=0.5 [, (float)height=0.5 [, (float)degree=2 [, (float)starting_angle=0 [, (float)angle_range=6.2831853072 [, (int)slices=8]]]]]]) -> Polyline2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline2D> SuperEllipsis([ double=0.5 [,double=0.5 [,double=2 [,double=0 [,double=6.2831853072 [,unsigned char=8]]]]]])
deepcopy()

deepcopy( (Polyline2D)arg1) -> Polyline2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline2D> deepcopy(PGL::Polyline2D {lvalue})

deepcopy( (Polyline2D)arg1, (DeepCopier)copier) -> Polyline2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline2D> deepcopy(PGL::Polyline2D {lvalue},PGL::DeepCopier {lvalue})
getNormalAt()

getNormalAt( (Polyline2D)arg1, (float)u) -> Vector2 :

C++ signature :
TOOLS::Vector2 getNormalAt(PGL::Polyline2D {lvalue},double)
getTangentAt()

getTangentAt( (Polyline2D)arg1, (float)u) -> Vector2 :

C++ signature :
TOOLS::Vector2 getTangentAt(PGL::Polyline2D {lvalue},double)
pointList
recast()

recast( (Polyline2D)arg1) -> Polyline2D :

C++ signature :
TOOLS::RefCountPtr<PGL::Polyline2D> recast(PGL::Polyline2D*)
split()

split( (Polyline2D)arg1, (float)u) -> object :

C++ signature :
boost::python::api::object split(PGL::Polyline2D*,double)
class Primitive

Abstract base class for all predefined primitives.

Raises an exception This class cannot be instantiated from Python

class ProfileInterpolation
__init__( (object)arg1, (Curve2DArray)profiles, (RealArray)knotList [, (int)degree=3 [, (int)stride=0]]) -> None :

ProfileInterpolation([Curve2D] profiles,[float] knotList,int degree,int stride

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2DArray>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int=3 [,unsigned int=0]])
degree
getSectionAt()

getSectionAt( (ProfileInterpolation)arg1, (float)arg2) -> object :

C++ signature :
boost::python::api::object getSectionAt(PGL::ProfileInterpolation*,double)
isDegreeToDefault()

isDegreeToDefault( (ProfileInterpolation)arg1) -> bool :

C++ signature :
bool isDegreeToDefault(PGL::ProfileInterpolation {lvalue})
isStrideToDefault()

isStrideToDefault( (ProfileInterpolation)arg1) -> bool :

C++ signature :
bool isStrideToDefault(PGL::ProfileInterpolation {lvalue})
knotList
profileList
stride
umax
umin
class QuadSet

A QuadSet describes a surface formed by a set of connected quadrilaterals, i.e. four sided polygons. Quads are specified using set of tuples of 4 indices (Index4) pointing to a list of points.

__init__( (object)arg1 [, (Point3Array)pointList=None [, (Index4Array)indexList=None [, (Point3Array)normalList=None [, (Index4Array)normalIndexList=None [, (Color4Array)colorList=None [, (Index4Array)colorIndexList=None [, (Point2Array)texCoordList=None [, (Index4Array)texCoordIndexList=None [, (bool)normalPerVertex=True [, (bool)colorPerVertex=True [, (bool)ccw=True [, (bool)solid=False [, (Polyline)skeleton=None]]]]]]]]]]]]]) -> None :

__init__(Point3Array pointList, IndexArray indexList [, Point3Array normalList, IndexArray nomalIndexList, Color4Array colorList, IndexArray colorIndexList, Point2Array texCoordList, IndexArray texCoordIndexList, bool normalPerVertex, bool colorPerVertex, bool ccw, bool solid, Polyline skeleton])

C++ signature :
void __init__(_object* [,TOOLS::RefCountPtr<PGL::Point3Array>=None [,TOOLS::RefCountPtr<PGL::Index4Array>=None [,TOOLS::RefCountPtr<PGL::Point3Array>=None [,TOOLS::RefCountPtr<PGL::Index4Array>=None [,TOOLS::RefCountPtr<PGL::Color4Array>=None [,TOOLS::RefCountPtr<PGL::Index4Array>=None [,TOOLS::RefCountPtr<PGL::Point2Array>=None [,TOOLS::RefCountPtr<PGL::Index4Array>=None [,bool=True [,bool=True [,bool=True [,bool=False [,TOOLS::RefCountPtr<PGL::Polyline>=None]]]]]]]]]]]]])
colorAt()

colorAt( (QuadSet)arg1, (int)arg2) -> Color4 :

C++ signature :
PGL::Color4 colorAt(PGL::QuadSet {lvalue},unsigned int)
colorIndexAt()

colorIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :
TOOLS::Tuple4<unsigned int> colorIndexAt(PGL::QuadSet {lvalue},unsigned int)
colorIndexList
deepcopy()

deepcopy( (QuadSet)arg1) -> QuadSet :

C++ signature :
TOOLS::RefCountPtr<PGL::QuadSet> deepcopy(PGL::QuadSet {lvalue})

deepcopy( (QuadSet)arg1, (DeepCopier)copier) -> QuadSet :

C++ signature :
TOOLS::RefCountPtr<PGL::QuadSet> deepcopy(PGL::QuadSet {lvalue},PGL::DeepCopier {lvalue})
faceColorAt()

faceColorAt( (QuadSet)arg1, (int)arg2, (int)arg3) -> Color4 :

C++ signature :
PGL::Color4 faceColorAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)
faceNormalAt()

faceNormalAt( (QuadSet)arg1, (int)arg2, (int)arg3) -> Vector3 :

C++ signature :
TOOLS::Vector3 faceNormalAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)
faceTexCoordAt()

faceTexCoordAt( (QuadSet)arg1, (int)arg2, (int)arg3) -> Vector2 :

C++ signature :
TOOLS::Vector2 faceTexCoordAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)
indexAt()

indexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :
TOOLS::Tuple4<unsigned int> indexAt(PGL::QuadSet {lvalue},unsigned int)
indexList
isColorIndexListToDefault()

isColorIndexListToDefault( (QuadSet)arg1) -> bool :

C++ signature :
bool isColorIndexListToDefault(PGL::QuadSet {lvalue})
isNormalIndexListToDefault()

isNormalIndexListToDefault( (QuadSet)arg1) -> bool :

C++ signature :
bool isNormalIndexListToDefault(PGL::QuadSet {lvalue})
isTexCoordIndexListToDefault()

isTexCoordIndexListToDefault( (QuadSet)arg1) -> bool :

C++ signature :
bool isTexCoordIndexListToDefault(PGL::QuadSet {lvalue})
normalAt()

normalAt( (QuadSet)arg1, (int)arg2) -> Vector3 :

C++ signature :
TOOLS::Vector3 normalAt(PGL::QuadSet {lvalue},unsigned int)
normalIndexAt()

normalIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :
TOOLS::Tuple4<unsigned int> normalIndexAt(PGL::QuadSet {lvalue},unsigned int)
normalIndexList
recast()

recast( (QuadSet)arg1) -> QuadSet :

C++ signature :
TOOLS::RefCountPtr<PGL::QuadSet> recast(PGL::QuadSet*)
texCoordAt()

texCoordAt( (QuadSet)arg1, (int)arg2) -> Vector2 :

C++ signature :
TOOLS::Vector2 texCoordAt(PGL::QuadSet {lvalue},unsigned int)
texCoordIndexAt()

texCoordIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :
TOOLS::Tuple4<unsigned int> texCoordIndexAt(PGL::QuadSet {lvalue},unsigned int)
texCoordIndexList
class QuantisedFunction

A 2D quantised injective function (homomorphism) defined on the range [firstx,lastx].

__init__( (object)arg1, (Curve2D)curve [, (int)sampling]) -> None :

QuantisedFunction(curve[,sampling,clamped]) : Quantised 2D function. If clamped parameter is set to False, if a x value is out of range, first or last value is returned. Otherwise an exception is raised.

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2D> [,unsigned int])
__init__( (object)arg1, (Point2Array)points [, (int)sampling]) -> None :

Function(points [,sampling])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned int])
build()

build( (QuantisedFunction)arg1, (Curve2D)curve, (int)sampling) -> bool :

C++ signature :
bool build(PGL::QuantisedFunction {lvalue},TOOLS::RefCountPtr<PGL::Curve2D>,unsigned int)

build( (QuantisedFunction)arg1, (Curve2D)arg2) -> bool :

C++ signature :
bool build(PGL::QuantisedFunction {lvalue},TOOLS::RefCountPtr<PGL::Curve2D>)
checkQuantisableFunction()

checkQuantisableFunction( (Curve2D)arg1) -> bool :

C++ signature :
bool checkQuantisableFunction(TOOLS::RefCountPtr<PGL::Curve2D>)
clamped
findX()

findX( (QuantisedFunction)arg1, (float)y) -> object :

C++ signature :
boost::python::api::object findX(PGL::QuantisedFunction*,double)
findX( (QuantisedFunction)arg1, (float)y, (float)startingX) -> object :

findX(y[,startingX]) : find the first x value such as f(x) = y.

C++ signature :
boost::python::api::object findX(PGL::QuantisedFunction*,double,double)
firstx
getValue()

getValue( (QuantisedFunction)arg1, (float)x) -> float :

C++ signature :
double getValue(PGL::QuantisedFunction*,double)
inverse()

inverse( (QuantisedFunction)arg1) -> QuantisedFunction :

C++ signature :
TOOLS::RefCountPtr<PGL::QuantisedFunction> inverse(PGL::QuantisedFunction {lvalue})
isClampedToDefault()

isClampedToDefault( (QuantisedFunction)arg1) -> bool :

C++ signature :
bool isClampedToDefault(PGL::QuantisedFunction {lvalue})
isDecreasing()

isDecreasing( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :

C++ signature :
bool isDecreasing(PGL::QuantisedFunction {lvalue} [,bool])
isIncreasing()

isIncreasing( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :

C++ signature :
bool isIncreasing(PGL::QuantisedFunction {lvalue} [,bool])
isMonotonous()

isMonotonous( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :

C++ signature :
bool isMonotonous(PGL::QuantisedFunction {lvalue} [,bool])
isValid()

isValid( (QuantisedFunction)arg1) -> bool :

C++ signature :
bool isValid(PGL::QuantisedFunction {lvalue})
lastx
sampling
class RealArray
__init__( (object)arg1, (int)size) -> None :

RealArray(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

IndexArray([a,b,...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (RealArray)arg1, (float)arg2) -> None :

C++ signature :
void append(TOOLS::RealArray*,double)

append( (RealArray)arg1, (RealArray)arg2) -> None :

C++ signature :
void append(TOOLS::RealArray*,TOOLS::RealArray*)
clear()

clear( (RealArray)arg1) -> None :

C++ signature :
void clear(TOOLS::RealArray {lvalue})
getId()

getId( (RealArray)arg1) -> int :

C++ signature :
unsigned long getId(TOOLS::RealArray*)
getPglId()

getPglId( (RealArray)arg1) -> int :

C++ signature :
unsigned long getPglId(TOOLS::RealArray {lvalue})
getPglReferenceCount()

getPglReferenceCount( (RealArray)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(TOOLS::RealArray {lvalue})
insert()

insert( (RealArray)arg1, (int)arg2, (float)arg3) -> None :

C++ signature :
void insert(TOOLS::RealArray*,int,double)
pop()

pop( (RealArray)arg1 [, (int)arg2]) -> float :

C++ signature :
double pop(TOOLS::RealArray* [,int])
prepend()

prepend( (RealArray)arg1, (float)arg2) -> None :

C++ signature :
void prepend(TOOLS::RealArray*,double)

prepend( (RealArray)arg1, (RealArray)arg2) -> None :

C++ signature :
void prepend(TOOLS::RealArray*,TOOLS::RealArray*)
reverse()

reverse( (RealArray)arg1) -> None :

C++ signature :
void reverse(TOOLS::RealArray {lvalue})
class RealArray2
__init__( (object)arg1, (int)rows, (int)cols) -> None :

RealArray2(int rows, int cols)

C++ signature :
void __init__(_object*,unsigned long,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

RealArray2([[a,b,c],[d,e,f]])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
clear()

clear( (RealArray2)arg1) -> None :

C++ signature :
void clear(TOOLS::RealArray2 {lvalue})
empty()

empty( (RealArray2)arg1) -> bool :

C++ signature :
bool empty(TOOLS::RealArray2 {lvalue})
getColumn()

getColumn( (RealArray2)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getColumn(TOOLS::RealArray2*,unsigned long)
getColumnNb()

getColumnNb( (RealArray2)arg1) -> int :

C++ signature :
unsigned long getColumnNb(TOOLS::RealArray2*)
getDiagonal()

getDiagonal( (RealArray2)arg1) -> object :

C++ signature :
boost::python::api::object getDiagonal(TOOLS::RealArray2*)
getRow()

getRow( (RealArray2)arg1, (int)arg2) -> object :

C++ signature :
boost::python::api::object getRow(TOOLS::RealArray2*,unsigned long)
getRowNb()

getRowNb( (RealArray2)arg1) -> int :

C++ signature :
unsigned long getRowNb(TOOLS::RealArray2*)
insertColumn()

insertColumn( (RealArray2)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertColumn(TOOLS::RealArray2*,unsigned long,boost::python::api::object)
insertRow()

insertRow( (RealArray2)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :
void insertRow(TOOLS::RealArray2*,unsigned long,boost::python::api::object)
inverse()

inverse( (RealArray2)arg1) -> RealArray2 :

C++ signature :
TOOLS::RefCountPtr<TOOLS::RealArray2> inverse(TOOLS::RealArray2*)
isUnique()

isUnique( (RealArray2)arg1) -> bool :

C++ signature :
bool isUnique(TOOLS::RealArray2 {lvalue})
pushColumn()

pushColumn( (RealArray2)arg1, (object)arg2) -> None :

C++ signature :
void pushColumn(TOOLS::RealArray2*,boost::python::api::object)
pushRow()

pushRow( (RealArray2)arg1, (object)arg2) -> None :

C++ signature :
void pushRow(TOOLS::RealArray2*,boost::python::api::object)
submatrix()

submatrix( (RealArray2)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> RealArray2 :

C++ signature :
TOOLS::RefCountPtr<TOOLS::RealArray2> submatrix(TOOLS::RealArray2*,unsigned int,unsigned int,unsigned int,unsigned int)
svd()

svd( (RealArray2)arg1) -> object :

C++ signature :
boost::python::api::object svd(TOOLS::RealArray2*)
transpose()

transpose( (RealArray2)arg1) -> RealArray2 :

C++ signature :
TOOLS::RefCountPtr<TOOLS::RealArray2> transpose(TOOLS::RealArray2*)
class Revolution

Revolution describes a general surface of revolution generated by the rotation of a planar curve about the z -axis. The number of points within the generatrice curve determines the number of subdivisions along the z -axis when discretizing the object. slice determine the number of evaluated vertical sections.

__init__( (object)arg1, (Curve2D)profile [, (int)slices=8]) -> None :

Revolution(profile [, slices])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2D> [,unsigned char=8])
deepcopy()

deepcopy( (Revolution)arg1) -> Revolution :

C++ signature :
TOOLS::RefCountPtr<PGL::Revolution> deepcopy(PGL::Revolution {lvalue})

deepcopy( (Revolution)arg1, (DeepCopier)copier) -> Revolution :

C++ signature :
TOOLS::RefCountPtr<PGL::Revolution> deepcopy(PGL::Revolution {lvalue},PGL::DeepCopier {lvalue})
profile
recast()

recast( (Revolution)arg1) -> Revolution :

C++ signature :
TOOLS::RefCountPtr<PGL::Revolution> recast(PGL::Revolution*)
class SOR

Abstract base class for 3D objects of type of surface of revolution.

Raises an exception This class cannot be instantiated from Python

isSlicesToDefault()

isSlicesToDefault( (SOR)arg1) -> bool :

C++ signature :
bool isSlicesToDefault(PGL::SOR {lvalue})
slices
class SOR2D

Abstract base class for 2D objects of type of surface of revolution.

Raises an exception This class cannot be instantiated from Python

isSlicesToDefault()

isSlicesToDefault( (SOR2D)arg1) -> bool :

C++ signature :
bool isSlicesToDefault(PGL::SOR2D {lvalue})
slices
class Scaled

The Scaled describes an object to which an anisotropic scaling has been applied. The scaling transformation is given by the matrix: |sx 0 0| |0 sy 0| |0 0 sz| where (sx, sy, sz) denotes the scaling factors along the x, y and z-axis.

__init__( (object)arg1 [, (Vector3)scale=Vector3(1,1,1) [, (Geometry)geometry=None]]) -> None :

Scaled(scale,geometry)

C++ signature :
void __init__(_object* [,TOOLS::Vector3=Vector3(1,1,1) [,TOOLS::RefCountPtr<PGL::Geometry>=None]])

__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (Geometry)arg5) -> object :

C++ signature :
void* __init__(boost::python::api::object,double,double,double,TOOLS::RefCountPtr<PGL::Geometry>)

__init__( (object)arg1, (float)arg2, (Geometry)arg3) -> object :

C++ signature :
void* __init__(boost::python::api::object,double,TOOLS::RefCountPtr<PGL::Geometry>)
deepcopy()

deepcopy( (Scaled)arg1) -> Scaled :

C++ signature :
TOOLS::RefCountPtr<PGL::Scaled> deepcopy(PGL::Scaled {lvalue})

deepcopy( (Scaled)arg1, (DeepCopier)copier) -> Scaled :

C++ signature :
TOOLS::RefCountPtr<PGL::Scaled> deepcopy(PGL::Scaled {lvalue},PGL::DeepCopier {lvalue})
isScaleToDefault()

isScaleToDefault( (Scaled)arg1) -> bool :

C++ signature :
bool isScaleToDefault(PGL::Scaled {lvalue})
recast()

recast( (Scaled)arg1) -> Scaled :

C++ signature :
TOOLS::RefCountPtr<PGL::Scaled> recast(PGL::Scaled*)
scale
class Scaling

__init__( (object)arg1, (Vector3)arg2) -> None :

C++ signature :
void __init__(_object*,TOOLS::Vector3)
class Scene

A 3D Scene defined as a list of objects of type of Shape.

__init__( (object)arg1, (str)arg2) -> None :

Read a scene from file.

C++ signature :
void __init__(_object*,std::string)
__init__( (object)arg1 [, (int)arg2]) -> None :

Create a scene with n empty elements.

C++ signature :
void __init__(_object* [,unsigned int])
__init__( (object)arg1, (Scene)arg2) -> None :

Create an empty scene.

C++ signature :
void __init__(_object*,PGL::Scene)

__init__( (object)arg1, (list)arg2) -> object :

C++ signature :
void* __init__(boost::python::api::object,boost::python::list)
class Pool

The scene pool. Allow you to access all scene in memory using their id.

Raises an exception This class cannot be instantiated from Python

get()
get( (Pool)arg1, (int)arg2) -> Scene :

get scene from id.

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> get(PGL::Scene::Pool {lvalue},unsigned long)
getScenes()
getScenes( (Pool)arg1) -> object :

get all scene.

C++ signature :
boost::python::api::object getScenes(PGL::Scene::Pool*)
Scene.add()

add( (Scene)arg1, (Shape)arg2) -> None :

C++ signature :
void add(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Shape>)

add( (Scene)arg1, (Shape3D)arg2) -> None :

C++ signature :
void add(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Shape3D>)

add( (Scene)arg1, (Geometry)arg2) -> None :

C++ signature :
void add(PGL::Scene*,TOOLS::RefCountPtr<PGL::Geometry>)

add( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :
void add(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)
Scene.apply()

apply( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :
bool apply(PGL::Scene {lvalue},PGL::Action {lvalue})
Scene.applyAppearanceFirst()

applyAppearanceFirst( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :
bool applyAppearanceFirst(PGL::Scene {lvalue},PGL::Action {lvalue})
Scene.applyAppearanceOnly()

applyAppearanceOnly( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :
bool applyAppearanceOnly(PGL::Scene {lvalue},PGL::Action {lvalue})
Scene.applyGeometryFirst()

applyGeometryFirst( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :
bool applyGeometryFirst(PGL::Scene {lvalue},PGL::Action {lvalue})
Scene.applyGeometryOnly()

applyGeometryOnly( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :
bool applyGeometryOnly(PGL::Scene {lvalue},PGL::Action {lvalue})
Scene.clear()

clear( (Scene)arg1) -> None :

C++ signature :
void clear(PGL::Scene {lvalue})
Scene.deepcopy()

deepcopy( (Scene)arg1) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> deepcopy(PGL::Scene {lvalue})

deepcopy( (Scene)arg1, (DeepCopier)copier) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> deepcopy(PGL::Scene {lvalue},PGL::DeepCopier {lvalue})
Scene.find()

find( (Scene)arg1, (int)arg2) -> Shape :

C++ signature :
TOOLS::RefCountPtr<PGL::Shape> find(PGL::Scene*,unsigned long)
Scene.findSceneObject()

findSceneObject( (Scene)arg1, (int)arg2) -> Shape3D :

C++ signature :
TOOLS::RefCountPtr<PGL::Shape3D> findSceneObject(PGL::Scene*,unsigned long)
Scene.getId()

getId( (Scene)arg1) -> int :

C++ signature :
unsigned long getId(PGL::Scene {lvalue})
Scene.getPglReferenceCount()

getPglReferenceCount( (Scene)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::Scene {lvalue})
Scene.index()

index( (Scene)arg1, (Shape3D)arg2) -> int :

C++ signature :
unsigned int index(PGL::Scene*,TOOLS::RefCountPtr<PGL::Shape3D>)
Scene.isValid()

isValid( (Scene)arg1) -> bool :

C++ signature :
bool isValid(PGL::Scene {lvalue})
Scene.merge()

merge( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :
void merge(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)

merge( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :
void merge(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)
Scene.pool()
pool() -> Pool :

Scene pool singleton access

C++ signature :
PGL::Scene::Pool {lvalue} pool()
Scene.read()

read( (Scene)arg1, (str)arg2) -> None :

C++ signature :
void read(PGL::Scene*,std::string)

read( (Scene)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :
void read(PGL::Scene*,std::string,std::string)
Scene.remove()

remove( (Scene)arg1, (Shape3D)arg2) -> None :

C++ signature :
void remove(PGL::Scene*,TOOLS::RefCountPtr<PGL::Shape3D>)
Scene.save()

save( (Scene)arg1, (str)arg2) -> None :

C++ signature :
void save(PGL::Scene*,std::string)

save( (Scene)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :
void save(PGL::Scene*,std::string,std::string)
Scene.sort()

sort( (Scene)arg1) -> None :

C++ signature :
void sort(PGL::Scene {lvalue})
class SceneCodec

Coder/Decoder of a scene description.

__init__( (object)arg1 [, (str)name [, (Mode)mode]]) -> None :

SceneCodec([name,mode])

C++ signature :
void __init__(_object* [,std::string [,PGL::SceneCodec::Mode]])
class Mode

Enum representing coding and decoding capabilities of a codec.

SceneCodec.formats()

formats( (SceneCodec)arg1) -> SceneFormatList :

C++ signature :
std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > formats(PGL::SceneCodec {lvalue})

formats( (SceneCodec)arg1) -> None :

C++ signature :
void formats(TOOLS::RefCountPtr<PySceneCodec> {lvalue})
SceneCodec.mode
SceneCodec.name
SceneCodec.read()

read( (SceneCodec)arg1, (str)arg2) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> read(PGL::SceneCodec {lvalue},std::string)

read( (SceneCodec)arg1, (str)arg2) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> read(PySceneCodec {lvalue},std::string)
SceneCodec.test()

test( (SceneCodec)arg1, (str)arg2, (Mode)arg3) -> bool :

C++ signature :
bool test(PGL::SceneCodec {lvalue},std::string,PGL::SceneCodec::Mode)

test( (SceneCodec)arg1, (str)arg2, (Mode)arg3) -> bool :

C++ signature :
bool test(PySceneCodec {lvalue},std::string,PGL::SceneCodec::Mode)
SceneCodec.write()

write( (SceneCodec)arg1, (str)arg2, (Scene)arg3) -> None :

C++ signature :
void write(PGL::SceneCodec {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>)

write( (SceneCodec)arg1, (str)arg2, (Scene)arg3) -> None :

C++ signature :
void write(PySceneCodec {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>)
class SceneFactory

A factory of Scene that register and use SceneCodec to read scene from files.

Raises an exception This class cannot be instantiated from Python

formats()

formats( (SceneFactory)arg1, (Mode)arg2) -> SceneFormatList :

C++ signature :
std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > formats(PGL::SceneFactory {lvalue},PGL::SceneCodec::Mode)

formats( (SceneFactory)arg1) -> SceneFormatList :

C++ signature :
std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > formats(PGL::SceneFactory*)
get()

get() -> SceneFactory :

C++ signature :
PGL::SceneFactory {lvalue} get()
isReadable()

isReadable( (SceneFactory)arg1, (str)arg2) -> bool :

C++ signature :
bool isReadable(PGL::SceneFactory {lvalue},std::string)
isWritable()

isWritable( (SceneFactory)arg1, (str)arg2) -> bool :

C++ signature :
bool isWritable(PGL::SceneFactory {lvalue},std::string)
read()

read( (SceneFactory)arg1, (str)arg2) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> read(PGL::SceneFactory {lvalue},std::string)

read( (SceneFactory)arg1, (str)arg2, (str)arg3) -> Scene :

C++ signature :
TOOLS::RefCountPtr<PGL::Scene> read(PGL::SceneFactory {lvalue},std::string,std::string)
registerCodec()

registerCodec( (SceneFactory)arg1, (SceneCodec)arg2) -> None :

C++ signature :
void registerCodec(PGL::SceneFactory {lvalue},TOOLS::RefCountPtr<PGL::SceneCodec>)
unregisterCodec()

unregisterCodec( (SceneFactory)arg1, (SceneCodec)arg2) -> None :

C++ signature :
void unregisterCodec(PGL::SceneFactory {lvalue},TOOLS::RefCountPtr<PGL::SceneCodec>)
write()

write( (SceneFactory)arg1, (str)arg2, (Scene)arg3) -> None :

C++ signature :
void write(PGL::SceneFactory {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>)

write( (SceneFactory)arg1, (str)arg2, (Scene)arg3, (str)arg4) -> None :

C++ signature :
void write(PGL::SceneFactory {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>,std::string)
class SceneFormat

A scene description format.

__init__( (object)arg1, (str)arg2, (list)arg3, (str)arg4) -> object :

C++ signature :
void* __init__(boost::python::api::object,std::string,boost::python::list,std::string)
comment
name
suffixes
class SceneFormatList

A list of scene description format.

__init__( (object)arg1) -> None :

C++ signature :
void __init__(_object*)

__init__( (object)arg1, (list)arg2) -> object :

C++ signature :
void* __init__(boost::python::api::object,boost::python::list)
append()

append( (SceneFormatList)arg1, (object)arg2) -> None :

C++ signature :
void append(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)
extend()

extend( (SceneFormatList)arg1, (object)arg2) -> None :

C++ signature :
void extend(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)
class SceneObject

Abstract base class for all objects of the scenegraph. It is named, has unique id and support reference counting. It can support Action application.

Raises an exception This class cannot be instantiated from Python

apply()

apply( (SceneObject)arg1, (Action)arg2) -> bool :

C++ signature :
bool apply(PGL::SceneObject {lvalue},PGL::Action {lvalue})
getId()

getId( (SceneObject)arg1) -> int :

C++ signature :
unsigned long getId(PGL::SceneObject {lvalue})
getName()

getName( (SceneObject)arg1) -> str :

C++ signature :
std::string getName(PGL::SceneObject {lvalue})
getPglReferenceCount()

getPglReferenceCount( (SceneObject)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::SceneObject {lvalue})
isNamed()

isNamed( (SceneObject)arg1) -> bool :

C++ signature :
bool isNamed(PGL::SceneObject {lvalue})
isValid()

isValid( (SceneObject)arg1) -> bool :

C++ signature :
bool isValid(PGL::SceneObject {lvalue})
name
setName()

setName( (SceneObject)arg1, (str)arg2) -> None :

C++ signature :
void setName(PGL::SceneObject {lvalue},std::string)
class Shape

A Shape is composed of a Geometry object and an Appearance object. There is an optional id to identy the shape and parent id to store shape relationship.

__init__( (object)arg1 [, (Geometry)geometry=None [, (Appearance)appearance=Material(name=’DEFAULT_MATERIAL’,) [, (int)id=4294967295 [, (int)parentId=4294967295]]]]) -> None :

Shape( geometry, appearance, id, parentId )

C++ signature :
void __init__(_object* [,TOOLS::RefCountPtr<PGL::Geometry>=None [,TOOLS::RefCountPtr<PGL::Appearance>=Material(name=’DEFAULT_MATERIAL’,) [,unsigned int=4294967295 [,unsigned int=4294967295]]]])
__init__( (object)arg1 [, (Geometry)geometry [, (ImageTexture)appearance [, (int)id=4294967295 [, (int)parentId=4294967295]]]]) -> None :

Shape( geometry, appearance, id, parentId )

C++ signature :
void __init__(_object* [,TOOLS::RefCountPtr<PGL::Geometry> [,TOOLS::RefCountPtr<PGL::ImageTexture> [,unsigned int=4294967295 [,unsigned int=4294967295]]]])
appearance
deepcopy()

deepcopy( (Shape)arg1) -> Shape :

C++ signature :
TOOLS::RefCountPtr<PGL::Shape> deepcopy(PGL::Shape {lvalue})

deepcopy( (Shape)arg1, (DeepCopier)copier) -> Shape :

C++ signature :
TOOLS::RefCountPtr<PGL::Shape> deepcopy(PGL::Shape {lvalue},PGL::DeepCopier {lvalue})
geometry
getSceneObjectId()

getSceneObjectId( (Shape)arg1) -> int :

C++ signature :
unsigned int getSceneObjectId(PGL::Shape const*)
id
parentId
recast()

recast( (Shape)arg1) -> Shape :

C++ signature :
TOOLS::RefCountPtr<PGL::Shape> recast(PGL::Shape*)
setComputedName()

setComputedName( (Shape)arg1) -> None :

C++ signature :
void setComputedName(PGL::Shape {lvalue})
class Shape3D

Abstract base class for shape that can be stored into a scene.

Raises an exception This class cannot be instantiated from Python

class Spectrum

Abstract base class for all spectrum objects.

Raises an exception This class cannot be instantiated from Python

class Sphere
__init__( (object)arg1 [, (float)radius=0.5 [, (int)slices=8 [, (int)stacks=8]]]) -> None :

Sphere(radius [,slices, stacks])

C++ signature :
void __init__(_object* [,double=0.5 [,unsigned char=8 [,unsigned char=8]]])
deepcopy()

deepcopy( (Sphere)arg1) -> Sphere :

C++ signature :
TOOLS::RefCountPtr<PGL::Sphere> deepcopy(PGL::Sphere {lvalue})

deepcopy( (Sphere)arg1, (DeepCopier)copier) -> Sphere :

C++ signature :
TOOLS::RefCountPtr<PGL::Sphere> deepcopy(PGL::Sphere {lvalue},PGL::DeepCopier {lvalue})
isRadiusToDefault()

isRadiusToDefault( (Sphere)arg1) -> bool :

C++ signature :
bool isRadiusToDefault(PGL::Sphere {lvalue})
isStacksToDefault()

isStacksToDefault( (Sphere)arg1) -> bool :

C++ signature :
bool isStacksToDefault(PGL::Sphere {lvalue})
radius
recast()

recast( (Sphere)arg1) -> Sphere :

C++ signature :
TOOLS::RefCountPtr<PGL::Sphere> recast(PGL::Sphere*)
stacks
class Swung

A surface defined by the revolution and interpolation of several 2D profiles along Z axis.

__init__( (object)arg1, (Curve2DArray)profileList, (RealArray)angleList [, (int)slices=8 [, (bool)ccw=True [, (int)degree=3 [, (int)stride=0]]]]) -> None :

Swung(profileList,angleList,slices,ccw,degree,stride)

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2DArray>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned char=8 [,bool=True [,unsigned int=3 [,unsigned int=0]]]])
angleList
ccw
deepcopy()

deepcopy( (Swung)arg1) -> Swung :

C++ signature :
TOOLS::RefCountPtr<PGL::Swung> deepcopy(PGL::Swung {lvalue})

deepcopy( (Swung)arg1, (DeepCopier)copier) -> Swung :

C++ signature :
TOOLS::RefCountPtr<PGL::Swung> deepcopy(PGL::Swung {lvalue},PGL::DeepCopier {lvalue})
degree
interpolator
isCCWToDefault()

isCCWToDefault( (Swung)arg1) -> bool :

C++ signature :
bool isCCWToDefault(PGL::Swung {lvalue})
isDegreeToDefault()

isDegreeToDefault( (Swung)arg1) -> bool :

C++ signature :
bool isDegreeToDefault(PGL::Swung {lvalue})
isStrideToDefault()

isStrideToDefault( (Swung)arg1) -> bool :

C++ signature :
bool isStrideToDefault(PGL::Swung {lvalue})
profileList
recast()

recast( (Swung)arg1) -> Swung :

C++ signature :
TOOLS::RefCountPtr<PGL::Swung> recast(PGL::Swung*)
stride
class Taper

__init__( (object)arg1, (float)arg2, (float)arg3) -> None :

C++ signature :
void __init__(_object*,double,double)
getBaseRadius()

getBaseRadius( (Taper)arg1) -> float :

C++ signature :
double getBaseRadius(PGL::Taper {lvalue})
getTopRadius()

getTopRadius( (Taper)arg1) -> float :

C++ signature :
double getTopRadius(PGL::Taper {lvalue})
class Tapered

Tapered describes an object to which it has been applied a Taper deformation. A Taper deforms an object in order to be able to bound the object within a cone frustum of a specified base radius and top radius. For each point composing an object, a Taper scale the polar coordinates according the zcoordinate. The amplitude of the scale is given by the radii.

__init__( (object)arg1 [, (float)baseRadius=0.5 [, (float)topRadius=0.5 [, (Primitive)primitive=None]]]) -> None :

Tapered(baseRadius, topRadius, primitive)

C++ signature :
void __init__(_object* [,double=0.5 [,double=0.5 [,TOOLS::RefCountPtr<PGL::Primitive>=None]]])
baseRadius
deepcopy()

deepcopy( (Tapered)arg1) -> Tapered :

C++ signature :
TOOLS::RefCountPtr<PGL::Tapered> deepcopy(PGL::Tapered {lvalue})

deepcopy( (Tapered)arg1, (DeepCopier)copier) -> Tapered :

C++ signature :
TOOLS::RefCountPtr<PGL::Tapered> deepcopy(PGL::Tapered {lvalue},PGL::DeepCopier {lvalue})
isBaseRadiusToDefault()

isBaseRadiusToDefault( (Tapered)arg1) -> bool :

C++ signature :
bool isBaseRadiusToDefault(PGL::Tapered {lvalue})
isTopRadiusToDefault()

isTopRadiusToDefault( (Tapered)arg1) -> bool :

C++ signature :
bool isTopRadiusToDefault(PGL::Tapered {lvalue})
primitive
recast()

recast( (Tapered)arg1) -> Tapered :

C++ signature :
TOOLS::RefCountPtr<PGL::Tapered> recast(PGL::Tapered*)
topRadius
class Text

Text with font. It support display in screen or world coordinates.

__init__( (object)arg1, (str)string [, (Vector3)position=Vector3(0,0,0) [, (bool)screencoordinates=False [, (Font)fontstyle=None]]]) -> None :

Text(str string[, Vector3 position, bool screencoordinates, Font fontstyle])

C++ signature :
void __init__(_object*,std::string [,TOOLS::Vector3=Vector3(0,0,0) [,bool=False [,TOOLS::RefCountPtr<PGL::Font>=None]]])
deepcopy()

deepcopy( (Text)arg1) -> Text :

C++ signature :
TOOLS::RefCountPtr<PGL::Text> deepcopy(PGL::Text {lvalue})

deepcopy( (Text)arg1, (DeepCopier)copier) -> Text :

C++ signature :
TOOLS::RefCountPtr<PGL::Text> deepcopy(PGL::Text {lvalue},PGL::DeepCopier {lvalue})
fontstyle
isFontStyleToDefault()

isFontStyleToDefault( (Text)arg1) -> bool :

C++ signature :
bool isFontStyleToDefault(PGL::Text {lvalue})
isPositionToDefault()

isPositionToDefault( (Text)arg1) -> bool :

C++ signature :
bool isPositionToDefault(PGL::Text {lvalue})
isScreenCoordinatesToDefault()

isScreenCoordinatesToDefault( (Text)arg1) -> bool :

C++ signature :
bool isScreenCoordinatesToDefault(PGL::Text {lvalue})
position
recast()

recast( (Text)arg1) -> Text :

C++ signature :
TOOLS::RefCountPtr<PGL::Text> recast(PGL::Text*)
screencoordinates
string
class Texture2D

The material of a textured object.

__init__( (object)arg1, (ImageTexture)image [, (Texture2DTransformation)transformation]) -> None :

Texture2D(image [,transformation])

C++ signature :
void __init__(_object*,TOOLS::RefCountPtr<PGL::ImageTexture> [,TOOLS::RefCountPtr<PGL::Texture2DTransformation>])
__init__( (object)arg1, (str)name, (ImageTexture)image [, (Texture2DTransformation)transformation]) -> None :

Texture2D(name, image [,transformation])

C++ signature :
void __init__(_object*,std::string,TOOLS::RefCountPtr<PGL::ImageTexture> [,TOOLS::RefCountPtr<PGL::Texture2DTransformation>])
image
isTransformationToDefault()

isTransformationToDefault( (Texture2D)arg1) -> bool :

C++ signature :
bool isTransformationToDefault(PGL::Texture2D {lvalue})
transformation
class Texture2DTransformation

The transformation of a texture 2D.

__init__( (object)arg1 [, (str)name [, (Vector2)scale=Vector2(1,1) [, (Vector2)translation=Vector2(0,0) [, (Vector2)rotationCenter=Vector2(0.5,0.5) [, (float)rotationAngle=0.0]]]]]) -> None :

Texture2D([name,scale,translation,rotationCenter,rotationAngle])

C++ signature :
void __init__(_object* [,std::string [,TOOLS::Vector2=Vector2(1,1) [,TOOLS::Vector2=Vector2(0,0) [,TOOLS::Vector2=Vector2(0.5,0.5) [,double=0.0]]]]])
isRotationAngleToDefault()

isRotationAngleToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :
bool isRotationAngleToDefault(PGL::Texture2DTransformation {lvalue})
isRotationCenterToDefault()

isRotationCenterToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :
bool isRotationCenterToDefault(PGL::Texture2DTransformation {lvalue})
isScaleToDefault()

isScaleToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :
bool isScaleToDefault(PGL::Texture2DTransformation {lvalue})
isTranslationToDefault()

isTranslationToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :
bool isTranslationToDefault(PGL::Texture2DTransformation {lvalue})
rotationAngle
rotationCenter
scale
transform()

transform( (Texture2DTransformation)arg1, (Point3Array)points3) -> Point3Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Array> transform(PGL::Texture2DTransformation {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)

transform( (Texture2DTransformation)arg1, (Point2Array)points2) -> Point2Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point2Array> transform(PGL::Texture2DTransformation {lvalue},TOOLS::RefCountPtr<PGL::Point2Array>)

transform( (Texture2DTransformation)arg1, (Vector2)point) -> Vector2 :

C++ signature :
TOOLS::Vector2 transform(PGL::Texture2DTransformation {lvalue},TOOLS::Vector2)
translation
class Transform4

__init__( (object)arg1, (Matrix4)arg2) -> None :

C++ signature :
void __init__(_object*,TOOLS::Matrix4)

__init__( (object)arg1) -> object :

C++ signature :
void* __init__(boost::python::api::object)
getTransformation()
getTransformation( (Transform4)arg1) -> tuple :

Return scale, rotate and translate corresponding values.

C++ signature :
boost::python::tuple getTransformation(PGL::Transform4*)
getVolume()
getVolume( (Transform4)arg1) -> float :

compute the Matrix3 determinant of the transformation

C++ signature :
double getVolume(PGL::Transform4 {lvalue})
isValid()

isValid( (Transform4)arg1) -> bool :

C++ signature :
bool isValid(PGL::Transform4 {lvalue})
rotate()
rotate( (Transform4)arg1, (Matrix3)arg2) -> None :

Add a rotation at the transformation

C++ signature :
void rotate(PGL::Transform4 {lvalue},TOOLS::Matrix3)
scale()
scale( (Transform4)arg1, (Vector3)arg2) -> None :

Add a scaling at the transformation

C++ signature :
void scale(PGL::Transform4 {lvalue},TOOLS::Vector3)
transform()
transform( (Transform4)arg1, (Point3Array)arg2) -> Point3Array :

transform a set of points

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Array> transform(PGL::Transform4*,TOOLS::RefCountPtr<PGL::Point3Array>)
translate()
translate( (Transform4)arg1, (Vector3)arg2) -> None :

Add a translation at the transformation

C++ signature :
void translate(PGL::Transform4 {lvalue},TOOLS::Vector3)
class Transform4Array
__init__( (object)arg1, (int)size) -> None :

Transform4Array(int size)

C++ signature :
void __init__(_object*,unsigned long)
__init__( (object)arg1, (object)arg2) -> object :

Transform4Array([Transform4(...),...])

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)
append()

append( (Transform4Array)arg1, (Transform4)arg2) -> None :

C++ signature :
void append(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,TOOLS::RefCountPtr<PGL::Transform4>)

append( (Transform4Array)arg1, (Transform4Array)arg2) -> None :

C++ signature :
void append(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)
clear()

clear( (Transform4Array)arg1) -> None :

C++ signature :
void clear(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
getId()

getId( (Transform4Array)arg1) -> int :

C++ signature :
unsigned long getId(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)
getPglId()

getPglId( (Transform4Array)arg1) -> int :

C++ signature :
unsigned long getPglId(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
getPglReferenceCount()

getPglReferenceCount( (Transform4Array)arg1) -> int :

C++ signature :
unsigned long getPglReferenceCount(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
insert()

insert( (Transform4Array)arg1, (int)arg2, (Transform4)arg3) -> None :

C++ signature :
void insert(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,int,TOOLS::RefCountPtr<PGL::Transform4>)
pop()

pop( (Transform4Array)arg1 [, (int)arg2]) -> Transform4 :

C++ signature :
TOOLS::RefCountPtr<PGL::Transform4> pop(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >* [,int])
prepend()

prepend( (Transform4Array)arg1, (Transform4)arg2) -> None :

C++ signature :
void prepend(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,TOOLS::RefCountPtr<PGL::Transform4>)

prepend( (Transform4Array)arg1, (Transform4Array)arg2) -> None :

C++ signature :
void prepend(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)
reverse()

reverse( (Transform4Array)arg1) -> None :

C++ signature :
void reverse(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
class Transformation

Raises an exception This class cannot be instantiated from Python

class Transformation2D

Raises an exception This class cannot be instantiated from Python

transform()

transform( (Transformation2D)arg1, (Point2Array)arg2) -> Point2Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point2Array> transform(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point2Array>)
transformP2Matrix()

transformP2Matrix( (Transformation2D)arg1, (Point2Matrix)arg2) -> Point2Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point2Matrix> transformP2Matrix(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point2Matrix>)
transformP3List()

transformP3List( (Transformation2D)arg1, (Point3Array)arg2) -> Point3Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Array> transformP3List(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)
transformP3Matrix()

transformP3Matrix( (Transformation2D)arg1, (Point3Matrix)arg2) -> Point3Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point3Matrix>)
class Transformation3D

Raises an exception This class cannot be instantiated from Python

transform()

transform( (Transformation3D)arg1, (Point3Array)arg2) -> Point3Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Array> transform(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)
transformP3Matrix()

transformP3Matrix( (Transformation3D)arg1, (Point3Matrix)arg2) -> Point3Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point3Matrix>)
transformP4List()

transformP4List( (Transformation3D)arg1, (Point4Array)arg2) -> Point4Array :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Array> transformP4List(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point4Array>)
transformP4Matrix()

transformP4Matrix( (Transformation3D)arg1, (Point4Matrix)arg2) -> Point4Matrix :

C++ signature :
TOOLS::RefCountPtr<PGL::Point4Matrix> transformP4Matrix(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point4Matrix>)
class Transformed

Abstract base class for trasnformed node. It suppose to contain object on which the transformation is applied.

Raises an exception This class cannot be instantiated from Python

transformation()

transformation( (Transformed)arg1) -> Transformation3D :

C++ signature :
TOOLS::RefCountPtr<PGL::Transformation3D> transformation(PGL::Transformed {lvalue})
class Translated

A Translated describes an object to which a translation of a specified vector is applied. The translation is given by the homogeneous matrix: |1 0 0 tx| |0 1 0 ty| |0 0 1 tz| |0 0 0 1 | where (tx, ty, tz) denotes the translation vector.

__init__( (object)arg1 [, (Vector3)translation=Vector3(0,0,0) [, (Geometry)geometry=None]]) -> None :

Translated(translation,geometry)

C++ signature :
void __init__(_object* [,TOOLS::Vector3=Vector3(0,0,0) [,TOOLS::RefCountPtr<PGL::Geometry>=None]])

__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (Geometry)arg5) -> object :

C++ signature :
void* __init__(boost::python::api::object,double,double,double,TOOLS::RefCountPtr<PGL::Geometry>)
deepcopy()

deepcopy( (Translated)arg1) -> Translated :

C++ signature :
TOOLS::RefCountPtr<PGL::Translated> deepcopy(PGL::Translated {lvalue})

deepcopy( (Translated)arg1, (DeepCopier)copier) -> Translated :

C++ signature :
TOOLS::RefCountPtr<PGL::Translated> deepcopy(PGL::Translated {lvalue},PGL::DeepCopier {lvalue})
isTranslationToDefault()

isTranslationToDefault( (Translated)arg1) -> bool :

C++ signature :
bool isTranslationToDefault(PGL::Translated {lvalue})
recast()

recast( (Translated)arg1) -> Translated :

C++ signature :
TOOLS::RefCountPtr<PGL::Translated> recast(PGL::Translated*)
translation
class Translation

__init__( (object)arg1, (Vector3)arg2) -> None :

C++ signature :
void __init__(_object*,TOOLS::Vector3)
class TriangleSet

A TriangleSet describes a surface formed by a set of connected triangles, i.e. three sided polygons. Triangles are specified using set of tuples of 3 indices (Index3) pointing to a list of points.

__init__( (object)arg1 [, (Point3Array)pointList=None [, (Index3Array)indexList=None [, (Point3Array)normalList=None [, (Index3Array)normalIndexList=None [, (Color4Array)colorList=None [, (Index3Array)colorIndexList=None [, (Point2Array)texCoordList=None [, (Index3Array)texCoordIndexList=None [, (bool)normalPerVertex=True [, (bool)colorPerVertex=True [, (bool)ccw=True [, (bool)solid=False [, (Polyline)skeleton=None]]]]]]]]]]]]]) -> None :

__init__(Point3Array pointList, IndexArray indexList [, Point3Array normalList, IndexArray nomalIndexList, Color4Array colorList, IndexArray colorIndexList, Point2Array texCoordList, IndexArray texCoordIndexList, bool normalPerVertex, bool colorPerVertex, bool ccw, bool solid, Polyline skeleton])

C++ signature :
void __init__(_object* [,TOOLS::RefCountPtr<PGL::Point3Array>=None [,TOOLS::RefCountPtr<PGL::Index3Array>=None [,TOOLS::RefCountPtr<PGL::Point3Array>=None [,TOOLS::RefCountPtr<PGL::Index3Array>=None [,TOOLS::RefCountPtr<PGL::Color4Array>=None [,TOOLS::RefCountPtr<PGL::Index3Array>=None [,TOOLS::RefCountPtr<PGL::Point2Array>=None [,TOOLS::RefCountPtr<PGL::Index3Array>=None [,bool=True [,bool=True [,bool=True [,bool=False [,TOOLS::RefCountPtr<PGL::Polyline>=None]]]]]]]]]]]]])
colorAt()

colorAt( (TriangleSet)arg1, (int)arg2) -> Color4 :

C++ signature :
PGL::Color4 colorAt(PGL::TriangleSet {lvalue},unsigned int)
colorIndexAt()

colorIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :
TOOLS::Tuple3<unsigned int> colorIndexAt(PGL::TriangleSet {lvalue},unsigned int)
colorIndexList
deepcopy()

deepcopy( (TriangleSet)arg1) -> TriangleSet :

C++ signature :
TOOLS::RefCountPtr<PGL::TriangleSet> deepcopy(PGL::TriangleSet {lvalue})

deepcopy( (TriangleSet)arg1, (DeepCopier)copier) -> TriangleSet :

C++ signature :
TOOLS::RefCountPtr<PGL::TriangleSet> deepcopy(PGL::TriangleSet {lvalue},PGL::DeepCopier {lvalue})
faceColorAt()

faceColorAt( (TriangleSet)arg1, (int)arg2, (int)arg3) -> Color4 :

C++ signature :
PGL::Color4 faceColorAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)
faceNormalAt()

faceNormalAt( (TriangleSet)arg1, (int)arg2, (int)arg3) -> Vector3 :

C++ signature :
TOOLS::Vector3 faceNormalAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)
faceTexCoordAt()

faceTexCoordAt( (TriangleSet)arg1, (int)arg2, (int)arg3) -> Vector2 :

C++ signature :
TOOLS::Vector2 faceTexCoordAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)
indexAt()

indexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :
TOOLS::Tuple3<unsigned int> indexAt(PGL::TriangleSet {lvalue},unsigned int)
indexList
isColorIndexListToDefault()

isColorIndexListToDefault( (TriangleSet)arg1) -> bool :

C++ signature :
bool isColorIndexListToDefault(PGL::TriangleSet {lvalue})
isNormalIndexListToDefault()

isNormalIndexListToDefault( (TriangleSet)arg1) -> bool :

C++ signature :
bool isNormalIndexListToDefault(PGL::TriangleSet {lvalue})
isTexCoordIndexListToDefault()

isTexCoordIndexListToDefault( (TriangleSet)arg1) -> bool :

C++ signature :
bool isTexCoordIndexListToDefault(PGL::TriangleSet {lvalue})
normalAt()

normalAt( (TriangleSet)arg1, (int)arg2) -> Vector3 :

C++ signature :
TOOLS::Vector3 normalAt(PGL::TriangleSet {lvalue},unsigned int)
normalIndexAt()

normalIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :
TOOLS::Tuple3<unsigned int> normalIndexAt(PGL::TriangleSet {lvalue},unsigned int)
normalIndexList
recast()

recast( (TriangleSet)arg1) -> TriangleSet :

C++ signature :
TOOLS::RefCountPtr<PGL::TriangleSet> recast(PGL::TriangleSet*)
texCoordAt()

texCoordAt( (TriangleSet)arg1, (int)arg2) -> Vector2 :

C++ signature :
TOOLS::Vector2 texCoordAt(PGL::TriangleSet {lvalue},unsigned int)
texCoordIndexAt()

texCoordIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :
TOOLS::Tuple3<unsigned int> texCoordIndexAt(PGL::TriangleSet {lvalue},unsigned int)
texCoordIndexList
closestPointToSegment()

closestPointToSegment( (Vector3)point, (Vector3)segA, (Vector3)segB) -> object :

C++ signature :
boost::python::api::object closestPointToSegment(TOOLS::Vector3,TOOLS::Vector3,TOOLS::Vector3)

closestPointToSegment( (Vector2)point, (Vector2)segA, (Vector2)segB) -> object :

C++ signature :
boost::python::api::object closestPointToSegment(TOOLS::Vector2,TOOLS::Vector2,TOOLS::Vector2)
getPGLVersion()

getPGLVersion() -> float :

C++ signature :
float getPGLVersion()
get_pgl_python_error_style()

get_pgl_python_error_style() -> bool :

C++ signature :
bool get_pgl_python_error_style()
get_pgl_supported_extensions()
get_pgl_supported_extensions() -> object :

Gives all extensions supported by current version of PlantGL.

C++ signature :
boost::python::api::object get_pgl_supported_extensions()
pgl_support_extension()
pgl_support_extension( (str)ext) -> bool :

Tell wether PlantGL support a given extension

C++ signature :
bool pgl_support_extension(std::string)
set_pgl_python_error_style()

set_pgl_python_error_style( (bool)arg1) -> None :

C++ signature :
void set_pgl_python_error_style(bool)

2.3. openalea.plantgl.scenegraph.cspline module

Class Cardinal Spline. A cardinal spline is a spline passing through a set of points.

class CSpline(points, is_closed=False)[source]

A CSpline interpolate a set of points.

Create a CSpline from a set of 2d or 3d points.

add_point(pt)[source]
bezier_cp()[source]

Compute bezier control points from the input points.

bezier_kv(is_linear=False)[source]

Compute a nurbs knot vector from Bezier control points. bezier_kv(linear=False) -> knot_vector

Param :is_linear indicate if the parametrization is linear or

pseudo curvilinear abscisse.

curve(is_linear=False, stride_factor=10, distances=None)[source]

Return the equivalent PlantGL nurbs curve which interpol the points. :param: stride_factor is the number of points to draw an arc of the curve.

derivatives()[source]

Compute the derivatives based on the knots and the distance. At Pi, the derivative is:

D_i = P_(i-1)P_i / 4||.|| + P_iP_(i+1) / 4||.||
distances()[source]

Compute the distance between the input points.

move_point(i, pt)[source]
cspline(pts, is_closed=False, is_linear=False, distances=None)[source]

Build a nurbs curve by interpolate (C1) the points pts. The resulting curve can be closed.

norm()
norm( (object)v) -> object :

The norm of the vector. If v.__norm__() exists, call it.

C++ signature :
boost::python::api::object norm(boost::python::api::object)

norm( (float)arg1, (float)arg2 [, (float)arg3 [, (float)arg4 [, (float)arg5 [, (float)arg6 [, (float)arg7 [, (float)arg8 [, (float)arg9 [, (float)arg10 [, (float)arg11 [, (float)arg12 [, (float)arg13 [, (float)arg14 [, (float)arg15]]]]]]]]]]]]]) -> float :

C++ signature :
double norm(double,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double]]]]]]]]]]]]])

2.4. openalea.plantgl.scenegraph.nurbspatch_nd module

class NurbsPatch3D(points, udeg=3, vdeg=3, wdeg=3, uknots=None, vknots=None, wknots=None, ustride=30, vstride=30, wstride=30)[source]
getParametrization(p)[source]

return (u,v,t)

getPointAt(u, v, w)[source]

Compute point at (u,v,w)

getUPatch(u)[source]
getVPatch(v)[source]
getWDerivativeAt(u, v, w)[source]

Compute point at (u,v,w)

getWPatch(w)[source]
isValid()[source]

Test whether self is valid or not