2. Scene Graph library

2.1. Class Inheritance diagram

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:

deepcopy((AmapSymbol)arg1) → AmapSymbol :

C++ signature :

PGL::RefCountPtr<PGL::AmapSymbol> deepcopy(PGL::AmapSymbol {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::AmapSymbol> deepcopy(PGL::AmapSymbol {lvalue},PGL::DeepCopier {lvalue})

property filename

readFile((AmapSymbol)arg1, (str)arg2) → bool :

C++ signature :

bool readFile(PGL::AmapSymbol {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

recast((AmapSymbol)arg1) → AmapSymbol :

C++ signature :

PGL::RefCountPtr<PGL::AmapSymbol> recast(PGL::AmapSymbol*)

class Appearance

Abstract base class for all appearance objects.

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.

DEFAULT_BOTTOM = Vector3(0,0,-0.5)

DEFAULT_BOTTOM_SHAPE = 2.0

DEFAULT_NEG_X_HEIGHT = 0.0

DEFAULT_NEG_X_RADIUS = 0.5

DEFAULT_NEG_Y_HEIGHT = 0.0

DEFAULT_NEG_Y_RADIUS = 0.5

DEFAULT_POS_X_HEIGHT = 0.0

DEFAULT_POS_X_RADIUS = 0.5

DEFAULT_POS_Y_HEIGHT = 0.0

DEFAULT_POS_Y_RADIUS = 0.5

DEFAULT_SLICES = 4

DEFAULT_STACKS = 4

DEFAULT_TOP = Vector3(0,0,0.5)

DEFAULT_TOP_SHAPE = 2.0

property bottom

property bottomShape

deepcopy((AsymmetricHull)arg1) → AsymmetricHull :

C++ signature :

PGL::RefCountPtr<PGL::AsymmetricHull> deepcopy(PGL::AsymmetricHull {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::AsymmetricHull> deepcopy(PGL::AsymmetricHull {lvalue},PGL::DeepCopier {lvalue})

isBottomShapeToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isBottomShapeToDefault(PGL::AsymmetricHull {lvalue})

isBottomToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isBottomToDefault(PGL::AsymmetricHull {lvalue})

isNegXHeightToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isNegXHeightToDefault(PGL::AsymmetricHull {lvalue})

isNegXRadiusToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isNegXRadiusToDefault(PGL::AsymmetricHull {lvalue})

isNegYHeightToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isNegYHeightToDefault(PGL::AsymmetricHull {lvalue})

isNegYRadiusToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isNegYRadiusToDefault(PGL::AsymmetricHull {lvalue})

isPosXHeightToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isPosXHeightToDefault(PGL::AsymmetricHull {lvalue})

isPosXRadiusToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isPosXRadiusToDefault(PGL::AsymmetricHull {lvalue})

isPosYHeightToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isPosYHeightToDefault(PGL::AsymmetricHull {lvalue})

isPosYRadiusToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isPosYRadiusToDefault(PGL::AsymmetricHull {lvalue})

isSlicesToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isSlicesToDefault(PGL::AsymmetricHull {lvalue})

isStacksToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isStacksToDefault(PGL::AsymmetricHull {lvalue})

isTopShapeToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isTopShapeToDefault(PGL::AsymmetricHull {lvalue})

isTopToDefault((AsymmetricHull)arg1) → bool :

C++ signature :

bool isTopToDefault(PGL::AsymmetricHull {lvalue})

property negXHeight

property negXRadius

property negYHeight

property negYRadius

property posXHeight

property posXRadius

property posYHeight

property posYRadius

recast((AsymmetricHull)arg1) → AsymmetricHull :

C++ signature :

PGL::RefCountPtr<PGL::AsymmetricHull> recast(PGL::AsymmetricHull*)

property slices

property stacks

property top

property 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.

DEFAULT_ANGLE = 0.0

DEFAULT_AXIS = Vector3(0,0,1)

property angle

property axis

deepcopy((AxisRotated)arg1) → AxisRotated :

C++ signature :

PGL::RefCountPtr<PGL::AxisRotated> deepcopy(PGL::AxisRotated {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::AxisRotated> deepcopy(PGL::AxisRotated {lvalue},PGL::DeepCopier {lvalue})

isAngleToDefault((AxisRotated)arg1) → bool :

C++ signature :

bool isAngleToDefault(PGL::AxisRotated {lvalue})

isAxisToDefault((AxisRotated)arg1) → bool :

C++ signature :

bool isAxisToDefault(PGL::AxisRotated {lvalue})

recast((AxisRotated)arg1) → AxisRotated :

C++ signature :

PGL::RefCountPtr<PGL::AxisRotated> recast(PGL::AxisRotated*)

class AxisRotation

class BaseOrientation

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.

DEFAULT_STRIDE = 30

static bernstein((object)i, (object)n, (object)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)

static bernstein_factors((object)n, (object)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)

property ctrlPointList

deepcopy((BezierCurve)arg1) → BezierCurve :

C++ signature :

PGL::RefCountPtr<PGL::BezierCurve> deepcopy(PGL::BezierCurve {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::BezierCurve> deepcopy(PGL::BezierCurve {lvalue},PGL::DeepCopier {lvalue})

isStrideToDefault((BezierCurve)arg1) → bool :

C++ signature :

bool isStrideToDefault(PGL::BezierCurve {lvalue})

recast((BezierCurve)arg1) → BezierCurve :

C++ signature :

PGL::RefCountPtr<PGL::BezierCurve> recast(PGL::BezierCurve*)

property 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.

property ctrlPointList

deepcopy((BezierCurve2D)arg1) → BezierCurve2D :

C++ signature :

PGL::RefCountPtr<PGL::BezierCurve2D> deepcopy(PGL::BezierCurve2D {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::BezierCurve2D> deepcopy(PGL::BezierCurve2D {lvalue},PGL::DeepCopier {lvalue})

isStrideToDefault((BezierCurve2D)arg1) → bool :

C++ signature :

bool isStrideToDefault(PGL::BezierCurve2D {lvalue})

recast((BezierCurve2D)arg1) → BezierCurve2D :

C++ signature :

PGL::RefCountPtr<PGL::BezierCurve2D> recast(PGL::BezierCurve2D*)

property 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.

DEFAULT_STRIDE = 30

property ctrlPointMatrix

deepcopy((BezierPatch)arg1) → BezierPatch :

C++ signature :

PGL::RefCountPtr<PGL::BezierPatch> deepcopy(PGL::BezierPatch {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::BezierPatch> deepcopy(PGL::BezierPatch {lvalue},PGL::DeepCopier {lvalue})

getIsoUSectionAt((BezierPatch)arg1, (object)u) → LineicModel :

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

C++ signature :

PGL::RefCountPtr<PGL::LineicModel> getIsoUSectionAt(PGL::BezierPatch {lvalue},double)

getIsoVSectionAt((BezierPatch)arg1, (object)v) → LineicModel :

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

C++ signature :

PGL::RefCountPtr<PGL::LineicModel> getIsoVSectionAt(PGL::BezierPatch {lvalue},double)

getPointAt((BezierPatch)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getPointAt(PGL::BezierPatch {lvalue},double,double)

isUStrideToDefault((BezierPatch)arg1) → bool :

C++ signature :

bool isUStrideToDefault(PGL::BezierPatch {lvalue})

isVStrideToDefault((BezierPatch)arg1) → bool :

C++ signature :

bool isVStrideToDefault(PGL::BezierPatch {lvalue})

recast((BezierPatch)arg1) → BezierPatch :

C++ signature :

PGL::RefCountPtr<PGL::BezierPatch> recast(PGL::BezierPatch*)

property udegree

property ustride

property vdegree

property vstride

class BoundingBox

An axis aligned box represented by 2 opposite corners.

change((BoundingBox)arg1, (Vector3)arg2, (Vector3)arg3) → None :

change(center)

C++ signature :

void change(PGL::BoundingBox {lvalue},PGL::Vector3,PGL::Vector3)

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*,PGL::Vector3)

corners()

distance((BoundingBox)arg1, (BoundingBox)arg2) → float :

C++ signature :

double distance(PGL::BoundingBox*,PGL::BoundingBox*)

distance( (BoundingBox)arg1, (Vector3)arg2) -> float :

C++ signature :

double distance(PGL::BoundingBox*,PGL::Vector3)

extend((BoundingBox)arg1, (BoundingBox)arg2) → None :

C++ signature :

void extend(PGL::BoundingBox*,PGL::BoundingBox*)

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

C++ signature :

void extend(PGL::BoundingBox*,PGL::Vector3)

getCenter((BoundingBox)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getCenter(PGL::BoundingBox {lvalue})

getId((BoundingBox)arg1) → int :

C++ signature :

unsigned long getId(PGL::BoundingBox {lvalue})

getSize((BoundingBox)arg1) → Vector3 :

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

C++ signature :

PGL::Vector3 getSize(PGL::BoundingBox {lvalue})

getXMax((BoundingBox)arg1) → float :

C++ signature :

double getXMax(PGL::BoundingBox {lvalue})

getXMin((BoundingBox)arg1) → float :

C++ signature :

double getXMin(PGL::BoundingBox {lvalue})

getXRange((BoundingBox)arg1) → float :

C++ signature :

double getXRange(PGL::BoundingBox {lvalue})

getYMax((BoundingBox)arg1) → float :

C++ signature :

double getYMax(PGL::BoundingBox {lvalue})

getYMin((BoundingBox)arg1) → float :

C++ signature :

double getYMin(PGL::BoundingBox {lvalue})

getYRange((BoundingBox)arg1) → float :

C++ signature :

double getYRange(PGL::BoundingBox {lvalue})

getZMax((BoundingBox)arg1) → float :

C++ signature :

double getZMax(PGL::BoundingBox {lvalue})

getZMin((BoundingBox)arg1) → float :

C++ signature :

double getZMin(PGL::BoundingBox {lvalue})

getZRange((BoundingBox)arg1) → float :

C++ signature :

double getZRange(PGL::BoundingBox {lvalue})

intersect((BoundingBox)arg1, (BoundingBox)arg2) → bool :

C++ signature :

bool intersect(PGL::BoundingBox*,PGL::BoundingBox*)

property lowerLeftCorner

scale((BoundingBox)arg1, (Vector3)arg2) → None :

C++ signature :

void scale(PGL::BoundingBox {lvalue},PGL::Vector3)

set((BoundingBox)arg1, (Vector3)arg2, (Vector3)arg3) → None :

set(lowerLeft,upperRight)

C++ signature :

void set(PGL::BoundingBox {lvalue},PGL::Vector3,PGL::Vector3)

transform((BoundingBox)arg1, (Matrix4)arg2) → None :

C++ signature :

void transform(PGL::BoundingBox {lvalue},PGL::Matrix4)

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

C++ signature :

void transform(PGL::BoundingBox {lvalue},PGL::Matrix3)

translate((BoundingBox)arg1, (Vector3)arg2) → None :

C++ signature :

void translate(PGL::BoundingBox {lvalue},PGL::Vector3)

property 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.

DEFAULT_SIZE = Vector3(0.5,0.5,0.5)

deepcopy((Box)arg1) → Box :

C++ signature :

PGL::RefCountPtr<PGL::Box> deepcopy(PGL::Box {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Box> deepcopy(PGL::Box {lvalue},PGL::DeepCopier {lvalue})

isSizeToDefault((Box)arg1) → bool :

C++ signature :

bool isSizeToDefault(PGL::Box {lvalue})

recast((Box)arg1) → Box :

C++ signature :

PGL::RefCountPtr<PGL::Box> recast(PGL::Box*)

property size

class Color3

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

BLACK = Color3(0,0,0)

BLUE = Color3(0,0,255)

CYAN = Color3(0,255,255)

GREEN = Color3(0,255,0)

RED = Color3(255,0,0)

WHITE = Color3(255,255,255)

YELLOW = Color3(255,255,0)

property blue

clampedBlue((Color3)arg1) → float :

C++ signature :

double clampedBlue(PGL::Color3*)

clampedGreen((Color3)arg1) → float :

C++ signature :

double clampedGreen(PGL::Color3*)

clampedRed((Color3)arg1) → float :

C++ signature :

double clampedRed(PGL::Color3*)

static fromHSV((object)arg1) → Color3 :

Construct a Color3 from a tuple containing HSV values (H should be in [0,255] if int or [0.,360.[ if float, S and V should be in [0,255])

C++ signature :

PGL::Color3 fromHSV(boost::python::api::object)

static fromUint((object)value[, (eColor3Format)format=openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB]) → Color3 :

C++ signature :

PGL::Color3 fromUint(unsigned int [,PGL::Color3::eColor3Format=openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB])

getAverage((Color3)arg1) → float :

C++ signature :

double getAverage(PGL::Color3 {lvalue})

getAverageClamped((Color3)arg1) → float :

C++ signature :

double getAverageClamped(PGL::Color3 {lvalue})

property green

interpolate((Color3)arg1, (Color3)c[, (object)alpha=0.5]) → Color3 :

C++ signature :

PGL::Color3 interpolate(PGL::Color3,PGL::Color3 [,double=0.5])

interpolate( (Color3)c0, (object)w0=0.3333333333333333, (Color3)c1, (object)w1=0.3333333333333333, (Color3)c2 [, (object)w2=0.3333333333333333]) -> Color3 :

C++ signature :

PGL::Color3 interpolate(PGL::Color3,double=0.3333333333333333,PGL::Color3,double=0.3333333333333333,PGL::Color3 [,double=0.3333333333333333])

property red

setClampedBlue((Color3)arg1, (object)arg2) → None :

C++ signature :

void setClampedBlue(PGL::Color3*,double)

setClampedGreen((Color3)arg1, (object)arg2) → None :

C++ signature :

void setClampedGreen(PGL::Color3*,double)

setClampedRed((Color3)arg1, (object)arg2) → None :

C++ signature :

void setClampedRed(PGL::Color3*,double)

toHSV((Color3)arg1) → object :

C++ signature :

boost::python::api::object toHSV(PGL::Color3*)

toHSV8((Color3)arg1) → object :

C++ signature :

boost::python::api::object toHSV8(PGL::Color3*)

toUint((Color3)arg1[, (eColor3Format)format=openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB]) → int :

C++ signature :

unsigned int toUint(PGL::Color3 {lvalue} [,PGL::Color3::eColor3Format=openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB])

class Color3Array

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((Color3Array)arg1) → None :

C++ signature :

void clear(PGL::Color3Array {lvalue})

empty((Color3Array)arg1) → bool :

C++ signature :

bool empty(PGL::Color3Array {lvalue})

getId((Color3Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Color3Array*)

insert((Color3Array)arg1, (object)arg2, (Color3)arg3) → None :

C++ signature :

void insert(PGL::Color3Array*,int,PGL::Color3)

static load((str)arg1) → Color3Array :

C++ signature :

PGL::RefCountPtr<PGL::Color3Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

opposite_subset((Color3Array)arg1, (object)arg2) → Color3Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Color3Array* opposite_subset(PGL::Color3Array*,boost::python::api::object)

pop((Color3Array)arg1[, (object)arg2]) → Color3 :

C++ signature :

PGL::Color3 pop(PGL::Color3Array* [,int])

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((Color3Array)arg1) → None :

C++ signature :

void reverse(PGL::Color3Array {lvalue})

save((Color3Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Color3Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((Color3Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Color3Array*,boost::python::api::object)

split_indices((Color3Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Color3Array*,boost::python::api::object)

split_subset((Color3Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Color3Array*,boost::python::api::object)

subset((Color3Array)arg1, (object)arg2) → Color3Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Color3Array* subset(PGL::Color3Array*,boost::python::api::object)

class Color4

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

BLACK = Color4(0,0,0,0)

BLUE = Color4(0,0,255,0)

CYAN = Color4(0,255,255,0)

GREEN = Color4(0,255,0,0)

RED = Color4(255,0,0,0)

WHITE = Color4(255,255,255,0)

YELLOW = Color4(255,255,0,0)

property alpha

property blue

clampedAlpha((Color4)arg1) → float :

C++ signature :

double clampedAlpha(PGL::Color4*)

clampedBlue((Color4)arg1) → float :

C++ signature :

double clampedBlue(PGL::Color4*)

clampedGreen((Color4)arg1) → float :

C++ signature :

double clampedGreen(PGL::Color4*)

clampedRed((Color4)arg1) → float :

C++ signature :

double clampedRed(PGL::Color4*)

static fromHSVA((object)arg1) → Color4 :

C++ signature :

PGL::Color4 fromHSVA(boost::python::api::object)

static fromUint((object)value[, (eColor4Format)format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB]) → Color4 :

C++ signature :

PGL::Color4 fromUint(unsigned int [,PGL::Color4::eColor4Format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB])

getAverage((Color4)arg1) → float :

C++ signature :

double getAverage(PGL::Color4 {lvalue})

getAverageClamped((Color4)arg1) → float :

C++ signature :

double getAverageClamped(PGL::Color4 {lvalue})

getRGBAverage((Color4)arg1) → float :

C++ signature :

double getRGBAverage(PGL::Color4 {lvalue})

getRGBAverageClamped((Color4)arg1) → float :

C++ signature :

double getRGBAverageClamped(PGL::Color4 {lvalue})

property green

interpolate((Color4)arg1, (Color4)c[, (object)alpha=0.5]) → Color4 :

C++ signature :

PGL::Color4 interpolate(PGL::Color4,PGL::Color4 [,double=0.5])

interpolate( (Color4)c0, (object)w0=0.3333333333333333, (Color4)c1, (object)w1=0.3333333333333333, (Color4)c2 [, (object)w2=0.3333333333333333]) -> Color4 :

C++ signature :

PGL::Color4 interpolate(PGL::Color4,double=0.3333333333333333,PGL::Color4,double=0.3333333333333333,PGL::Color4 [,double=0.3333333333333333])

property red

setClampedAlpha((Color4)arg1, (object)arg2) → None :

C++ signature :

void setClampedAlpha(PGL::Color4*,double)

setClampedBlue((Color4)arg1, (object)arg2) → None :

C++ signature :

void setClampedBlue(PGL::Color4*,double)

setClampedGreen((Color4)arg1, (object)arg2) → None :

C++ signature :

void setClampedGreen(PGL::Color4*,double)

setClampedRed((Color4)arg1, (object)arg2) → None :

C++ signature :

void setClampedRed(PGL::Color4*,double)

toHSVA((Color4)arg1) → object :

C++ signature :

boost::python::api::object toHSVA(PGL::Color4*)

toHSVA8((Color4)arg1) → object :

C++ signature :

boost::python::api::object toHSVA8(PGL::Color4*)

toUint((Color4)arg1[, (eColor4Format)format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB]) → int :

C++ signature :

unsigned int toUint(PGL::Color4 {lvalue} [,PGL::Color4::eColor4Format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB])

class Color4Array

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((Color4Array)arg1) → None :

C++ signature :

void clear(PGL::Color4Array {lvalue})

empty((Color4Array)arg1) → bool :

C++ signature :

bool empty(PGL::Color4Array {lvalue})

getId((Color4Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Color4Array*)

insert((Color4Array)arg1, (object)arg2, (Color4)arg3) → None :

C++ signature :

void insert(PGL::Color4Array*,int,PGL::Color4)

static load((str)arg1) → Color4Array :

C++ signature :

PGL::RefCountPtr<PGL::Color4Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

opposite_subset((Color4Array)arg1, (object)arg2) → Color4Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Color4Array* opposite_subset(PGL::Color4Array*,boost::python::api::object)

pop((Color4Array)arg1[, (object)arg2]) → Color4 :

C++ signature :

PGL::Color4 pop(PGL::Color4Array* [,int])

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((Color4Array)arg1) → None :

C++ signature :

void reverse(PGL::Color4Array {lvalue})

save((Color4Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Color4Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((Color4Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Color4Array*,boost::python::api::object)

split_indices((Color4Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Color4Array*,boost::python::api::object)

split_subset((Color4Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Color4Array*,boost::python::api::object)

subset((Color4Array)arg1, (object)arg2) → Color4Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Color4Array* subset(PGL::Color4Array*,boost::python::api::object)

class Cone

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

DEFAULT_HEIGHT = 1.0

DEFAULT_RADIUS = 0.5

DEFAULT_SOLID = True

deepcopy((Cone)arg1) → Cone :

C++ signature :

PGL::RefCountPtr<PGL::Cone> deepcopy(PGL::Cone {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Cone> deepcopy(PGL::Cone {lvalue},PGL::DeepCopier {lvalue})

property height

isHeightToDefault((Cone)arg1) → bool :

C++ signature :

bool isHeightToDefault(PGL::Cone {lvalue})

isRadiusToDefault((Cone)arg1) → bool :

C++ signature :

bool isRadiusToDefault(PGL::Cone {lvalue})

isSolidToDefault((Cone)arg1) → bool :

C++ signature :

bool isSolidToDefault(PGL::Cone {lvalue})

property radius

recast((Cone)arg1) → Cone :

C++ signature :

PGL::RefCountPtr<PGL::Cone> recast(PGL::Cone*)

property solid

class Curve2D

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

DEFAULT_WIDTH = 1

findClosest((Curve2D)arg1, (Vector2)point) → object :

findClosest(point) : return closestpoint, u

C++ signature :

boost::python::api::object findClosest(PGL::Curve2D*,PGL::Vector2)

property firstKnot

getArcLengthToUMapping((Curve2D)arg1) → QuantisedFunction :

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

C++ signature :

PGL::RefCountPtr<PGL::QuantisedFunction> getArcLengthToUMapping(PGL::Curve2D {lvalue})

getLength((Curve2D)arg1) → float :

C++ signature :

double getLength(PGL::Curve2D {lvalue})

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

C++ signature :

double getLength(PGL::Curve2D {lvalue},double)

getLength( (Curve2D)arg1, (object)begin, (object)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((Curve2D)arg1, (object)u) → Vector2 :

C++ signature :

PGL::Vector2 getNormalAt(PGL::Curve2D const*,double)

getPointAt((Curve2D)arg1, (object)u) → Vector2 :

C++ signature :

PGL::Vector2 getPointAt(PGL::Curve2D const*,double)

getTangentAt((Curve2D)arg1, (object)u) → Vector2 :

C++ signature :

PGL::Vector2 getTangentAt(PGL::Curve2D const*,double)

getUToArcLengthMapping((Curve2D)arg1) → QuantisedFunction :

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

C++ signature :

PGL::RefCountPtr<PGL::QuantisedFunction> getUToArcLengthMapping(PGL::Curve2D {lvalue})

isWidthToDefault((Curve2D)arg1) → bool :

C++ signature :

bool isWidthToDefault(PGL::Curve2D {lvalue})

property lastKnot

property stride

property width

class Curve2DArray

append((Curve2DArray)arg1, (Curve2D)arg2) → None :

C++ signature :

void append(PGL::Curve2DArray*,PGL::RefCountPtr<PGL::Curve2D>)

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

C++ signature :

void append(PGL::Curve2DArray*,PGL::Curve2DArray*)

clear((Curve2DArray)arg1) → None :

C++ signature :

void clear(PGL::Curve2DArray {lvalue})

empty((Curve2DArray)arg1) → bool :

C++ signature :

bool empty(PGL::Curve2DArray {lvalue})

getId((Curve2DArray)arg1) → int :

C++ signature :

unsigned long getId(PGL::Curve2DArray*)

insert((Curve2DArray)arg1, (object)arg2, (Curve2D)arg3) → None :

C++ signature :

void insert(PGL::Curve2DArray*,int,PGL::RefCountPtr<PGL::Curve2D>)

opposite_subset((Curve2DArray)arg1, (object)arg2) → Curve2DArray :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Curve2DArray* opposite_subset(PGL::Curve2DArray*,boost::python::api::object)

pop((Curve2DArray)arg1[, (object)arg2]) → Curve2D :

C++ signature :

PGL::RefCountPtr<PGL::Curve2D> pop(PGL::Curve2DArray* [,int])

prepend((Curve2DArray)arg1, (Curve2D)arg2) → None :

C++ signature :

void prepend(PGL::Curve2DArray*,PGL::RefCountPtr<PGL::Curve2D>)

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

C++ signature :

void prepend(PGL::Curve2DArray*,PGL::Curve2DArray*)

reverse((Curve2DArray)arg1) → None :

C++ signature :

void reverse(PGL::Curve2DArray {lvalue})

split((Curve2DArray)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Curve2DArray*,boost::python::api::object)

split_indices((Curve2DArray)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Curve2DArray*,boost::python::api::object)

split_subset((Curve2DArray)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Curve2DArray*,boost::python::api::object)

subset((Curve2DArray)arg1, (object)arg2) → Curve2DArray :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Curve2DArray* subset(PGL::Curve2DArray*,boost::python::api::object)

class CurveArray

append((CurveArray)arg1, (LineicModel)arg2) → None :

C++ signature :

void append(PGL::CurveArray*,PGL::RefCountPtr<PGL::LineicModel>)

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

C++ signature :

void append(PGL::CurveArray*,PGL::CurveArray*)

clear((CurveArray)arg1) → None :

C++ signature :

void clear(PGL::CurveArray {lvalue})

empty((CurveArray)arg1) → bool :

C++ signature :

bool empty(PGL::CurveArray {lvalue})

getId((CurveArray)arg1) → int :

C++ signature :

unsigned long getId(PGL::CurveArray*)

insert((CurveArray)arg1, (object)arg2, (LineicModel)arg3) → None :

C++ signature :

void insert(PGL::CurveArray*,int,PGL::RefCountPtr<PGL::LineicModel>)

opposite_subset((CurveArray)arg1, (object)arg2) → CurveArray :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::CurveArray* opposite_subset(PGL::CurveArray*,boost::python::api::object)

pop((CurveArray)arg1[, (object)arg2]) → LineicModel :

C++ signature :

PGL::RefCountPtr<PGL::LineicModel> pop(PGL::CurveArray* [,int])

prepend((CurveArray)arg1, (LineicModel)arg2) → None :

C++ signature :

void prepend(PGL::CurveArray*,PGL::RefCountPtr<PGL::LineicModel>)

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

C++ signature :

void prepend(PGL::CurveArray*,PGL::CurveArray*)

reverse((CurveArray)arg1) → None :

C++ signature :

void reverse(PGL::CurveArray {lvalue})

split((CurveArray)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::CurveArray*,boost::python::api::object)

split_indices((CurveArray)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::CurveArray*,boost::python::api::object)

split_subset((CurveArray)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::CurveArray*,boost::python::api::object)

subset((CurveArray)arg1, (object)arg2) → CurveArray :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::CurveArray* subset(PGL::CurveArray*,boost::python::api::object)

class Cylinder

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

deepcopy((Cylinder)arg1) → Cylinder :

C++ signature :

PGL::RefCountPtr<PGL::Cylinder> deepcopy(PGL::Cylinder {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Cylinder> deepcopy(PGL::Cylinder {lvalue},PGL::DeepCopier {lvalue})

recast((Cylinder)arg1) → Cylinder :

C++ signature :

PGL::RefCountPtr<PGL::Cylinder> recast(PGL::Cylinder*)

class DeepCopier

Base class for recursive deep copy of a scene.

clear((DeepCopier)arg1) → None :

C++ signature :

void clear(PGL::DeepCopier {lvalue})

class Deformation

class Disc

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

DEFAULT_RADIUS = 0.5

deepcopy((Disc)arg1) → Disc :

C++ signature :

PGL::RefCountPtr<PGL::Disc> deepcopy(PGL::Disc {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Disc> deepcopy(PGL::Disc {lvalue},PGL::DeepCopier {lvalue})

isRadiusToDefault((Disc)arg1) → bool :

C++ signature :

bool isRadiusToDefault(PGL::Disc {lvalue})

property radius

recast((Disc)arg1) → Disc :

C++ signature :

PGL::RefCountPtr<PGL::Disc> recast(PGL::Disc*)

class ElevationGrid

A regular grid of elevations.

DEFAULT_X_SPACING = 1.0

DEFAULT_Y_SPACING = 1.0

deepcopy((ElevationGrid)arg1) → ElevationGrid :

C++ signature :

PGL::RefCountPtr<PGL::ElevationGrid> deepcopy(PGL::ElevationGrid {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::ElevationGrid> deepcopy(PGL::ElevationGrid {lvalue},PGL::DeepCopier {lvalue})

getHeightAt((ElevationGrid)arg1, (object)arg2, (object)arg3) → float :

C++ signature :

double getHeightAt(PGL::ElevationGrid*,unsigned int,unsigned int)

getPointAt((ElevationGrid)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getPointAt(PGL::ElevationGrid {lvalue},unsigned int,unsigned int)

getXDim((ElevationGrid)arg1) → int :

C++ signature :

unsigned int getXDim(PGL::ElevationGrid {lvalue})

getXSize((ElevationGrid)arg1) → float :

C++ signature :

double getXSize(PGL::ElevationGrid {lvalue})

getYDim((ElevationGrid)arg1) → int :

C++ signature :

unsigned int getYDim(PGL::ElevationGrid {lvalue})

getYSize((ElevationGrid)arg1) → float :

C++ signature :

double getYSize(PGL::ElevationGrid {lvalue})

property heightList

isXSpacingToDefault((ElevationGrid)arg1) → bool :

C++ signature :

bool isXSpacingToDefault(PGL::ElevationGrid {lvalue})

isYSpacingToDefault((ElevationGrid)arg1) → bool :

C++ signature :

bool isYSpacingToDefault(PGL::ElevationGrid {lvalue})

recast((ElevationGrid)arg1) → ElevationGrid :

C++ signature :

PGL::RefCountPtr<PGL::ElevationGrid> recast(PGL::ElevationGrid*)

property xspacing

property 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).

DEFAULT_AZIMUTH = 0.0

DEFAULT_ELEVATION = 0.0

DEFAULT_ROLL = 0.0

property azimuth

deepcopy((EulerRotated)arg1) → EulerRotated :

C++ signature :

PGL::RefCountPtr<PGL::EulerRotated> deepcopy(PGL::EulerRotated {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::EulerRotated> deepcopy(PGL::EulerRotated {lvalue},PGL::DeepCopier {lvalue})

property elevation

isAzimuthToDefault((EulerRotated)arg1) → bool :

C++ signature :

bool isAzimuthToDefault(PGL::EulerRotated {lvalue})

isElevationToDefault((EulerRotated)arg1) → bool :

C++ signature :

bool isElevationToDefault(PGL::EulerRotated {lvalue})

isRollToDefault((EulerRotated)arg1) → bool :

C++ signature :

bool isRollToDefault(PGL::EulerRotated {lvalue})

recast((EulerRotated)arg1) → EulerRotated :

C++ signature :

PGL::RefCountPtr<PGL::EulerRotated> recast(PGL::EulerRotated*)

property roll

class EulerRotation

class ExplicitModel

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

property colorList

isColorListToDefault((ExplicitModel)arg1) → bool :

C++ signature :

bool isColorListToDefault(PGL::ExplicitModel {lvalue})

property pointList

transform((ExplicitModel)arg1, (Transformation3D)arg2) → ExplicitModel :

C++ signature :

PGL::RefCountPtr<PGL::ExplicitModel> transform(PGL::ExplicitModel {lvalue},PGL::RefCountPtr<PGL::Transformation3D>)

class ExtrudedHull

A hull extruded by a vertical and an horizontal profiles.

DEFAULT_CCW = True

property ccw

deepcopy((ExtrudedHull)arg1) → ExtrudedHull :

C++ signature :

PGL::RefCountPtr<PGL::ExtrudedHull> deepcopy(PGL::ExtrudedHull {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::ExtrudedHull> deepcopy(PGL::ExtrudedHull {lvalue},PGL::DeepCopier {lvalue})

property horizontal

isCCWToDefault((ExtrudedHull)arg1) → bool :

C++ signature :

bool isCCWToDefault(PGL::ExtrudedHull {lvalue})

recast((ExtrudedHull)arg1) → ExtrudedHull :

C++ signature :

PGL::RefCountPtr<PGL::ExtrudedHull> recast(PGL::ExtrudedHull*)

property vertical

class Extrusion

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

DEFAULT_CCW = True

DEFAULT_INITIAL_NORMAL = Vector3(0,0,0)

DEFAULT_ORIENTATION_LIST = None

DEFAULT_SCALE_LIST = None

DEFAULT_SOLID = False

property axis

property ccw

property crossSection

deepcopy((Extrusion)arg1) → Extrusion :

C++ signature :

PGL::RefCountPtr<PGL::Extrusion> deepcopy(PGL::Extrusion {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Extrusion> deepcopy(PGL::Extrusion {lvalue},PGL::DeepCopier {lvalue})

getFrameAt((Extrusion)arg1, (object)arg2) → Matrix3 :

C++ signature :

PGL::Matrix3 getFrameAt(PGL::Extrusion {lvalue},double)

getInitialNormalValue((Extrusion)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getInitialNormalValue(PGL::Extrusion {lvalue})

getIsoUSectionAt((Extrusion)arg1, (object)arg2) → LineicModel :

C++ signature :

PGL::RefCountPtr<PGL::LineicModel> getIsoUSectionAt(PGL::Extrusion {lvalue},double)

getIsoVSectionAt((Extrusion)arg1, (object)arg2) → LineicModel :

C++ signature :

PGL::RefCountPtr<PGL::LineicModel> getIsoVSectionAt(PGL::Extrusion {lvalue},double)

getNextFrameAt((Extrusion)arg1, (object)arg2, (Matrix3)arg3, (object)arg4) → Matrix3 :

C++ signature :

PGL::Matrix3 getNextFrameAt(PGL::Extrusion {lvalue},double,PGL::Matrix3,double)

getNormalAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getNormalAt(PGL::Extrusion {lvalue},double,double)

getNormalAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getNormalAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

getPointAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getPointAt(PGL::Extrusion {lvalue},double,double)

getPointAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getPointAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

getSecondDerivativeUUAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getSecondDerivativeUUAt(PGL::Extrusion {lvalue},double,double)

getSecondDerivativeUUAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getSecondDerivativeUUAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

getSecondDerivativeUVAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getSecondDerivativeUVAt(PGL::Extrusion {lvalue},double,double)

getSecondDerivativeUVAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getSecondDerivativeUVAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

getSecondDerivativeVVAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getSecondDerivativeVVAt(PGL::Extrusion {lvalue},double,double)

getSecondDerivativeVVAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getSecondDerivativeVVAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

getUTangentAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getUTangentAt(PGL::Extrusion {lvalue},double,double)

getUTangentAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getUTangentAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

getVTangentAt((Extrusion)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 getVTangentAt(PGL::Extrusion {lvalue},double,double)

getVTangentAt( (Extrusion)arg1, (object)arg2, (object)arg3, (Matrix3)arg4) -> Vector3 :

C++ signature :

PGL::Vector3 getVTangentAt(PGL::Extrusion {lvalue},double,double,PGL::Matrix3)

property initialNormal

isCCWToDefault((Extrusion)arg1) → bool :

C++ signature :

bool isCCWToDefault(PGL::Extrusion {lvalue})

isInitialNormalToDefault((Extrusion)arg1) → bool :

C++ signature :

bool isInitialNormalToDefault(PGL::Extrusion {lvalue})

isOrientationToDefault((Extrusion)arg1) → bool :

C++ signature :

bool isOrientationToDefault(PGL::Extrusion {lvalue})

isScaleToDefault((Extrusion)arg1) → bool :

C++ signature :

bool isScaleToDefault(PGL::Extrusion {lvalue})

isSolidToDefault((Extrusion)arg1) → bool :

C++ signature :

bool isSolidToDefault(PGL::Extrusion {lvalue})

property knotList

property orientation

DEPRECATED

property orientationList

recast((Extrusion)arg1) → Extrusion :

C++ signature :

PGL::RefCountPtr<PGL::Extrusion> recast(PGL::Extrusion*)

property scale

DEPRECATED

property scaleList

property 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.

colorAt((FaceSet)arg1, (object)arg2) → Color4 :

C++ signature :

PGL::Color4 colorAt(PGL::FaceSet {lvalue},unsigned int)

colorIndexAt((FaceSet)arg1, (object)arg2) → Index :

C++ signature :

PGL::PglVector<unsigned int> colorIndexAt(PGL::FaceSet {lvalue},unsigned int)

property colorIndexList

deepcopy((FaceSet)arg1) → FaceSet :

C++ signature :

PGL::RefCountPtr<PGL::FaceSet> deepcopy(PGL::FaceSet {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::FaceSet> deepcopy(PGL::FaceSet {lvalue},PGL::DeepCopier {lvalue})

faceColorAt((FaceSet)arg1, (object)arg2, (object)arg3) → Color4 :

C++ signature :

PGL::Color4 faceColorAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)

faceNormalAt((FaceSet)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 faceNormalAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)

faceTexCoordAt((FaceSet)arg1, (object)arg2, (object)arg3) → Vector2 :

C++ signature :

PGL::Vector2 faceTexCoordAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)

indexAt((FaceSet)arg1, (object)arg2) → Index :

C++ signature :

PGL::PglVector<unsigned int> indexAt(PGL::FaceSet {lvalue},unsigned int)

property indexList

isColorIndexListToDefault((FaceSet)arg1) → bool :

C++ signature :

bool isColorIndexListToDefault(PGL::FaceSet {lvalue})

isNormalIndexListToDefault((FaceSet)arg1) → bool :

C++ signature :

bool isNormalIndexListToDefault(PGL::FaceSet {lvalue})

isTexCoordIndexListToDefault((FaceSet)arg1) → bool :

C++ signature :

bool isTexCoordIndexListToDefault(PGL::FaceSet {lvalue})

normalAt((FaceSet)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 normalAt(PGL::FaceSet {lvalue},unsigned int)

normalIndexAt((FaceSet)arg1, (object)arg2) → Index :

C++ signature :

PGL::PglVector<unsigned int> normalIndexAt(PGL::FaceSet {lvalue},unsigned int)

property normalIndexList

recast((FaceSet)arg1) → FaceSet :

C++ signature :

PGL::RefCountPtr<PGL::FaceSet> recast(PGL::FaceSet*)

texCoordAt((FaceSet)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 texCoordAt(PGL::FaceSet {lvalue},unsigned int)

texCoordIndexAt((FaceSet)arg1, (object)arg2) → Index :

C++ signature :

PGL::PglVector<unsigned int> texCoordIndexAt(PGL::FaceSet {lvalue},unsigned int)

property texCoordIndexList

class Font

Font describes how text is displayed.

DEFAULT_BOLD = False

DEFAULT_ITALIC = False

DEFAULT_SIZE = 10

property bold

deepcopy((Font)arg1) → Font :

C++ signature :

PGL::RefCountPtr<PGL::Font> deepcopy(PGL::Font {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Font> deepcopy(PGL::Font {lvalue},PGL::DeepCopier {lvalue})

property family

isBoldToDefault((Font)arg1) → bool :

C++ signature :

bool isBoldToDefault(PGL::Font {lvalue})

isItalicToDefault((Font)arg1) → bool :

C++ signature :

bool isItalicToDefault(PGL::Font {lvalue})

isSizeToDefault((Font)arg1) → bool :

C++ signature :

bool isSizeToDefault(PGL::Font {lvalue})

property italic

recast((Font)arg1) → Font :

C++ signature :

PGL::RefCountPtr<PGL::Font> recast(PGL::Font*)

property size

class Frustum

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

DEFAULT_TAPER = 0.5

deepcopy((Frustum)arg1) → Frustum :

C++ signature :

PGL::RefCountPtr<PGL::Frustum> deepcopy(PGL::Frustum {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Frustum> deepcopy(PGL::Frustum {lvalue},PGL::DeepCopier {lvalue})

isTaperToDefault((Frustum)arg1) → bool :

C++ signature :

bool isTaperToDefault(PGL::Frustum {lvalue})

recast((Frustum)arg1) → Frustum :

C++ signature :

PGL::RefCountPtr<PGL::Frustum> recast(PGL::Frustum*)

property taper

class Geometry

Abstract base class for all geometrical structure.

isACurve((Geometry)arg1) → bool :

C++ signature :

bool isACurve(PGL::Geometry {lvalue})

isASurface((Geometry)arg1) → bool :

C++ signature :

bool isASurface(PGL::Geometry {lvalue})

isAVolume((Geometry)arg1) → bool :

C++ signature :

bool isAVolume(PGL::Geometry {lvalue})

isExplicit((Geometry)arg1) → bool :

C++ signature :

bool isExplicit(PGL::Geometry {lvalue})

class GeometryArray

append((GeometryArray)arg1, (Geometry)arg2) → None :

C++ signature :

void append(PGL::GeometryArray*,PGL::RefCountPtr<PGL::Geometry>)

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

C++ signature :

void append(PGL::GeometryArray*,PGL::GeometryArray*)

clear((GeometryArray)arg1) → None :

C++ signature :

void clear(PGL::GeometryArray {lvalue})

empty((GeometryArray)arg1) → bool :

C++ signature :

bool empty(PGL::GeometryArray {lvalue})

getId((GeometryArray)arg1) → int :

C++ signature :

unsigned long getId(PGL::GeometryArray*)

insert((GeometryArray)arg1, (object)arg2, (Geometry)arg3) → None :

C++ signature :

void insert(PGL::GeometryArray*,int,PGL::RefCountPtr<PGL::Geometry>)

opposite_subset((GeometryArray)arg1, (object)arg2) → GeometryArray :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::GeometryArray* opposite_subset(PGL::GeometryArray*,boost::python::api::object)

pop((GeometryArray)arg1[, (object)arg2]) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> pop(PGL::GeometryArray* [,int])

prepend((GeometryArray)arg1, (Geometry)arg2) → None :

C++ signature :

void prepend(PGL::GeometryArray*,PGL::RefCountPtr<PGL::Geometry>)

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

C++ signature :

void prepend(PGL::GeometryArray*,PGL::GeometryArray*)

reverse((GeometryArray)arg1) → None :

C++ signature :

void reverse(PGL::GeometryArray {lvalue})

split((GeometryArray)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::GeometryArray*,boost::python::api::object)

split_indices((GeometryArray)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::GeometryArray*,boost::python::api::object)

split_subset((GeometryArray)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::GeometryArray*,boost::python::api::object)

subset((GeometryArray)arg1, (object)arg2) → GeometryArray :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::GeometryArray* subset(PGL::GeometryArray*,boost::python::api::object)

class Group

A Group of Geometry

DEFAULT_SKELETON = None

deepcopy((Group)arg1) → Group :

C++ signature :

PGL::RefCountPtr<PGL::Group> deepcopy(PGL::Group {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Group> deepcopy(PGL::Group {lvalue},PGL::DeepCopier {lvalue})

property geometryList

isSkeletonToDefault((Group)arg1) → bool :

C++ signature :

bool isSkeletonToDefault(PGL::Group {lvalue})

recast((Group)arg1) → Group :

C++ signature :

PGL::RefCountPtr<PGL::Group> recast(PGL::Group*)

property skeleton

class Hull

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

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.

DEFAULT_DEPTH = 1

deepcopy((IFS)arg1) → IFS :

C++ signature :

PGL::RefCountPtr<PGL::IFS> deepcopy(PGL::IFS {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::IFS> deepcopy(PGL::IFS {lvalue},PGL::DeepCopier {lvalue})

property depth

property geometry

getAllTransformations((IFS)arg1) → Matrix4Array :

C++ signature :

PGL::RefCountPtr<PGL::Array1<PGL::Matrix4> > getAllTransformations(PGL::IFS*)

isDepthToDefault((IFS)arg1) → bool :

C++ signature :

bool isDepthToDefault(PGL::IFS {lvalue})

recast((IFS)arg1) → IFS :

C++ signature :

PGL::RefCountPtr<PGL::IFS> recast(PGL::IFS*)

property transfoList

class Image

An image represented as a matrix of Color4.

fill((Image)arg1, (Color4)arg2) → None :

C++ signature :

void fill(PGL::Image {lvalue},PGL::Color4)

from_array((Image)arg1, (object)arg2) → bool :

C++ signature :

bool from_array(PGL::Image*,boost::python::numpy::ndarray)

getPixel3At((Image)arg1, (object)arg2, (object)arg3) → Color3 :

C++ signature :

PGL::Color3 getPixel3At(PGL::Image {lvalue},unsigned int,unsigned int)

getPixel4At((Image)arg1, (object)arg2, (object)arg3) → Color4 :

C++ signature :

PGL::Color4 getPixel4At(PGL::Image {lvalue},unsigned int,unsigned int)

getPixelAt((Image)arg1, (object)arg2, (object)arg3) → object :

C++ signature :

boost::python::api::object getPixelAt(PGL::Image*,unsigned int,unsigned int)

height((Image)arg1) → int :

C++ signature :

unsigned int height(PGL::Image {lvalue})

histogram((Image)arg1) → object :

C++ signature :

boost::python::api::object histogram(PGL::Image*)

nbChannels((Image)arg1) → int :

C++ signature :

unsigned int nbChannels(PGL::Image {lvalue})

plot()

plot self using maplotlib

read((Image)arg1, (str)arg2) → bool :

C++ signature :

bool read(PGL::Image {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

save((Image)arg1, (str)arg2) → None :

C++ signature :

void save(PGL::Image {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

setPixelAt((Image)arg1, (object)arg2, (object)arg3, (Color4)arg4) → None :

C++ signature :

void setPixelAt(PGL::Image {lvalue},unsigned int,unsigned int,PGL::Color4)

setPixelAt( (Image)arg1, (object)arg2, (object)arg3, (Color3)arg4, (object)arg5) -> None :

C++ signature :

void setPixelAt(PGL::Image {lvalue},unsigned int,unsigned int,PGL::Color3,unsigned char)

toQImage()

Convert self into a QImage

to_array((Image)arg1) → numpy.ndarray :

C++ signature :

boost::python::numpy::ndarray to_array(PGL::Image*)

to_interlaced_array((Image)arg1) → numpy.ndarray :

C++ signature :

boost::python::numpy::ndarray to_interlaced_array(PGL::Image*)

transpose((Image)arg1) → Image :

C++ signature :

PGL::RefCountPtr<PGL::Image> transpose(PGL::Image {lvalue})

width((Image)arg1) → int :

C++ signature :

unsigned int width(PGL::Image {lvalue})

class ImageTexture

The image of a textured object.

DEFAULT_MIPMAPING = True

DEFAULT_REPEATS = True

DEFAULT_REPEATT = True

property filename

isMipmapingToDefault((ImageTexture)arg1) → bool :

C++ signature :

bool isMipmapingToDefault(PGL::ImageTexture {lvalue})

isRepeatSToDefault((ImageTexture)arg1) → bool :

C++ signature :

bool isRepeatSToDefault(PGL::ImageTexture {lvalue})

isRepeatTToDefault((ImageTexture)arg1) → bool :

C++ signature :

bool isRepeatTToDefault(PGL::ImageTexture {lvalue})

property mipmaping

property repeatS

property repeatT

class Index

A set of indices

append((Index)arg1, (object)arg2) → None :

C++ signature :

void append(PGL::PglVector<unsigned int>*,unsigned int)

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

C++ signature :

void append(PGL::PglVector<unsigned int>*,PGL::PglVector<unsigned int>*)

clear((Index)arg1) → None :

C++ signature :

void clear(PGL::PglVector<unsigned int> {lvalue})

empty((Index)arg1) → bool :

C++ signature :

bool empty(PGL::PglVector<unsigned int> {lvalue})

getId((Index)arg1) → int :

C++ signature :

unsigned long getId(PGL::PglVector<unsigned int>*)

insert((Index)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insert(PGL::PglVector<unsigned int>*,int,unsigned int)

opposite_subset((Index)arg1, (object)arg2) → Index :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::PglVector<unsigned int>* opposite_subset(PGL::PglVector<unsigned int>*,boost::python::api::object)

pop((Index)arg1[, (object)arg2]) → int :

C++ signature :

unsigned int pop(PGL::PglVector<unsigned int>* [,int])

prepend((Index)arg1, (object)arg2) → None :

C++ signature :

void prepend(PGL::PglVector<unsigned int>*,unsigned int)

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

C++ signature :

void prepend(PGL::PglVector<unsigned int>*,PGL::PglVector<unsigned int>*)

reverse((Index)arg1) → None :

C++ signature :

void reverse(PGL::PglVector<unsigned int> {lvalue})

split((Index)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::PglVector<unsigned int>*,boost::python::api::object)

split_indices((Index)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::PglVector<unsigned int>*,boost::python::api::object)

split_subset((Index)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::PglVector<unsigned int>*,boost::python::api::object)

subset((Index)arg1, (object)arg2) → Index :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::PglVector<unsigned int>* subset(PGL::PglVector<unsigned int>*,boost::python::api::object)

class Index3

A set of 3 indices

class Index3Array

append((Index3Array)arg1, (Index3)arg2) → None :

C++ signature :

void append(PGL::Index3Array*,PGL::Tuple3<unsigned int>)

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

C++ signature :

void append(PGL::Index3Array*,PGL::Index3Array*)

clear((Index3Array)arg1) → None :

C++ signature :

void clear(PGL::Index3Array {lvalue})

empty((Index3Array)arg1) → bool :

C++ signature :

bool empty(PGL::Index3Array {lvalue})

getId((Index3Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Index3Array*)

insert((Index3Array)arg1, (object)arg2, (Index3)arg3) → None :

C++ signature :

void insert(PGL::Index3Array*,int,PGL::Tuple3<unsigned int>)

static load((str)arg1) → Index3Array :

C++ signature :

PGL::RefCountPtr<PGL::Index3Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

opposite_subset((Index3Array)arg1, (object)arg2) → Index3Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Index3Array* opposite_subset(PGL::Index3Array*,boost::python::api::object)

pop((Index3Array)arg1[, (object)arg2]) → Index3 :

C++ signature :

PGL::Tuple3<unsigned int> pop(PGL::Index3Array* [,int])

prepend((Index3Array)arg1, (Index3)arg2) → None :

C++ signature :

void prepend(PGL::Index3Array*,PGL::Tuple3<unsigned int>)

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

C++ signature :

void prepend(PGL::Index3Array*,PGL::Index3Array*)

reverse((Index3Array)arg1) → None :

C++ signature :

void reverse(PGL::Index3Array {lvalue})

save((Index3Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Index3Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((Index3Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Index3Array*,boost::python::api::object)

split_indices((Index3Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Index3Array*,boost::python::api::object)

split_subset((Index3Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Index3Array*,boost::python::api::object)

subset((Index3Array)arg1, (object)arg2) → Index3Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Index3Array* subset(PGL::Index3Array*,boost::python::api::object)

class Index4

A set of 4 indices

class Index4Array

append((Index4Array)arg1, (Index4)arg2) → None :

C++ signature :

void append(PGL::Index4Array*,PGL::Tuple4<unsigned int>)

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

C++ signature :

void append(PGL::Index4Array*,PGL::Index4Array*)

clear((Index4Array)arg1) → None :

C++ signature :

void clear(PGL::Index4Array {lvalue})

empty((Index4Array)arg1) → bool :

C++ signature :

bool empty(PGL::Index4Array {lvalue})

getId((Index4Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Index4Array*)

insert((Index4Array)arg1, (object)arg2, (Index4)arg3) → None :

C++ signature :

void insert(PGL::Index4Array*,int,PGL::Tuple4<unsigned int>)

static load((str)arg1) → Index4Array :

C++ signature :

PGL::RefCountPtr<PGL::Index4Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

opposite_subset((Index4Array)arg1, (object)arg2) → Index4Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Index4Array* opposite_subset(PGL::Index4Array*,boost::python::api::object)

pop((Index4Array)arg1[, (object)arg2]) → Index4 :

C++ signature :

PGL::Tuple4<unsigned int> pop(PGL::Index4Array* [,int])

prepend((Index4Array)arg1, (Index4)arg2) → None :

C++ signature :

void prepend(PGL::Index4Array*,PGL::Tuple4<unsigned int>)

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

C++ signature :

void prepend(PGL::Index4Array*,PGL::Index4Array*)

reverse((Index4Array)arg1) → None :

C++ signature :

void reverse(PGL::Index4Array {lvalue})

save((Index4Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Index4Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((Index4Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Index4Array*,boost::python::api::object)

split_indices((Index4Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Index4Array*,boost::python::api::object)

split_subset((Index4Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Index4Array*,boost::python::api::object)

subset((Index4Array)arg1, (object)arg2) → Index4Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Index4Array* subset(PGL::Index4Array*,boost::python::api::object)

triangulate((Index4Array)arg1) → Index3Array :

C++ signature :

PGL::RefCountPtr<PGL::Index3Array> triangulate(PGL::Index4Array {lvalue})

class IndexArray

append((IndexArray)arg1, (Index)arg2) → None :

C++ signature :

void append(PGL::IndexArray*,PGL::PglVector<unsigned int>)

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

C++ signature :

void append(PGL::IndexArray*,PGL::IndexArray*)

clear((IndexArray)arg1) → None :

C++ signature :

void clear(PGL::IndexArray {lvalue})

empty((IndexArray)arg1) → bool :

C++ signature :

bool empty(PGL::IndexArray {lvalue})

getId((IndexArray)arg1) → int :

C++ signature :

unsigned long getId(PGL::IndexArray*)

insert((IndexArray)arg1, (object)arg2, (Index)arg3) → None :

C++ signature :

void insert(PGL::IndexArray*,int,PGL::PglVector<unsigned int>)

static load((str)arg1) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

opposite_subset((IndexArray)arg1, (object)arg2) → IndexArray :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::IndexArray* opposite_subset(PGL::IndexArray*,boost::python::api::object)

pop((IndexArray)arg1[, (object)arg2]) → Index :

C++ signature :

PGL::PglVector<unsigned int> pop(PGL::IndexArray* [,int])

prepend((IndexArray)arg1, (Index)arg2) → None :

C++ signature :

void prepend(PGL::IndexArray*,PGL::PglVector<unsigned int>)

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

C++ signature :

void prepend(PGL::IndexArray*,PGL::IndexArray*)

reverse((IndexArray)arg1) → None :

C++ signature :

void reverse(PGL::IndexArray {lvalue})

save((IndexArray)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::IndexArray*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((IndexArray)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::IndexArray*,boost::python::api::object)

split_indices((IndexArray)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::IndexArray*,boost::python::api::object)

split_subset((IndexArray)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::IndexArray*,boost::python::api::object)

subset((IndexArray)arg1, (object)arg2) → IndexArray :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::IndexArray* subset(PGL::IndexArray*,boost::python::api::object)

triangulate((IndexArray)arg1) → Index3Array :

C++ signature :

PGL::RefCountPtr<PGL::Index3Array> triangulate(PGL::IndexArray {lvalue})

class IndexArrayPostOrderConstIterator

atEnd((IndexArrayPostOrderConstIterator)arg1) → bool :

C++ signature :

bool atEnd(PGL::PostOrderConstIterator<PGL::IndexArray, PGL::RefCountPtr<PGL::IndexArray> > {lvalue})

next((IndexArrayPostOrderConstIterator)arg1) → int :

C++ signature :

int next(PGL::PostOrderConstIterator<PGL::IndexArray, PGL::RefCountPtr<PGL::IndexArray> >*)

class IndexArrayPreOrderConstIterator

atEnd((IndexArrayPreOrderConstIterator)arg1) → bool :

C++ signature :

bool atEnd(PGL::PreOrderConstIterator<PGL::IndexArray, PGL::RefCountPtr<PGL::IndexArray> > {lvalue})

next((IndexArrayPreOrderConstIterator)arg1) → int :

C++ signature :

int next(PGL::PreOrderConstIterator<PGL::IndexArray, PGL::RefCountPtr<PGL::IndexArray> >*)

class Iterator

next((Iterator)arg1) → object :

C++ signature :

boost::python::api::object next(Array2Iter<PGL::RealArray2> {lvalue})

class LineicModel

Abstract base class for all lineic model.

DEFAULT_WIDTH = 1

findClosest((LineicModel)arg1, (Vector3)point) → object :

findClosest(point) : return closestpoint, u

C++ signature :

boost::python::api::object findClosest(PGL::LineicModel*,PGL::Vector3)

property firstKnot

getArcLengthToUMapping((LineicModel)arg1) → QuantisedFunction :

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

C++ signature :

PGL::RefCountPtr<PGL::QuantisedFunction> getArcLengthToUMapping(PGL::LineicModel {lvalue})

getLength((LineicModel)arg1) → float :

C++ signature :

double getLength(PGL::LineicModel {lvalue})

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

C++ signature :

double getLength(PGL::LineicModel {lvalue},double)

getLength( (LineicModel)arg1, (object)begin, (object)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((LineicModel)arg1, (object)u) → Vector3 :

C++ signature :

PGL::Vector3 getNormalAt(PGL::LineicModel const*,double)

getPointAt((LineicModel)arg1, (object)u) → Vector3 :

C++ signature :

PGL::Vector3 getPointAt(PGL::LineicModel const*,double)

getTangentAt((LineicModel)arg1, (object)u) → Vector3 :

C++ signature :

PGL::Vector3 getTangentAt(PGL::LineicModel const*,double)

getUToArcLengthMapping((LineicModel)arg1) → QuantisedFunction :

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

C++ signature :

PGL::RefCountPtr<PGL::QuantisedFunction> getUToArcLengthMapping(PGL::LineicModel {lvalue})

isWidthToDefault((LineicModel)arg1) → bool :

C++ signature :

bool isWidthToDefault(PGL::LineicModel {lvalue})

property lastKnot

property stride

property width

class Material

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

DEFAULT_AMBIENT = Color3(80,80,80)

DEFAULT_DIFFUSE = 2.0

DEFAULT_EMISSION = Color3(0,0,0)

DEFAULT_MATERIAL = Material(name='DEFAULT_MATERIAL',)

DEFAULT_SHININESS = 0.2

DEFAULT_SPECULAR = Color3(0,0,0)

DEFAULT_TRANSPARENCY = 0.0

property ambient

deepcopy((Material)arg1) → Material :

C++ signature :

PGL::RefCountPtr<PGL::Material> deepcopy(PGL::Material {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Material> deepcopy(PGL::Material {lvalue},PGL::DeepCopier {lvalue})

property diffuse

diffuseColor((Material)arg1) → Color3 :

C++ signature :

PGL::Color3 diffuseColor(PGL::Material {lvalue})

property emission

interpolate((Material)arg1, (Material)m[, (object)alpha=0.5]) → Material :

C++ signature :

PGL::RefCountPtr<PGL::Material> interpolate(PGL::Material*,PGL::Material* [,double=0.5])

isAmbientToDefault((Material)arg1) → bool :

C++ signature :

bool isAmbientToDefault(PGL::Material {lvalue})

isDiffuseToDefault((Material)arg1) → bool :

C++ signature :

bool isDiffuseToDefault(PGL::Material {lvalue})

isEmissionToDefault((Material)arg1) → bool :

C++ signature :

bool isEmissionToDefault(PGL::Material {lvalue})

isShininessToDefault((Material)arg1) → bool :

C++ signature :

bool isShininessToDefault(PGL::Material {lvalue})

isSimilar((Material)arg1, (Material)arg2) → bool :

C++ signature :

bool isSimilar(PGL::Material {lvalue},PGL::Material)

isSpecularToDefault((Material)arg1) → bool :

C++ signature :

bool isSpecularToDefault(PGL::Material {lvalue})

isTransparencyToDefault((Material)arg1) → bool :

C++ signature :

bool isTransparencyToDefault(PGL::Material {lvalue})

recast((Material)arg1) → Material :

C++ signature :

PGL::RefCountPtr<PGL::Material> recast(PGL::Material*)

property shininess

property specular

property transparency

class Matrix3Transformation

class Matrix4Array

append((Matrix4Array)arg1, (Matrix4)arg2) → None :

C++ signature :

void append(PGL::Array1<PGL::Matrix4>*,PGL::Matrix4)

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

C++ signature :

void append(PGL::Array1<PGL::Matrix4>*,PGL::Array1<PGL::Matrix4>*)

clear((Matrix4Array)arg1) → None :

C++ signature :

void clear(PGL::Array1<PGL::Matrix4> {lvalue})

empty((Matrix4Array)arg1) → bool :

C++ signature :

bool empty(PGL::Array1<PGL::Matrix4> {lvalue})

getId((Matrix4Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Array1<PGL::Matrix4>*)

insert((Matrix4Array)arg1, (object)arg2, (Matrix4)arg3) → None :

C++ signature :

void insert(PGL::Array1<PGL::Matrix4>*,int,PGL::Matrix4)

static load((str)arg1) → Matrix4Array :

C++ signature :

PGL::RefCountPtr<PGL::Array1<PGL::Matrix4> > load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

opposite_subset((Matrix4Array)arg1, (object)arg2) → Matrix4Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Array1<PGL::Matrix4>* opposite_subset(PGL::Array1<PGL::Matrix4>*,boost::python::api::object)

pop((Matrix4Array)arg1[, (object)arg2]) → Matrix4 :

C++ signature :

PGL::Matrix4 pop(PGL::Array1<PGL::Matrix4>* [,int])

prepend((Matrix4Array)arg1, (Matrix4)arg2) → None :

C++ signature :

void prepend(PGL::Array1<PGL::Matrix4>*,PGL::Matrix4)

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

C++ signature :

void prepend(PGL::Array1<PGL::Matrix4>*,PGL::Array1<PGL::Matrix4>*)

reverse((Matrix4Array)arg1) → None :

C++ signature :

void reverse(PGL::Array1<PGL::Matrix4> {lvalue})

save((Matrix4Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Array1<PGL::Matrix4>*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((Matrix4Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Array1<PGL::Matrix4>*,boost::python::api::object)

split_indices((Matrix4Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Array1<PGL::Matrix4>*,boost::python::api::object)

split_subset((Matrix4Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Array1<PGL::Matrix4>*,boost::python::api::object)

subset((Matrix4Array)arg1, (object)arg2) → Matrix4Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Array1<PGL::Matrix4>* subset(PGL::Array1<PGL::Matrix4>*,boost::python::api::object)

class Matrix4Transformation

getMatrix((Matrix4Transformation)arg1) → Matrix4 :

C++ signature :

PGL::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.

property geometry

class Mesh

Abstract base class for objects of type of mesh.

DEFAULT_CCW = True

DEFAULT_COLORPERVERTEX = True

DEFAULT_NORMALPERVERTEX = True

DEFAULT_SKELETON = None

DEFAULT_SOLID = False

property ccw

property colorPerVertex

computeNormalList((Mesh)arg1) → None :

C++ signature :

void computeNormalList(PGL::Mesh {lvalue})

estimateNormalPerFace((Mesh)arg1) → None :

C++ signature :

void estimateNormalPerFace(PGL::Mesh {lvalue})

estimateNormalPerVertex((Mesh)arg1) → None :

C++ signature :

void estimateNormalPerVertex(PGL::Mesh {lvalue})

faceCenter((Mesh)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 faceCenter(PGL::Mesh {lvalue},unsigned int)

faceSize((Mesh)arg1, (object)arg2) → int :

C++ signature :

unsigned int faceSize(PGL::Mesh {lvalue},unsigned int)

indexListSize((Mesh)arg1) → int :

C++ signature :

unsigned int indexListSize(PGL::Mesh {lvalue})

isCCWToDefault((Mesh)arg1) → bool :

C++ signature :

bool isCCWToDefault(PGL::Mesh {lvalue})

isColorPerVertexToDefault((Mesh)arg1) → bool :

C++ signature :

bool isColorPerVertexToDefault(PGL::Mesh {lvalue})

isNormalListToDefault((Mesh)arg1) → bool :

C++ signature :

bool isNormalListToDefault(PGL::Mesh {lvalue})

isNormalPerVertexToDefault((Mesh)arg1) → bool :

C++ signature :

bool isNormalPerVertexToDefault(PGL::Mesh {lvalue})

isSkeletonToDefault((Mesh)arg1) → bool :

C++ signature :

bool isSkeletonToDefault(PGL::Mesh {lvalue})

isSolidToDefault((Mesh)arg1) → bool :

C++ signature :

bool isSolidToDefault(PGL::Mesh {lvalue})

isTexCoordListToDefault((Mesh)arg1) → bool :

C++ signature :

bool isTexCoordListToDefault(PGL::Mesh {lvalue})

property normalList

property normalPerVertex

pointAt((Mesh)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 pointAt(PGL::Mesh {lvalue},unsigned int)

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

C++ signature :

PGL::Vector3 pointAt(PGL::Mesh {lvalue},unsigned int,unsigned int)

property skeleton

property solid

property texCoordList

class MonoSpectral

Mono spectral appearance property of an object.

deepcopy((MonoSpectral)arg1) → MonoSpectral :

C++ signature :

PGL::RefCountPtr<PGL::MonoSpectral> deepcopy(PGL::MonoSpectral {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::MonoSpectral> deepcopy(PGL::MonoSpectral {lvalue},PGL::DeepCopier {lvalue})

recast((MonoSpectral)arg1) → MonoSpectral :

C++ signature :

PGL::RefCountPtr<PGL::MonoSpectral> recast(PGL::MonoSpectral*)

property reflectance

property transmittance

class MultiSpectral

Multi spectral appearance property of an object.

deepcopy((MultiSpectral)arg1) → MultiSpectral :

C++ signature :

PGL::RefCountPtr<PGL::MultiSpectral> deepcopy(PGL::MultiSpectral {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::MultiSpectral> deepcopy(PGL::MultiSpectral {lvalue},PGL::DeepCopier {lvalue})

recast((MultiSpectral)arg1) → MultiSpectral :

C++ signature :

PGL::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.

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, degree=3)

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

DEFAULT_NURBS_DEGREE = 3

static basisFunctions((object)span, (object)u, (object)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 :

PGL::RefCountPtr<PGL::RealArray> basisFunctions(unsigned int,double,unsigned int,PGL::RefCountPtr<PGL::RealArray>)

deepcopy((NurbsCurve)arg1) → NurbsCurve :

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve> deepcopy(PGL::NurbsCurve {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve> deepcopy(PGL::NurbsCurve {lvalue},PGL::DeepCopier {lvalue})

static defaultKnotList((object)nbCtrlPoints, (object)degree) → RealArray :

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

C++ signature :

PGL::RefCountPtr<PGL::RealArray> defaultKnotList(unsigned int,unsigned int)

static defaultKnotListTest((RealArray)knots, (object)nbCtrlPoints, (object)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(PGL::RefCountPtr<PGL::RealArray>,unsigned int,unsigned int)

property degree

static derivatesBasisFunctions((object)n, (object)u, (object)span, (object)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 :

PGL::RefCountPtr<PGL::RealArray2> derivatesBasisFunctions(int,double,int,unsigned int,PGL::RefCountPtr<PGL::RealArray>)

static findSpan((object)u, (object)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,PGL::RefCountPtr<PGL::RealArray>)

static fit((Point3Array)points[, (object)degree=3[, (object)nbctrlpoints=4]]) → object :

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

C++ signature :

boost::python::api::object fit(PGL::RefCountPtr<PGL::Point3Array> [,int=3 [,int=4]])

getDerivativeAt((NurbsCurve)arg1, (object)u, (object)d) → Vector3 :

C++ signature :

PGL::Vector3 getDerivativeAt(PGL::NurbsCurve {lvalue},double,int)

getDerivativesAt((NurbsCurve)arg1, (object)u) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> getDerivativesAt(PGL::NurbsCurve {lvalue},double)

static interpol((Point3Array)points, (RealArray)parametrization[, (object)degree=3[, (object)closed=False]]) → NurbsCurve :

interpol(points [, parametrization, int degree, bool closed])

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve> interpol(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::RealArray> [,int=3 [,bool=False]])

isDegreeToDefault((NurbsCurve)arg1) → bool :

C++ signature :

bool isDegreeToDefault(PGL::NurbsCurve {lvalue})

isKnotListToDefault((NurbsCurve)arg1) → bool :

C++ signature :

bool isKnotListToDefault(PGL::NurbsCurve {lvalue})

property knotList

recast((NurbsCurve)arg1) → NurbsCurve :

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve> recast(PGL::NurbsCurve*)

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.

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((NurbsCurve2D)arg1) → NurbsCurve2D :

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve2D> deepcopy(PGL::NurbsCurve2D {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve2D> deepcopy(PGL::NurbsCurve2D {lvalue},PGL::DeepCopier {lvalue})

property degree

static fit((Point2Array)points) → object :

C++ signature :

boost::python::api::object fit(PGL::RefCountPtr<PGL::Point2Array>)

fit( (Point2Array)points, (object)degree, (object)nbctrlpoints) -> object :

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

C++ signature :

boost::python::api::object fit(PGL::RefCountPtr<PGL::Point2Array>,int,int)

fit( (Polyline2D)points) -> object :

C++ signature :

boost::python::api::object fit(PGL::Polyline2D*)

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

C++ signature :

boost::python::api::object fit(PGL::Polyline2D*,int,int)

static interpol((Point2Array)points, (RealArray)parametrization[, (object)degree=3[, (object)closed=False]]) → NurbsCurve2D :

interpol(points, parametrization [, int degree, bool closed])

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve2D> interpol(PGL::RefCountPtr<PGL::Point2Array>,PGL::RefCountPtr<PGL::RealArray> [,int=3 [,bool=False]])

isDegreeToDefault((NurbsCurve2D)arg1) → bool :

C++ signature :

bool isDegreeToDefault(PGL::NurbsCurve2D {lvalue})

isKnotListToDefault((NurbsCurve2D)arg1) → bool :

C++ signature :

bool isKnotListToDefault(PGL::NurbsCurve2D {lvalue})

property knotList

recast((NurbsCurve2D)arg1) → NurbsCurve2D :

C++ signature :

PGL::RefCountPtr<PGL::NurbsCurve2D> recast(PGL::NurbsCurve2D*)

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.

deepcopy((NurbsPatch)arg1) → NurbsPatch :

C++ signature :

PGL::RefCountPtr<PGL::NurbsPatch> deepcopy(PGL::NurbsPatch {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::NurbsPatch> deepcopy(PGL::NurbsPatch {lvalue},PGL::DeepCopier {lvalue})

deriveAt((NurbsPatch)arg1, (object)u, (object)v, (object)d, (object)uspan, (object)vspan) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> deriveAt(PGL::NurbsPatch {lvalue},double,double,int,int,int)

property firstUKnot

property firstVKnot

getDerivativeAt((NurbsPatch)arg1, (object)u, (object)v, (object)du, (object)dv) → Vector3 :

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 :

PGL::Vector3 getDerivativeAt(PGL::NurbsPatch {lvalue},double,double,int,int)

getDerivativesAt((NurbsPatch)arg1, (object)u, (object)v) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> getDerivativesAt(PGL::NurbsPatch {lvalue},double,double)

getNormalAt((NurbsPatch)arg1, (object)u, (object)v) → Vector3 :

C++ signature :

PGL::Vector3 getNormalAt(PGL::NurbsPatch {lvalue},double,double)

getUTangentAt((NurbsPatch)arg1, (object)u, (object)v) → Vector3 :

C++ signature :

PGL::Vector3 getUTangentAt(PGL::NurbsPatch {lvalue},double,double)

getVTangentAt((NurbsPatch)arg1, (object)u, (object)v) → Vector3 :

C++ signature :

PGL::Vector3 getVTangentAt(PGL::NurbsPatch {lvalue},double,double)

isUDegreeToDefault((NurbsPatch)arg1) → bool :

C++ signature :

bool isUDegreeToDefault(PGL::NurbsPatch {lvalue})

isUKnotListToDefault((NurbsPatch)arg1) → bool :

C++ signature :

bool isUKnotListToDefault(PGL::NurbsPatch {lvalue})

isVDegreeToDefault((NurbsPatch)arg1) → int :

C++ signature :

unsigned int isVDegreeToDefault(PGL::NurbsPatch {lvalue})

isVKnotListToDefault((NurbsPatch)arg1) → bool :

C++ signature :

bool isVKnotListToDefault(PGL::NurbsPatch {lvalue})

property lastUKnot

property lastVKnot

recast((NurbsPatch)arg1) → NurbsPatch :

C++ signature :

PGL::RefCountPtr<PGL::NurbsPatch> recast(PGL::NurbsPatch*)

setUKnotListToDefault((NurbsPatch)arg1) → bool :

C++ signature :

bool setUKnotListToDefault(PGL::NurbsPatch {lvalue})

setVKnotListToDefault((NurbsPatch)arg1) → bool :

C++ signature :

bool setVKnotListToDefault(PGL::NurbsPatch {lvalue})

property udegree

property uknotList

property vdegree

property 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.

DEFAULT_PRIMARY = Vector3(1,0,0)

DEFAULT_SECONDARY = Vector3(0,1,0)

deepcopy((Oriented)arg1) → Oriented :

C++ signature :

PGL::RefCountPtr<PGL::Oriented> deepcopy(PGL::Oriented {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Oriented> deepcopy(PGL::Oriented {lvalue},PGL::DeepCopier {lvalue})

isPrimaryToDefault((Oriented)arg1) → bool :

C++ signature :

bool isPrimaryToDefault(PGL::Oriented {lvalue})

isSecondaryToDefault((Oriented)arg1) → bool :

C++ signature :

bool isSecondaryToDefault(PGL::Oriented {lvalue})

property primary

recast((Oriented)arg1) → Oriented :

C++ signature :

PGL::RefCountPtr<PGL::Oriented> recast(PGL::Oriented*)

property secondary

class OrthoTransformed

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

class OrthonormalBasis3D

getMatrix((OrthonormalBasis3D)arg1) → Matrix4 :

C++ signature :

PGL::Matrix4 getMatrix(PGL::OrthonormalBasis3D {lvalue})

getMatrix3((OrthonormalBasis3D)arg1) → Matrix3 :

C++ signature :

PGL::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.

DEFAULT_SHAPE = 2.0

DEFAULT_STACKS = 8

deepcopy((Paraboloid)arg1) → Paraboloid :

C++ signature :

PGL::RefCountPtr<PGL::Paraboloid> deepcopy(PGL::Paraboloid {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Paraboloid> deepcopy(PGL::Paraboloid {lvalue},PGL::DeepCopier {lvalue})

isShapeToDefault((Paraboloid)arg1) → bool :

C++ signature :

bool isShapeToDefault(PGL::Paraboloid {lvalue})

isStacksToDefault((Paraboloid)arg1) → bool :

C++ signature :

bool isStacksToDefault(PGL::Paraboloid {lvalue})

recast((Paraboloid)arg1) → Paraboloid :

C++ signature :

PGL::RefCountPtr<PGL::Paraboloid> recast(PGL::Paraboloid*)

property shape

property stacks

class ParametricModel

Abstract base class for all parametric primitives

class Patch

Abstract base class for patches.

DEFAULT_CCW = True

property ccw

isCCWToDefault((Patch)arg1) → bool :

C++ signature :

bool isCCWToDefault(PGL::Patch {lvalue})

class PglObject

getPglId((PglObject)arg1) → int :

C++ signature :

unsigned long getPglId(PGL::RefCountObject {lvalue})

getPglReferenceCount((PglObject)arg1) → int :

C++ signature :

unsigned long getPglReferenceCount(PGL::RefCountObject {lvalue})

class PlanarModel

class Plane3

A 3D plane

property a

property b

base1((Plane3)arg1) → Vector3 :

C++ signature :

PGL::Vector3 base1(PGL::Plane3 {lvalue})

base2((Plane3)arg1) → Vector3 :

C++ signature :

PGL::Vector3 base2(PGL::Plane3 {lvalue})

property c

property d

getDistance((Plane3)arg1, (Vector3)arg2) → float :

C++ signature :

double getDistance(PGL::Plane3 {lvalue},PGL::Vector3)

property normal

class Point2Array

append((Point2Array)arg1, (Vector2)arg2) → None :

C++ signature :

void append(PGL::Point2Array*,PGL::Vector2)

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

C++ signature :

void append(PGL::Point2Array*,PGL::Point2Array*)

clear((Point2Array)arg1) → None :

C++ signature :

void clear(PGL::Point2Array {lvalue})

directional_sort((Point2Array)arg1, (Vector2)direction) → None :

Sort the points according to the given direction. This is done INPLACE.

C++ signature :

void directional_sort(PGL::Point2Array*,PGL::Vector2)

empty((Point2Array)arg1) → bool :

C++ signature :

bool empty(PGL::Point2Array {lvalue})

filterCoordinates((Point2Array)arg1, (object)i, (object)coordmin, (object)coordmax) → Point2Array :

Filter array by looking at coordinate i.

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> filterCoordinates(PGL::Point2Array*,unsigned char,double,double)

findClosest((Point2Array)arg1, (Vector2)point) → object :

Find closest point in the PointArray2 from arg

C++ signature :

boost::python::api::object findClosest(PGL::Point2Array*,PGL::Vector2)

getBounds((Point2Array)arg1) → object :

C++ signature :

boost::python::api::object getBounds(PGL::Point2Array const*)

getCenter((Point2Array)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getCenter(PGL::Point2Array {lvalue})

getExtent((Point2Array)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getExtent(PGL::Point2Array {lvalue})

getId((Point2Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Point2Array*)

getLength((Point2Array)arg1) → float :

C++ signature :

double getLength(PGL::Point2Array {lvalue})

getXMaxIndex((Point2Array)arg1) → int :

C++ signature :

int getXMaxIndex(PGL::Point2Array const*)

getXMinAndMaxIndex((Point2Array)arg1) → object :

C++ signature :

boost::python::api::object getXMinAndMaxIndex(PGL::Point2Array const*)

getXMinIndex((Point2Array)arg1) → int :

C++ signature :

int getXMinIndex(PGL::Point2Array const*)

getYMaxIndex((Point2Array)arg1) → int :

C++ signature :

int getYMaxIndex(PGL::Point2Array const*)

getYMinAndMaxIndex((Point2Array)arg1) → object :

C++ signature :

boost::python::api::object getYMinAndMaxIndex(PGL::Point2Array const*)

getYMinIndex((Point2Array)arg1) → int :

C++ signature :

int getYMinIndex(PGL::Point2Array const*)

hausdorff_distance((Point2Array)arg1, (Point2Array)arg2) → float :

C++ signature :

double hausdorff_distance(PGL::RefCountPtr<PGL::Point2Array>,PGL::RefCountPtr<PGL::Point2Array>)

insert((Point2Array)arg1, (object)arg2, (Vector2)arg3) → None :

C++ signature :

void insert(PGL::Point2Array*,int,PGL::Vector2)

isValid((Point2Array)arg1) → bool :

C++ signature :

bool isValid(PGL::Point2Array {lvalue})

static load((str)arg1) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

normalize((Point2Array)arg1) → None :

C++ signature :

void normalize(PGL::Point2Array {lvalue})

opposite_subset((Point2Array)arg1, (object)arg2) → Point2Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Point2Array* opposite_subset(PGL::Point2Array*,boost::python::api::object)

partition((Point2Array)arg1, (object)arg2) → list :

C++ signature :

boost::python::list partition(PGL::Point2Array*,boost::python::api::object)

pop((Point2Array)arg1[, (object)arg2]) → Vector2 :

C++ signature :

PGL::Vector2 pop(PGL::Point2Array* [,int])

prepend((Point2Array)arg1, (Vector2)arg2) → None :

C++ signature :

void prepend(PGL::Point2Array*,PGL::Vector2)

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

C++ signature :

void prepend(PGL::Point2Array*,PGL::Point2Array*)

reverse((Point2Array)arg1) → None :

C++ signature :

void reverse(PGL::Point2Array {lvalue})

save((Point2Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Point2Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

scale((Point2Array)arg1, (Vector2)scaling) → None :

Scale the PointArray. This is done INPLACE.

C++ signature :

void scale(PGL::Point2Array*,PGL::Vector2)

scale( (Point2Array)arg1, (object)scaling) -> None :

Scale the PointArray. This is done INPLACE.

C++ signature :

void scale(PGL::Point2Array*,double)

sliceCoordinates((Point2Array)arg1, (object)idx) → RealArray :

Construct a RealArray using one of the coordinates.

C++ signature :

PGL::RefCountPtr<PGL::RealArray> sliceCoordinates(PGL::Point2Array*,unsigned int)

sort((Point2Array)arg1, (object)arg2) → None :

C++ signature :

void sort(PGL::Point2Array*,boost::python::api::object)

sortX((Point2Array)arg1) → None :

C++ signature :

void sortX(PGL::Point2Array*)

sortY((Point2Array)arg1) → None :

C++ signature :

void sortY(PGL::Point2Array*)

split((Point2Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Point2Array*,boost::python::api::object)

split_indices((Point2Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Point2Array*,boost::python::api::object)

split_subset((Point2Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Point2Array*,boost::python::api::object)

subset((Point2Array)arg1, (object)arg2) → Point2Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Point2Array* subset(PGL::Point2Array*,boost::python::api::object)

swapCoordinates((Point2Array)arg1) → None :

Swap the two coordinates of the points. This is done INPLACE.

C++ signature :

void swapCoordinates(PGL::Point2Array*)

transform((Point2Array)arg1, (Matrix2)arg2) → None :

C++ signature :

void transform(PGL::Point2Array {lvalue},PGL::Matrix2)

translate((Point2Array)arg1, (Vector2)translation) → None :

Translate the PointArray from translation. This is done INPLACE.

C++ signature :

void translate(PGL::Point2Array*,PGL::Vector2)

class Point2Matrix

clear((Point2Matrix)arg1) → None :

C++ signature :

void clear(PGL::Point2Matrix {lvalue})

empty((Point2Matrix)arg1) → bool :

C++ signature :

bool empty(PGL::Point2Matrix {lvalue})

getColumn((Point2Matrix)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getColumn(PGL::Point2Matrix*,unsigned long)

getColumnNb((Point2Matrix)arg1) → int :

C++ signature :

unsigned long getColumnNb(PGL::Point2Matrix*)

getColumnSize((Point2Matrix)arg1) → int :

C++ signature :

unsigned long getColumnSize(PGL::Point2Matrix*)

getDiagonal((Point2Matrix)arg1) → object :

C++ signature :

boost::python::api::object getDiagonal(PGL::Point2Matrix*)

getRow((Point2Matrix)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getRow(PGL::Point2Matrix*,unsigned long)

getRowNb((Point2Matrix)arg1) → int :

C++ signature :

unsigned long getRowNb(PGL::Point2Matrix*)

getRowSize((Point2Matrix)arg1) → int :

C++ signature :

unsigned long getRowSize(PGL::Point2Matrix*)

insertColumn((Point2Matrix)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertColumn(PGL::Point2Matrix*,unsigned long,boost::python::api::object)

insertRow((Point2Matrix)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertRow(PGL::Point2Matrix*,unsigned long,boost::python::api::object)

isUnique((Point2Matrix)arg1) → bool :

C++ signature :

bool isUnique(PGL::Point2Matrix {lvalue})

static load((str)arg1) → Point2Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point2Matrix> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pushColumn((Point2Matrix)arg1, (object)arg2) → None :

C++ signature :

void pushColumn(PGL::Point2Matrix*,boost::python::api::object)

pushRow((Point2Matrix)arg1, (object)arg2) → None :

C++ signature :

void pushRow(PGL::Point2Matrix*,boost::python::api::object)

reshape((Point2Matrix)arg1, (object)nbrow, (object)nbcolumn) → None :

C++ signature :

void reshape(PGL::Point2Matrix*,unsigned long,unsigned long)

save((Point2Matrix)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Point2Matrix*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

size((Point2Matrix)arg1) → int :

C++ signature :

unsigned long size(PGL::Point2Matrix*)

sizes((Point2Matrix)arg1) → object :

C++ signature :

boost::python::api::object sizes(PGL::Point2Matrix*)

submatrix((Point2Matrix)arg1, (object)row, (object)column, (object)nbrow, (object)nbcolumn) → Point2Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point2Matrix> submatrix(PGL::Point2Matrix*,unsigned int,unsigned int,unsigned int,unsigned int)

transpose((Point2Matrix)arg1) → Point2Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point2Matrix> transpose(PGL::Point2Matrix*)

class Point3Array

append((Point3Array)arg1, (Vector3)arg2) → None :

C++ signature :

void append(PGL::Point3Array*,PGL::Vector3)

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

C++ signature :

void append(PGL::Point3Array*,PGL::Point3Array*)

clear((Point3Array)arg1) → None :

C++ signature :

void clear(PGL::Point3Array {lvalue})

directional_sort((Point3Array)arg1, (Vector3)direction) → None :

Sort the points according to the given direction. This is done INPLACE.

C++ signature :

void directional_sort(PGL::Point3Array*,PGL::Vector3)

empty((Point3Array)arg1) → bool :

C++ signature :

bool empty(PGL::Point3Array {lvalue})

filterCoordinates((Point3Array)arg1, (object)i, (object)coordmin, (object)coordmax) → Point3Array :

Filter array by looking at coordinate i.

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> filterCoordinates(PGL::Point3Array*,unsigned char,double,double)

findClosest((Point3Array)arg1, (Vector3)point) → object :

Find closest point in the PointArray3 from arg

C++ signature :

boost::python::api::object findClosest(PGL::Point3Array*,PGL::Vector3)

getBounds((Point3Array)arg1) → object :

C++ signature :

boost::python::api::object getBounds(PGL::Point3Array const*)

getCenter((Point3Array)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getCenter(PGL::Point3Array {lvalue})

getExtent((Point3Array)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getExtent(PGL::Point3Array {lvalue})

getId((Point3Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Point3Array*)

getLength((Point3Array)arg1) → float :

C++ signature :

double getLength(PGL::Point3Array {lvalue})

getXMaxIndex((Point3Array)arg1) → int :

C++ signature :

int getXMaxIndex(PGL::Point3Array const*)

getXMinAndMaxIndex((Point3Array)arg1) → object :

C++ signature :

boost::python::api::object getXMinAndMaxIndex(PGL::Point3Array const*)

getXMinIndex((Point3Array)arg1) → int :

C++ signature :

int getXMinIndex(PGL::Point3Array const*)

getYMaxIndex((Point3Array)arg1) → int :

C++ signature :

int getYMaxIndex(PGL::Point3Array const*)

getYMinAndMaxIndex((Point3Array)arg1) → object :

C++ signature :

boost::python::api::object getYMinAndMaxIndex(PGL::Point3Array const*)

getYMinIndex((Point3Array)arg1) → int :

C++ signature :

int getYMinIndex(PGL::Point3Array const*)

getZMaxIndex((Point3Array)arg1) → int :

C++ signature :

int getZMaxIndex(PGL::Point3Array const*)

getZMinAndMaxIndex((Point3Array)arg1) → object :

C++ signature :

boost::python::api::object getZMinAndMaxIndex(PGL::Point3Array const*)

getZMinIndex((Point3Array)arg1) → int :

C++ signature :

int getZMinIndex(PGL::Point3Array const*)

hausdorff_distance((Point3Array)arg1, (Point3Array)arg2) → float :

C++ signature :

double hausdorff_distance(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>)

insert((Point3Array)arg1, (object)arg2, (Vector3)arg3) → None :

C++ signature :

void insert(PGL::Point3Array*,int,PGL::Vector3)

isValid((Point3Array)arg1) → bool :

C++ signature :

bool isValid(PGL::Point3Array {lvalue})

static load((str)arg1) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

normalize((Point3Array)arg1) → None :

C++ signature :

void normalize(PGL::Point3Array {lvalue})

opposite_subset((Point3Array)arg1, (object)arg2) → Point3Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Point3Array* opposite_subset(PGL::Point3Array*,boost::python::api::object)

partition((Point3Array)arg1, (object)arg2) → list :

C++ signature :

boost::python::list partition(PGL::Point3Array*,boost::python::api::object)

pop((Point3Array)arg1[, (object)arg2]) → Vector3 :

C++ signature :

PGL::Vector3 pop(PGL::Point3Array* [,int])

prepend((Point3Array)arg1, (Vector3)arg2) → None :

C++ signature :

void prepend(PGL::Point3Array*,PGL::Vector3)

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

C++ signature :

void prepend(PGL::Point3Array*,PGL::Point3Array*)

project((Point3Array)arg1) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> project(PGL::Point3Array {lvalue})

reverse((Point3Array)arg1) → None :

C++ signature :

void reverse(PGL::Point3Array {lvalue})

save((Point3Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Point3Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

scale((Point3Array)arg1, (Vector3)scaling) → None :

Scale the PointArray. This is done INPLACE.

C++ signature :

void scale(PGL::Point3Array*,PGL::Vector3)

scale( (Point3Array)arg1, (object)scaling) -> None :

Scale the PointArray. This is done INPLACE.

C++ signature :

void scale(PGL::Point3Array*,double)

sliceCoordinates((Point3Array)arg1, (object)idx0, (object)idx1) → Point2Array :

Construct a Point2Array using 2 of the coordinates.

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> sliceCoordinates(PGL::Point3Array*,unsigned int,unsigned int)

sliceCoordinates( (Point3Array)arg1, (object)idx) -> RealArray :

Construct a RealArray using one of the coordinates.

C++ signature :

PGL::RefCountPtr<PGL::RealArray> sliceCoordinates(PGL::Point3Array*,unsigned int)

sort((Point3Array)arg1, (object)arg2) → None :

C++ signature :

void sort(PGL::Point3Array*,boost::python::api::object)

sortX((Point3Array)arg1) → None :

C++ signature :

void sortX(PGL::Point3Array*)

sortY((Point3Array)arg1) → None :

C++ signature :

void sortY(PGL::Point3Array*)

sortZ((Point3Array)arg1) → None :

C++ signature :

void sortZ(PGL::Point3Array*)

split((Point3Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Point3Array*,boost::python::api::object)

split_indices((Point3Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Point3Array*,boost::python::api::object)

split_subset((Point3Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Point3Array*,boost::python::api::object)

subset((Point3Array)arg1, (object)arg2) → Point3Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Point3Array* subset(PGL::Point3Array*,boost::python::api::object)

swapCoordinates((Point3Array)arg1, (object)i, (object)j) → None :

Swap the coordinate i with coordinate j of the points. This is done INPLACE.

C++ signature :

void swapCoordinates(PGL::Point3Array*,int,int)

transform((Point3Array)arg1, (Matrix3)arg2) → None :

C++ signature :

void transform(PGL::Point3Array {lvalue},PGL::Matrix3)

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

C++ signature :

void transform(PGL::Point3Array {lvalue},PGL::Matrix4)

translate((Point3Array)arg1, (Vector3)translation) → None :

Translate the PointArray from translation. This is done INPLACE.

C++ signature :

void translate(PGL::Point3Array*,PGL::Vector3)

class Point3Matrix

clear((Point3Matrix)arg1) → None :

C++ signature :

void clear(PGL::Point3Matrix {lvalue})

empty((Point3Matrix)arg1) → bool :

C++ signature :

bool empty(PGL::Point3Matrix {lvalue})

getColumn((Point3Matrix)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getColumn(PGL::Point3Matrix*,unsigned long)

getColumnNb((Point3Matrix)arg1) → int :

C++ signature :

unsigned long getColumnNb(PGL::Point3Matrix*)

getColumnSize((Point3Matrix)arg1) → int :

C++ signature :

unsigned long getColumnSize(PGL::Point3Matrix*)

getDiagonal((Point3Matrix)arg1) → object :

C++ signature :

boost::python::api::object getDiagonal(PGL::Point3Matrix*)

getRow((Point3Matrix)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getRow(PGL::Point3Matrix*,unsigned long)

getRowNb((Point3Matrix)arg1) → int :

C++ signature :

unsigned long getRowNb(PGL::Point3Matrix*)

getRowSize((Point3Matrix)arg1) → int :

C++ signature :

unsigned long getRowSize(PGL::Point3Matrix*)

insertColumn((Point3Matrix)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertColumn(PGL::Point3Matrix*,unsigned long,boost::python::api::object)

insertRow((Point3Matrix)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertRow(PGL::Point3Matrix*,unsigned long,boost::python::api::object)

isUnique((Point3Matrix)arg1) → bool :

C++ signature :

bool isUnique(PGL::Point3Matrix {lvalue})

static load((str)arg1) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pushColumn((Point3Matrix)arg1, (object)arg2) → None :

C++ signature :

void pushColumn(PGL::Point3Matrix*,boost::python::api::object)

pushRow((Point3Matrix)arg1, (object)arg2) → None :

C++ signature :

void pushRow(PGL::Point3Matrix*,boost::python::api::object)

reshape((Point3Matrix)arg1, (object)nbrow, (object)nbcolumn) → None :

C++ signature :

void reshape(PGL::Point3Matrix*,unsigned long,unsigned long)

save((Point3Matrix)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Point3Matrix*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

size((Point3Matrix)arg1) → int :

C++ signature :

unsigned long size(PGL::Point3Matrix*)

sizes((Point3Matrix)arg1) → object :

C++ signature :

boost::python::api::object sizes(PGL::Point3Matrix*)

submatrix((Point3Matrix)arg1, (object)row, (object)column, (object)nbrow, (object)nbcolumn) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> submatrix(PGL::Point3Matrix*,unsigned int,unsigned int,unsigned int,unsigned int)

transpose((Point3Matrix)arg1) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> transpose(PGL::Point3Matrix*)

class Point4Array

append((Point4Array)arg1, (Vector4)arg2) → None :

C++ signature :

void append(PGL::Point4Array*,PGL::Vector4)

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

C++ signature :

void append(PGL::Point4Array*,PGL::Point4Array*)

clear((Point4Array)arg1) → None :

C++ signature :

void clear(PGL::Point4Array {lvalue})

directional_sort((Point4Array)arg1, (Vector4)direction) → None :

Sort the points according to the given direction. This is done INPLACE.

C++ signature :

void directional_sort(PGL::Point4Array*,PGL::Vector4)

empty((Point4Array)arg1) → bool :

C++ signature :

bool empty(PGL::Point4Array {lvalue})

filterCoordinates((Point4Array)arg1, (object)i, (object)coordmin, (object)coordmax) → Point4Array :

Filter array by looking at coordinate i.

C++ signature :

PGL::RefCountPtr<PGL::Point4Array> filterCoordinates(PGL::Point4Array*,unsigned char,double,double)

findClosest((Point4Array)arg1, (Vector4)point) → object :

Find closest point in the PointArray4 from arg

C++ signature :

boost::python::api::object findClosest(PGL::Point4Array*,PGL::Vector4)

getBounds((Point4Array)arg1) → object :

C++ signature :

boost::python::api::object getBounds(PGL::Point4Array const*)

getCenter((Point4Array)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getCenter(PGL::Point4Array {lvalue})

getExtent((Point4Array)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getExtent(PGL::Point4Array {lvalue})

getId((Point4Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::Point4Array*)

getLength((Point4Array)arg1) → float :

C++ signature :

double getLength(PGL::Point4Array {lvalue})

getWMaxIndex((Point4Array)arg1) → int :

C++ signature :

int getWMaxIndex(PGL::Point4Array const*)

getWMinAndMaxIndex((Point4Array)arg1) → object :

C++ signature :

boost::python::api::object getWMinAndMaxIndex(PGL::Point4Array const*)

getWMinIndex((Point4Array)arg1) → int :

C++ signature :

int getWMinIndex(PGL::Point4Array const*)

getXMaxIndex((Point4Array)arg1) → int :

C++ signature :

int getXMaxIndex(PGL::Point4Array const*)

getXMinAndMaxIndex((Point4Array)arg1) → object :

C++ signature :

boost::python::api::object getXMinAndMaxIndex(PGL::Point4Array const*)

getXMinIndex((Point4Array)arg1) → int :

C++ signature :

int getXMinIndex(PGL::Point4Array const*)

getYMaxIndex((Point4Array)arg1) → int :

C++ signature :

int getYMaxIndex(PGL::Point4Array const*)

getYMinAndMaxIndex((Point4Array)arg1) → object :

C++ signature :

boost::python::api::object getYMinAndMaxIndex(PGL::Point4Array const*)

getYMinIndex((Point4Array)arg1) → int :

C++ signature :

int getYMinIndex(PGL::Point4Array const*)

getZMaxIndex((Point4Array)arg1) → int :

C++ signature :

int getZMaxIndex(PGL::Point4Array const*)

getZMinAndMaxIndex((Point4Array)arg1) → object :

C++ signature :

boost::python::api::object getZMinAndMaxIndex(PGL::Point4Array const*)

getZMinIndex((Point4Array)arg1) → int :

C++ signature :

int getZMinIndex(PGL::Point4Array const*)

hausdorff_distance((Point4Array)arg1, (Point4Array)arg2) → float :

C++ signature :

double hausdorff_distance(PGL::RefCountPtr<PGL::Point4Array>,PGL::RefCountPtr<PGL::Point4Array>)

insert((Point4Array)arg1, (object)arg2, (Vector4)arg3) → None :

C++ signature :

void insert(PGL::Point4Array*,int,PGL::Vector4)

isValid((Point4Array)arg1) → bool :

C++ signature :

bool isValid(PGL::Point4Array {lvalue})

static load((str)arg1) → Point4Array :

C++ signature :

PGL::RefCountPtr<PGL::Point4Array> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

normalize((Point4Array)arg1) → None :

C++ signature :

void normalize(PGL::Point4Array {lvalue})

opposite_subset((Point4Array)arg1, (object)arg2) → Point4Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::Point4Array* opposite_subset(PGL::Point4Array*,boost::python::api::object)

partition((Point4Array)arg1, (object)arg2) → list :

C++ signature :

boost::python::list partition(PGL::Point4Array*,boost::python::api::object)

pop((Point4Array)arg1[, (object)arg2]) → Vector4 :

C++ signature :

PGL::Vector4 pop(PGL::Point4Array* [,int])

prepend((Point4Array)arg1, (Vector4)arg2) → None :

C++ signature :

void prepend(PGL::Point4Array*,PGL::Vector4)

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

C++ signature :

void prepend(PGL::Point4Array*,PGL::Point4Array*)

project((Point4Array)arg1) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> project(PGL::Point4Array {lvalue})

reverse((Point4Array)arg1) → None :

C++ signature :

void reverse(PGL::Point4Array {lvalue})

save((Point4Array)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Point4Array*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

scale((Point4Array)arg1, (Vector4)scaling) → None :

Scale the PointArray. This is done INPLACE.

C++ signature :

void scale(PGL::Point4Array*,PGL::Vector4)

scale( (Point4Array)arg1, (object)scaling) -> None :

Scale the PointArray. This is done INPLACE.

C++ signature :

void scale(PGL::Point4Array*,double)

sliceCoordinates((Point4Array)arg1, (object)idx0, (object)idx1) → Point2Array :

Construct a Point2Array using 2 of the coordinates.

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> sliceCoordinates(PGL::Point4Array*,unsigned int,unsigned int)

sliceCoordinates( (Point4Array)arg1, (object)idx0, (object)idx1, (object)idx2) -> Point3Array :

Construct a Point3Array using 3 of the coordinates.

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> sliceCoordinates(PGL::Point4Array*,unsigned int,unsigned int,unsigned int)

sliceCoordinates( (Point4Array)arg1, (object)idx) -> RealArray :

Construct a RealArray using one of the coordinates.

C++ signature :

PGL::RefCountPtr<PGL::RealArray> sliceCoordinates(PGL::Point4Array*,unsigned int)

sort((Point4Array)arg1, (object)arg2) → None :

C++ signature :

void sort(PGL::Point4Array*,boost::python::api::object)

sortW((Point4Array)arg1) → None :

C++ signature :

void sortW(PGL::Point4Array*)

sortX((Point4Array)arg1) → None :

C++ signature :

void sortX(PGL::Point4Array*)

sortY((Point4Array)arg1) → None :

C++ signature :

void sortY(PGL::Point4Array*)

sortZ((Point4Array)arg1) → None :

C++ signature :

void sortZ(PGL::Point4Array*)

split((Point4Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::Point4Array*,boost::python::api::object)

split_indices((Point4Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::Point4Array*,boost::python::api::object)

split_subset((Point4Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::Point4Array*,boost::python::api::object)

subset((Point4Array)arg1, (object)arg2) → Point4Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::Point4Array* subset(PGL::Point4Array*,boost::python::api::object)

swapCoordinates((Point4Array)arg1, (object)i, (object)j) → None :

Swap the coordinate i with coordinate j of the points. This is done INPLACE.

C++ signature :

void swapCoordinates(PGL::Point4Array*,int,int)

transform((Point4Array)arg1, (Matrix4)arg2) → None :

C++ signature :

void transform(PGL::Point4Array {lvalue},PGL::Matrix4)

translate((Point4Array)arg1, (Vector4)translation) → None :

Translate the PointArray from translation. This is done INPLACE.

C++ signature :

void translate(PGL::Point4Array*,PGL::Vector4)

class Point4Matrix

clear((Point4Matrix)arg1) → None :

C++ signature :

void clear(PGL::Point4Matrix {lvalue})

empty((Point4Matrix)arg1) → bool :

C++ signature :

bool empty(PGL::Point4Matrix {lvalue})

getColumn((Point4Matrix)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getColumn(PGL::Point4Matrix*,unsigned long)

getColumnNb((Point4Matrix)arg1) → int :

C++ signature :

unsigned long getColumnNb(PGL::Point4Matrix*)

getColumnSize((Point4Matrix)arg1) → int :

C++ signature :

unsigned long getColumnSize(PGL::Point4Matrix*)

getDiagonal((Point4Matrix)arg1) → object :

C++ signature :

boost::python::api::object getDiagonal(PGL::Point4Matrix*)

getRow((Point4Matrix)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getRow(PGL::Point4Matrix*,unsigned long)

getRowNb((Point4Matrix)arg1) → int :

C++ signature :

unsigned long getRowNb(PGL::Point4Matrix*)

getRowSize((Point4Matrix)arg1) → int :

C++ signature :

unsigned long getRowSize(PGL::Point4Matrix*)

insertColumn((Point4Matrix)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertColumn(PGL::Point4Matrix*,unsigned long,boost::python::api::object)

insertRow((Point4Matrix)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertRow(PGL::Point4Matrix*,unsigned long,boost::python::api::object)

isUnique((Point4Matrix)arg1) → bool :

C++ signature :

bool isUnique(PGL::Point4Matrix {lvalue})

static load((str)arg1) → Point4Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point4Matrix> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pushColumn((Point4Matrix)arg1, (object)arg2) → None :

C++ signature :

void pushColumn(PGL::Point4Matrix*,boost::python::api::object)

pushRow((Point4Matrix)arg1, (object)arg2) → None :

C++ signature :

void pushRow(PGL::Point4Matrix*,boost::python::api::object)

reshape((Point4Matrix)arg1, (object)nbrow, (object)nbcolumn) → None :

C++ signature :

void reshape(PGL::Point4Matrix*,unsigned long,unsigned long)

save((Point4Matrix)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::Point4Matrix*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

size((Point4Matrix)arg1) → int :

C++ signature :

unsigned long size(PGL::Point4Matrix*)

sizes((Point4Matrix)arg1) → object :

C++ signature :

boost::python::api::object sizes(PGL::Point4Matrix*)

submatrix((Point4Matrix)arg1, (object)row, (object)column, (object)nbrow, (object)nbcolumn) → Point4Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point4Matrix> submatrix(PGL::Point4Matrix*,unsigned int,unsigned int,unsigned int,unsigned int)

transpose((Point4Matrix)arg1) → Point4Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point4Matrix> transpose(PGL::Point4Matrix*)

class PointSet

PointSet describes an explicit set of points

DEFAULT_WIDTH = 1

convertToShapes((PointSet)arg1[, (Vector3)translation=Vector3(0, 0, 0)]) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> convertToShapes(PGL::PointSet* [,PGL::Vector3=Vector3(0,0,0)])

deepcopy((PointSet)arg1) → PointSet :

C++ signature :

PGL::RefCountPtr<PGL::PointSet> deepcopy(PGL::PointSet {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::PointSet> deepcopy(PGL::PointSet {lvalue},PGL::DeepCopier {lvalue})

findClosest((PointSet)arg1, (Vector3)point) → object :

Find closest point in the PointSet from arg

C++ signature :

boost::python::api::object findClosest(PGL::PointSet*,PGL::Vector3)

isWidthToDefault((PointSet)arg1) → bool :

C++ signature :

bool isWidthToDefault(PGL::PointSet {lvalue})

recast((PointSet)arg1) → PointSet :

C++ signature :

PGL::RefCountPtr<PGL::PointSet> recast(PGL::PointSet*)

transform((PointSet)arg1, (Transformation3D)arg2) → ExplicitModel :

C++ signature :

PGL::RefCountPtr<PGL::ExplicitModel> transform(PGL::PointSet {lvalue},PGL::RefCountPtr<PGL::Transformation3D>)

property width

class PointSet2D

PointSet2D describes an explicit set of 2D points. See PointSet.

deepcopy((PointSet2D)arg1) → PointSet2D :

C++ signature :

PGL::RefCountPtr<PGL::PointSet2D> deepcopy(PGL::PointSet2D {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::PointSet2D> deepcopy(PGL::PointSet2D {lvalue},PGL::DeepCopier {lvalue})

findClosest((PointSet2D)arg1, (Vector2)point) → object :

Find closest point in the PointSet from arg

C++ signature :

boost::python::api::object findClosest(PGL::PointSet2D*,PGL::Vector2)

isWidthToDefault((PointSet2D)arg1) → bool :

C++ signature :

bool isWidthToDefault(PGL::PointSet2D {lvalue})

property pointList

recast((PointSet2D)arg1) → PointSet2D :

C++ signature :

PGL::RefCountPtr<PGL::PointSet2D> recast(PGL::PointSet2D*)

property 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.

deepcopy((Polyline)arg1) → Polyline :

C++ signature :

PGL::RefCountPtr<PGL::Polyline> deepcopy(PGL::Polyline {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Polyline> deepcopy(PGL::Polyline {lvalue},PGL::DeepCopier {lvalue})

recast((Polyline)arg1) → Polyline :

C++ signature :

PGL::RefCountPtr<PGL::Polyline> recast(PGL::Polyline*)

split((Polyline)arg1, (object)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.

static ArcOfCircle([(object)radius=0.5[, (object)starting_angle=0[, (object)angle_range=3.141592653589793[, (object)slices=8]]]]) → Polyline2D :

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> ArcOfCircle([ double=0.5 [,double=0 [,double=3.141592653589793 [,unsigned char=8]]]])

static Circle([(object)radius=0.5[, (object)slices=8]]) → Polyline2D :

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> Circle([ double=0.5 [,unsigned char=8]])

static SuperEllipsis([(object)radius=0.5[, (object)height=0.5[, (object)degree=2[, (object)starting_angle=0[, (object)angle_range=6.2831853072[, (object)slices=8]]]]]]) → Polyline2D :

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> SuperEllipsis([ double=0.5 [,double=0.5 [,double=2 [,double=0 [,double=6.2831853072 [,unsigned char=8]]]]]])

deepcopy((Polyline2D)arg1) → Polyline2D :

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> deepcopy(PGL::Polyline2D {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> deepcopy(PGL::Polyline2D {lvalue},PGL::DeepCopier {lvalue})

getNormalAt((Polyline2D)arg1, (object)u) → Vector2 :

C++ signature :

PGL::Vector2 getNormalAt(PGL::Polyline2D {lvalue},double)

getTangentAt((Polyline2D)arg1, (object)u) → Vector2 :

C++ signature :

PGL::Vector2 getTangentAt(PGL::Polyline2D {lvalue},double)

property pointList

recast((Polyline2D)arg1) → Polyline2D :

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> recast(PGL::Polyline2D*)

split((Polyline2D)arg1, (object)u) → object :

C++ signature :

boost::python::api::object split(PGL::Polyline2D*,double)

class Primitive

Abstract base class for all predefined primitives.

class ProfileInterpolation

DEFAULT_DEGREE = 3

DEFAULT_STRIDE = 0

property degree

getSectionAt((ProfileInterpolation)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getSectionAt(PGL::ProfileInterpolation*,double)

interpol((ProfileInterpolation)arg1) → bool :

C++ signature :

bool interpol(PGL::ProfileInterpolation {lvalue})

isDegreeToDefault((ProfileInterpolation)arg1) → bool :

C++ signature :

bool isDegreeToDefault(PGL::ProfileInterpolation {lvalue})

isStrideToDefault((ProfileInterpolation)arg1) → bool :

C++ signature :

bool isStrideToDefault(PGL::ProfileInterpolation {lvalue})

property knotList

property profileList

property stride

property umax

property 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.

colorAt((QuadSet)arg1, (object)arg2) → Color4 :

C++ signature :

PGL::Color4 colorAt(PGL::QuadSet {lvalue},unsigned int)

colorIndexAt((QuadSet)arg1, (object)arg2) → Index4 :

C++ signature :

PGL::Tuple4<unsigned int> colorIndexAt(PGL::QuadSet {lvalue},unsigned int)

property colorIndexList

deepcopy((QuadSet)arg1) → QuadSet :

C++ signature :

PGL::RefCountPtr<PGL::QuadSet> deepcopy(PGL::QuadSet {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::QuadSet> deepcopy(PGL::QuadSet {lvalue},PGL::DeepCopier {lvalue})

faceColorAt((QuadSet)arg1, (object)arg2, (object)arg3) → Color4 :

C++ signature :

PGL::Color4 faceColorAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)

faceNormalAt((QuadSet)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 faceNormalAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)

faceTexCoordAt((QuadSet)arg1, (object)arg2, (object)arg3) → Vector2 :

C++ signature :

PGL::Vector2 faceTexCoordAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)

indexAt((QuadSet)arg1, (object)arg2) → Index4 :

C++ signature :

PGL::Tuple4<unsigned int> indexAt(PGL::QuadSet {lvalue},unsigned int)

property indexList

isColorIndexListToDefault((QuadSet)arg1) → bool :

C++ signature :

bool isColorIndexListToDefault(PGL::QuadSet {lvalue})

isNormalIndexListToDefault((QuadSet)arg1) → bool :

C++ signature :

bool isNormalIndexListToDefault(PGL::QuadSet {lvalue})

isTexCoordIndexListToDefault((QuadSet)arg1) → bool :

C++ signature :

bool isTexCoordIndexListToDefault(PGL::QuadSet {lvalue})

normalAt((QuadSet)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 normalAt(PGL::QuadSet {lvalue},unsigned int)

normalIndexAt((QuadSet)arg1, (object)arg2) → Index4 :

C++ signature :

PGL::Tuple4<unsigned int> normalIndexAt(PGL::QuadSet {lvalue},unsigned int)

property normalIndexList

recast((QuadSet)arg1) → QuadSet :

C++ signature :

PGL::RefCountPtr<PGL::QuadSet> recast(PGL::QuadSet*)

texCoordAt((QuadSet)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 texCoordAt(PGL::QuadSet {lvalue},unsigned int)

texCoordIndexAt((QuadSet)arg1, (object)arg2) → Index4 :

C++ signature :

PGL::Tuple4<unsigned int> texCoordIndexAt(PGL::QuadSet {lvalue},unsigned int)

property texCoordIndexList

class QuantisedFunction

A 2D quantised injective function (homomorphism) defined on the range [firstx,lastx].

DEFAULT_CLAMPED = True

DEFAULT_SAMPLING = 100

build((QuantisedFunction)arg1, (Curve2D)curve, (object)sampling) → bool :

C++ signature :

bool build(PGL::QuantisedFunction {lvalue},PGL::RefCountPtr<PGL::Curve2D>,unsigned int)

build( (QuantisedFunction)arg1, (Curve2D)arg2) -> bool :

C++ signature :

bool build(PGL::QuantisedFunction {lvalue},PGL::RefCountPtr<PGL::Curve2D>)

static checkQuantisableFunction((Curve2D)arg1) → bool :

C++ signature :

bool checkQuantisableFunction(PGL::RefCountPtr<PGL::Curve2D>)

property clamped

findX((QuantisedFunction)arg1, (object)y) → object :

C++ signature :

boost::python::api::object findX(PGL::QuantisedFunction*,double)

findX( (QuantisedFunction)arg1, (object)y, (object)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)

property firstx

getValue((QuantisedFunction)arg1, (object)x) → float :

C++ signature :

double getValue(PGL::QuantisedFunction*,double)

inverse((QuantisedFunction)arg1) → QuantisedFunction :

C++ signature :

PGL::RefCountPtr<PGL::QuantisedFunction> inverse(PGL::QuantisedFunction {lvalue})

isClampedToDefault((QuantisedFunction)arg1) → bool :

C++ signature :

bool isClampedToDefault(PGL::QuantisedFunction {lvalue})

isDecreasing((QuantisedFunction)arg1[, (object)arg2]) → bool :

C++ signature :

bool isDecreasing(PGL::QuantisedFunction {lvalue} [,bool])

isIncreasing((QuantisedFunction)arg1[, (object)arg2]) → bool :

C++ signature :

bool isIncreasing(PGL::QuantisedFunction {lvalue} [,bool])

isMonotonous((QuantisedFunction)arg1[, (object)arg2]) → bool :

C++ signature :

bool isMonotonous(PGL::QuantisedFunction {lvalue} [,bool])

isValid((QuantisedFunction)arg1) → bool :

C++ signature :

bool isValid(PGL::QuantisedFunction {lvalue})

property lastx

property sampling

class RealArray

append((RealArray)arg1, (object)arg2) → None :

C++ signature :

void append(PGL::RealArray*,double)

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

C++ signature :

void append(PGL::RealArray*,PGL::RealArray*)

clear((RealArray)arg1) → None :

C++ signature :

void clear(PGL::RealArray {lvalue})

cut((RealArray)arg1, (RealArray)bins[, (object)filteremptygroups=True]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> cut(PGL::RealArray*,PGL::RefCountPtr<PGL::RealArray> [,bool=True])

empty((RealArray)arg1) → bool :

C++ signature :

bool empty(PGL::RealArray {lvalue})

exp((RealArray)arg1) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> exp(PGL::RealArray {lvalue})

getId((RealArray)arg1) → int :

C++ signature :

unsigned long getId(PGL::RealArray*)

getMax((RealArray)arg1) → float :

C++ signature :

double getMax(PGL::RealArray*)

getMaxIndex((RealArray)arg1) → int :

C++ signature :

unsigned long getMaxIndex(PGL::RealArray*)

getMean((RealArray)arg1) → float :

C++ signature :

double getMean(PGL::RealArray {lvalue})

getMin((RealArray)arg1) → float :

C++ signature :

double getMin(PGL::RealArray*)

getMinAndMax((RealArray)arg1[, (object)filterinf=False]) → object :

C++ signature :

boost::python::api::object getMinAndMax(PGL::RealArray* [,bool=False])

getMinAndMaxIndex((RealArray)arg1[, (object)filterinf=False]) → object :

C++ signature :

boost::python::api::object getMinAndMaxIndex(PGL::RealArray* [,bool=False])

getMinIndex((RealArray)arg1) → int :

C++ signature :

unsigned long getMinIndex(PGL::RealArray*)

getSum((RealArray)arg1) → float :

C++ signature :

double getSum(PGL::RealArray {lvalue})

insert((RealArray)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insert(PGL::RealArray*,int,double)

isValid((RealArray)arg1) → bool :

C++ signature :

bool isValid(PGL::RealArray*)

static load((str)arg1) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

log((RealArray)arg1) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> log(PGL::RealArray {lvalue})

log( (RealArray)arg1, (object)base) -> RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> log(PGL::RealArray {lvalue},double)

opposite_subset((RealArray)arg1, (object)arg2) → RealArray :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::RealArray* opposite_subset(PGL::RealArray*,boost::python::api::object)

pop((RealArray)arg1[, (object)arg2]) → float :

C++ signature :

double pop(PGL::RealArray* [,int])

pow((RealArray)arg1, (object)exponent) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> pow(PGL::RealArray {lvalue},double)

prepend((RealArray)arg1, (object)arg2) → None :

C++ signature :

void prepend(PGL::RealArray*,double)

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

C++ signature :

void prepend(PGL::RealArray*,PGL::RealArray*)

reverse((RealArray)arg1) → None :

C++ signature :

void reverse(PGL::RealArray {lvalue})

save((RealArray)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::RealArray*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

split((RealArray)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::RealArray*,boost::python::api::object)

split_indices((RealArray)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::RealArray*,boost::python::api::object)

split_subset((RealArray)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::RealArray*,boost::python::api::object)

sqrt((RealArray)arg1) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> sqrt(PGL::RealArray {lvalue})

subset((RealArray)arg1, (object)arg2) → RealArray :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::RealArray* subset(PGL::RealArray*,boost::python::api::object)

class RealArray2

clear((RealArray2)arg1) → None :

C++ signature :

void clear(PGL::RealArray2 {lvalue})

empty((RealArray2)arg1) → bool :

C++ signature :

bool empty(PGL::RealArray2 {lvalue})

getColumn((RealArray2)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getColumn(PGL::RealArray2*,unsigned long)

getColumnNb((RealArray2)arg1) → int :

C++ signature :

unsigned long getColumnNb(PGL::RealArray2*)

getColumnSize((RealArray2)arg1) → int :

C++ signature :

unsigned long getColumnSize(PGL::RealArray2*)

getDiagonal((RealArray2)arg1) → object :

C++ signature :

boost::python::api::object getDiagonal(PGL::RealArray2*)

getRow((RealArray2)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getRow(PGL::RealArray2*,unsigned long)

getRowNb((RealArray2)arg1) → int :

C++ signature :

unsigned long getRowNb(PGL::RealArray2*)

getRowSize((RealArray2)arg1) → int :

C++ signature :

unsigned long getRowSize(PGL::RealArray2*)

insertColumn((RealArray2)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertColumn(PGL::RealArray2*,unsigned long,boost::python::api::object)

insertRow((RealArray2)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insertRow(PGL::RealArray2*,unsigned long,boost::python::api::object)

inverse((RealArray2)arg1) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> inverse(PGL::RealArray2*)

isUnique((RealArray2)arg1) → bool :

C++ signature :

bool isUnique(PGL::RealArray2 {lvalue})

static load((str)arg1) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pushColumn((RealArray2)arg1, (object)arg2) → None :

C++ signature :

void pushColumn(PGL::RealArray2*,boost::python::api::object)

pushRow((RealArray2)arg1, (object)arg2) → None :

C++ signature :

void pushRow(PGL::RealArray2*,boost::python::api::object)

reshape((RealArray2)arg1, (object)nbrow, (object)nbcolumn) → None :

C++ signature :

void reshape(PGL::RealArray2*,unsigned long,unsigned long)

save((RealArray2)arg1, (str)arg2) → bool :

C++ signature :

bool save(PGL::RealArray2*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

size((RealArray2)arg1) → int :

C++ signature :

unsigned long size(PGL::RealArray2*)

sizes((RealArray2)arg1) → object :

C++ signature :

boost::python::api::object sizes(PGL::RealArray2*)

submatrix((RealArray2)arg1, (object)row, (object)column, (object)nbrow, (object)nbcolumn) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> submatrix(PGL::RealArray2*,unsigned int,unsigned int,unsigned int,unsigned int)

svd((RealArray2)arg1) → object :

C++ signature :

boost::python::api::object svd(PGL::RealArray2*)

threshold_max_values((RealArray2)arg1, (object)arg2) → None :

C++ signature :

void threshold_max_values(PGL::RealArray2*,double)

threshold_min_values((RealArray2)arg1, (object)arg2) → None :

C++ signature :

void threshold_min_values(PGL::RealArray2*,double)

to_array((RealArray2)arg1) → numpy.ndarray :

C++ signature :

boost::python::numpy::ndarray to_array(PGL::RealArray2*)

transpose((RealArray2)arg1) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> transpose(PGL::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.

deepcopy((Revolution)arg1) → Revolution :

C++ signature :

PGL::RefCountPtr<PGL::Revolution> deepcopy(PGL::Revolution {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Revolution> deepcopy(PGL::Revolution {lvalue},PGL::DeepCopier {lvalue})

property profile

recast((Revolution)arg1) → Revolution :

C++ signature :

PGL::RefCountPtr<PGL::Revolution> recast(PGL::Revolution*)

class SOR

Abstract base class for 3D objects of type of surface of revolution.

DEFAULT_SLICES = 8

isSlicesToDefault((SOR)arg1) → bool :

C++ signature :

bool isSlicesToDefault(PGL::SOR {lvalue})

property slices

class SOR2D

Abstract base class for 2D objects of type of surface of revolution.

isSlicesToDefault((SOR2D)arg1) → bool :

C++ signature :

bool isSlicesToDefault(PGL::SOR2D {lvalue})

property 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.

DEFAULT_SCALE = Vector3(1,1,1)

deepcopy((Scaled)arg1) → Scaled :

C++ signature :

PGL::RefCountPtr<PGL::Scaled> deepcopy(PGL::Scaled {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Scaled> deepcopy(PGL::Scaled {lvalue},PGL::DeepCopier {lvalue})

isScaleToDefault((Scaled)arg1) → bool :

C++ signature :

bool isScaleToDefault(PGL::Scaled {lvalue})

recast((Scaled)arg1) → Scaled :

C++ signature :

PGL::RefCountPtr<PGL::Scaled> recast(PGL::Scaled*)

property scale

class Scaling

class Scene

A 3D Scene defined as a list of objects of type of Shape.

class Pool

The scene pool. Allow you to access all scene in memory using their id.

get((Pool)arg1, (object)arg2) → Scene :

get scene from id.

C++ signature :

PGL::RefCountPtr<PGL::Scene> get(PGL::Scene::Pool {lvalue},unsigned long)

getScenes((Pool)arg1) → object :

get all scene.

C++ signature :

boost::python::api::object getScenes(PGL::Scene::Pool*)

add((Scene)arg1, (Shape)arg2) → None :

C++ signature :

void add(PGL::Scene {lvalue},PGL::RefCountPtr<PGL::Shape>)

add( (Scene)arg1, (Shape3D)arg2) -> None :

C++ signature :

void add(PGL::Scene {lvalue},PGL::RefCountPtr<PGL::Shape3D>)

add( (Scene)arg1, (Geometry)arg2) -> None :

C++ signature :

void add(PGL::Scene*,PGL::RefCountPtr<PGL::Geometry>)

add( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :

void add(PGL::Scene {lvalue},PGL::RefCountPtr<PGL::Scene>)

apply((Scene)arg1, (Action)arg2) → bool :

C++ signature :

bool apply(PGL::Scene {lvalue},PGL::Action {lvalue})

applyAppearanceFirst((Scene)arg1, (Action)arg2) → bool :

C++ signature :

bool applyAppearanceFirst(PGL::Scene {lvalue},PGL::Action {lvalue})

applyAppearanceOnly((Scene)arg1, (Action)arg2) → bool :

C++ signature :

bool applyAppearanceOnly(PGL::Scene {lvalue},PGL::Action {lvalue})

applyGeometryFirst((Scene)arg1, (Action)arg2) → bool :

C++ signature :

bool applyGeometryFirst(PGL::Scene {lvalue},PGL::Action {lvalue})

applyGeometryOnly((Scene)arg1, (Action)arg2) → bool :

C++ signature :

bool applyGeometryOnly(PGL::Scene {lvalue},PGL::Action {lvalue})

clear((Scene)arg1) → None :

C++ signature :

void clear(PGL::Scene {lvalue})

deepcopy((Scene)arg1) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> deepcopy(PGL::Scene {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Scene> deepcopy(PGL::Scene {lvalue},PGL::DeepCopier {lvalue})

find((Scene)arg1, (object)arg2) → Shape :

C++ signature :

PGL::RefCountPtr<PGL::Shape> find(PGL::Scene*,unsigned long)

findSceneObject((Scene)arg1, (object)arg2) → Shape3D :

C++ signature :

PGL::RefCountPtr<PGL::Shape3D> findSceneObject(PGL::Scene*,unsigned long)

getId((Scene)arg1) → int :

C++ signature :

unsigned long getId(PGL::Scene {lvalue})

getPglReferenceCount((Scene)arg1) → int :

C++ signature :

unsigned long getPglReferenceCount(PGL::Scene {lvalue})

index((Scene)arg1, (Shape3D)arg2) → int :

C++ signature :

unsigned int index(PGL::Scene*,PGL::RefCountPtr<PGL::Shape3D>)

isValid((Scene)arg1) → bool :

C++ signature :

bool isValid(PGL::Scene {lvalue})

merge((Scene)arg1, (Scene)arg2) → None :

C++ signature :

void merge(PGL::Scene {lvalue},PGL::RefCountPtr<PGL::Scene>)

merge( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :

void merge(PGL::Scene {lvalue},PGL::RefCountPtr<PGL::Scene>)

static pool() → Pool :

Scene pool singleton access

C++ signature :

PGL::Scene::Pool {lvalue} pool()

read((Scene)arg1, (str)arg2) → None :

C++ signature :

void read(PGL::Scene*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

read( (Scene)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :

void read(PGL::Scene*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

remove((Scene)arg1, (Shape3D)arg2) → None :

C++ signature :

void remove(PGL::Scene*,PGL::RefCountPtr<PGL::Shape3D>)

save((Scene)arg1, (str)arg2) → None :

C++ signature :

void save(PGL::Scene*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

save( (Scene)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :

void save(PGL::Scene*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

sort((Scene)arg1) → None :

C++ signature :

void sort(PGL::Scene {lvalue})

todict((Scene)arg1) → dict :

C++ signature :

boost::python::dict todict(PGL::Scene*)

class SceneCodec

Coder/Decoder of a scene description.

class Mode

Enum representing coding and decoding capabilities of a codec.

No = openalea.plantgl.scenegraph._pglsg.Mode.No

Read = openalea.plantgl.scenegraph._pglsg.Mode.Read

ReadWrite = openalea.plantgl.scenegraph._pglsg.Mode.ReadWrite

Write = openalea.plantgl.scenegraph._pglsg.Mode.Write

names = {'No': openalea.plantgl.scenegraph._pglsg.Mode.No, 'Read': openalea.plantgl.scenegraph._pglsg.Mode.Read, 'ReadWrite': openalea.plantgl.scenegraph._pglsg.Mode.ReadWrite, 'Write': openalea.plantgl.scenegraph._pglsg.Mode.Write}

values = {0: openalea.plantgl.scenegraph._pglsg.Mode.No, 1: openalea.plantgl.scenegraph._pglsg.Mode.Read, 2: openalea.plantgl.scenegraph._pglsg.Mode.Write, 3: openalea.plantgl.scenegraph._pglsg.Mode.ReadWrite}

No = openalea.plantgl.scenegraph._pglsg.Mode.No

Read = openalea.plantgl.scenegraph._pglsg.Mode.Read

ReadWrite = openalea.plantgl.scenegraph._pglsg.Mode.ReadWrite

Write = openalea.plantgl.scenegraph._pglsg.Mode.Write

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(PGL::RefCountPtr<PySceneCodec> {lvalue})

property mode

property name

read((SceneCodec)arg1, (str)arg2) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> read(PGL::SceneCodec {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

read( (SceneCodec)arg1, (str)arg2) -> Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> read(PySceneCodec {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

test((SceneCodec)arg1, (str)arg2, (Mode)arg3) → bool :

C++ signature :

bool test(PGL::SceneCodec {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::SceneCodec::Mode)

test( (SceneCodec)arg1, (str)arg2, (Mode)arg3) -> bool :

C++ signature :

bool test(PySceneCodec {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::SceneCodec::Mode)

write((SceneCodec)arg1, (str)arg2, (Scene)arg3) → bool :

C++ signature :

bool write(PGL::SceneCodec {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::RefCountPtr<PGL::Scene>)

write( (SceneCodec)arg1, (str)arg2, (Scene)arg3) -> bool :

C++ signature :

bool write(PySceneCodec {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::RefCountPtr<PGL::Scene>)

class SceneFactory

A factory of Scene that register and use SceneCodec to read scene from files.

codecs((SceneFactory)arg1) → list :

C++ signature :

boost::python::list codecs(PGL::SceneFactory*)

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*)

static get() → SceneFactory :

C++ signature :

PGL::SceneFactory {lvalue} get()

isReadable((SceneFactory)arg1, (str)arg2) → bool :

C++ signature :

bool isReadable(PGL::SceneFactory {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isWritable((SceneFactory)arg1, (str)arg2) → bool :

C++ signature :

bool isWritable(PGL::SceneFactory {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

read((SceneFactory)arg1, (str)arg2) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> read(PGL::SceneFactory {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

read( (SceneFactory)arg1, (str)arg2, (str)arg3) -> Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> read(PGL::SceneFactory {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

registerCodec((SceneFactory)arg1, (SceneCodec)arg2) → None :

C++ signature :

void registerCodec(PGL::SceneFactory {lvalue},PGL::RefCountPtr<PGL::SceneCodec>)

unregisterCodec((SceneFactory)arg1, (SceneCodec)arg2) → None :

C++ signature :

void unregisterCodec(PGL::SceneFactory {lvalue},PGL::RefCountPtr<PGL::SceneCodec>)

write((SceneFactory)arg1, (str)arg2, (Scene)arg3) → bool :

C++ signature :

bool write(PGL::SceneFactory {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::RefCountPtr<PGL::Scene>)

write( (SceneFactory)arg1, (str)arg2, (Scene)arg3, (str)arg4) -> bool :

C++ signature :

bool write(PGL::SceneFactory {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::RefCountPtr<PGL::Scene>,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class SceneFormat

A scene description format.

property comment

property name

property suffixes

class SceneFormatList

A list of scene description format.

append((SceneFormatList)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)

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.

apply((SceneObject)arg1, (Action)arg2) → bool :

C++ signature :

bool apply(PGL::SceneObject {lvalue},PGL::Action {lvalue})

getName((SceneObject)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > getName(PGL::SceneObject {lvalue})

getObjectId((SceneObject)arg1) → int :

C++ signature :

unsigned long getObjectId(PGL::SceneObject {lvalue})

isNamed((SceneObject)arg1) → bool :

C++ signature :

bool isNamed(PGL::SceneObject {lvalue})

isValid((SceneObject)arg1) → bool :

C++ signature :

bool isValid(PGL::SceneObject {lvalue})

property name

setName((SceneObject)arg1, (str)arg2) → None :

C++ signature :

void setName(PGL::SceneObject {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class ScreenProjected

The ScreenProjected describes an object that is defined in the camera coordinates system.

deepcopy((ScreenProjected)arg1) → ScreenProjected :

C++ signature :

PGL::RefCountPtr<PGL::ScreenProjected> deepcopy(PGL::ScreenProjected {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::ScreenProjected> deepcopy(PGL::ScreenProjected {lvalue},PGL::DeepCopier {lvalue})

property geometry

property keepAspectRatio

recast((ScreenProjected)arg1) → ScreenProjected :

C++ signature :

PGL::RefCountPtr<PGL::ScreenProjected> recast(PGL::ScreenProjected*)

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.

NOID = 4294967295

property appearance

deepcopy((Shape)arg1) → Shape :

C++ signature :

PGL::RefCountPtr<PGL::Shape> deepcopy(PGL::Shape {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Shape> deepcopy(PGL::Shape {lvalue},PGL::DeepCopier {lvalue})

property geometry

property id

property parentId

recast((Shape)arg1) → Shape :

C++ signature :

PGL::RefCountPtr<PGL::Shape> recast(PGL::Shape*)

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.

class Spectrum

Abstract base class for all spectrum objects.

class Sphere

DEFAULT_RADIUS = 0.5

DEFAULT_STACKS = 8

deepcopy((Sphere)arg1) → Sphere :

C++ signature :

PGL::RefCountPtr<PGL::Sphere> deepcopy(PGL::Sphere {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Sphere> deepcopy(PGL::Sphere {lvalue},PGL::DeepCopier {lvalue})

isRadiusToDefault((Sphere)arg1) → bool :

C++ signature :

bool isRadiusToDefault(PGL::Sphere {lvalue})

isStacksToDefault((Sphere)arg1) → bool :

C++ signature :

bool isStacksToDefault(PGL::Sphere {lvalue})

property radius

recast((Sphere)arg1) → Sphere :

C++ signature :

PGL::RefCountPtr<PGL::Sphere> recast(PGL::Sphere*)

property stacks

class Swung

A surface defined by the revolution and interpolation of several 2D profiles along Z axis.

DEFAULT_CCW = True

DEFAULT_DEGREE = 3

DEFAULT_STRIDE = 0

property angleList

property ccw

deepcopy((Swung)arg1) → Swung :

C++ signature :

PGL::RefCountPtr<PGL::Swung> deepcopy(PGL::Swung {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Swung> deepcopy(PGL::Swung {lvalue},PGL::DeepCopier {lvalue})

property degree

property interpolator

isCCWToDefault((Swung)arg1) → bool :

C++ signature :

bool isCCWToDefault(PGL::Swung {lvalue})

isDegreeToDefault((Swung)arg1) → bool :

C++ signature :

bool isDegreeToDefault(PGL::Swung {lvalue})

isStrideToDefault((Swung)arg1) → bool :

C++ signature :

bool isStrideToDefault(PGL::Swung {lvalue})

property profileList

recast((Swung)arg1) → Swung :

C++ signature :

PGL::RefCountPtr<PGL::Swung> recast(PGL::Swung*)

property stride

class Taper

getBaseRadius((Taper)arg1) → float :

C++ signature :

double getBaseRadius(PGL::Taper {lvalue})

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.

DEFAULT_BASE_RADIUS = 0.5

DEFAULT_TOP_RADIUS = 0.5

property baseRadius

deepcopy((Tapered)arg1) → Tapered :

C++ signature :

PGL::RefCountPtr<PGL::Tapered> deepcopy(PGL::Tapered {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Tapered> deepcopy(PGL::Tapered {lvalue},PGL::DeepCopier {lvalue})

isBaseRadiusToDefault((Tapered)arg1) → bool :

C++ signature :

bool isBaseRadiusToDefault(PGL::Tapered {lvalue})

isTopRadiusToDefault((Tapered)arg1) → bool :

C++ signature :

bool isTopRadiusToDefault(PGL::Tapered {lvalue})

property primitive

recast((Tapered)arg1) → Tapered :

C++ signature :

PGL::RefCountPtr<PGL::Tapered> recast(PGL::Tapered*)

property topRadius

class Text

Text with font. It support display in screen or world coordinates.

DEFAULT_FONT = None

DEFAULT_POSITION = Vector3(0,0,0)

DEFAULT_SCREEN_COORDINATES = False

deepcopy((Text)arg1) → Text :

C++ signature :

PGL::RefCountPtr<PGL::Text> deepcopy(PGL::Text {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Text> deepcopy(PGL::Text {lvalue},PGL::DeepCopier {lvalue})

property fontstyle

isFontStyleToDefault((Text)arg1) → bool :

C++ signature :

bool isFontStyleToDefault(PGL::Text {lvalue})

isPositionToDefault((Text)arg1) → bool :

C++ signature :

bool isPositionToDefault(PGL::Text {lvalue})

isScreenCoordinatesToDefault((Text)arg1) → bool :

C++ signature :

bool isScreenCoordinatesToDefault(PGL::Text {lvalue})

property position

recast((Text)arg1) → Text :

C++ signature :

PGL::RefCountPtr<PGL::Text> recast(PGL::Text*)

property screencoordinates

property string

class Texture2D

The material of a textured object.

DEFAULT_BASECOLOR = Color4(255,255,255,0)

DEFAULT_TRANSFORMATION = None

property baseColor

property image

isBaseColorToDefault((Texture2D)arg1) → bool :

C++ signature :

bool isBaseColorToDefault(PGL::Texture2D {lvalue})

isTransformationToDefault((Texture2D)arg1) → bool :

C++ signature :

bool isTransformationToDefault(PGL::Texture2D {lvalue})

property transformation

class Texture2DTransformation

The transformation of a texture 2D.

DEFAULT_ROTATIONANGLE = 0.0

DEFAULT_ROTATIONCENTER = Vector2(0.5,0.5)

DEFAULT_SCALE = Vector2(1,1)

DEFAULT_TRANSLATION = Vector2(0,0)

isRotationAngleToDefault((Texture2DTransformation)arg1) → bool :

C++ signature :

bool isRotationAngleToDefault(PGL::Texture2DTransformation {lvalue})

isRotationCenterToDefault((Texture2DTransformation)arg1) → bool :

C++ signature :

bool isRotationCenterToDefault(PGL::Texture2DTransformation {lvalue})

isScaleToDefault((Texture2DTransformation)arg1) → bool :

C++ signature :

bool isScaleToDefault(PGL::Texture2DTransformation {lvalue})

isTranslationToDefault((Texture2DTransformation)arg1) → bool :

C++ signature :

bool isTranslationToDefault(PGL::Texture2DTransformation {lvalue})

property rotationAngle

property rotationCenter

property scale

transform((Texture2DTransformation)arg1, (Point3Array)points3) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> transform(PGL::Texture2DTransformation {lvalue},PGL::RefCountPtr<PGL::Point3Array>)

transform( (Texture2DTransformation)arg1, (Point2Array)points2) -> Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> transform(PGL::Texture2DTransformation {lvalue},PGL::RefCountPtr<PGL::Point2Array>)

transform( (Texture2DTransformation)arg1, (Vector2)point) -> Vector2 :

C++ signature :

PGL::Vector2 transform(PGL::Texture2DTransformation {lvalue},PGL::Vector2)

property translation

class Transform4

getTransformation((Transform4)arg1) → tuple :

Return scale, rotate and translate corresponding values.

C++ signature :

boost::python::tuple getTransformation(PGL::Transform4*)

getVolume((Transform4)arg1) → float :

compute the Matrix3 determinant of the transformation

C++ signature :

double getVolume(PGL::Transform4 {lvalue})

isValid((Transform4)arg1) → bool :

C++ signature :

bool isValid(PGL::Transform4 {lvalue})

rotate((Transform4)arg1, (Matrix3)arg2) → None :

Add a rotation at the transformation

C++ signature :

void rotate(PGL::Transform4 {lvalue},PGL::Matrix3)

scale((Transform4)arg1, (Vector3)arg2) → None :

Add a scaling at the transformation

C++ signature :

void scale(PGL::Transform4 {lvalue},PGL::Vector3)

transform((Transform4)arg1, (Point3Array)arg2) → Point3Array :

transform a set of points

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> transform(PGL::Transform4*,PGL::RefCountPtr<PGL::Point3Array>)

translate((Transform4)arg1, (Vector3)arg2) → None :

Add a translation at the transformation

C++ signature :

void translate(PGL::Transform4 {lvalue},PGL::Vector3)

class Transform4Array

append((Transform4Array)arg1, (Transform4)arg2) → None :

C++ signature :

void append(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,PGL::RefCountPtr<PGL::Transform4>)

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

C++ signature :

void append(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*)

clear((Transform4Array)arg1) → None :

C++ signature :

void clear(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> > {lvalue})

empty((Transform4Array)arg1) → bool :

C++ signature :

bool empty(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> > {lvalue})

getId((Transform4Array)arg1) → int :

C++ signature :

unsigned long getId(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*)

insert((Transform4Array)arg1, (object)arg2, (Transform4)arg3) → None :

C++ signature :

void insert(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,int,PGL::RefCountPtr<PGL::Transform4>)

opposite_subset((Transform4Array)arg1, (object)arg2) → Transform4Array :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >* opposite_subset(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,boost::python::api::object)

pop((Transform4Array)arg1[, (object)arg2]) → Transform4 :

C++ signature :

PGL::RefCountPtr<PGL::Transform4> pop(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >* [,int])

prepend((Transform4Array)arg1, (Transform4)arg2) → None :

C++ signature :

void prepend(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,PGL::RefCountPtr<PGL::Transform4>)

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

C++ signature :

void prepend(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*)

reverse((Transform4Array)arg1) → None :

C++ signature :

void reverse(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> > {lvalue})

split((Transform4Array)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,boost::python::api::object)

split_indices((Transform4Array)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,boost::python::api::object)

split_subset((Transform4Array)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,boost::python::api::object)

subset((Transform4Array)arg1, (object)arg2) → Transform4Array :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >* subset(PGL::ObjectArray<PGL::RefCountPtr<PGL::Transform4> >*,boost::python::api::object)

class Transformation

class Transformation2D

transform((Transformation2D)arg1, (Point2Array)arg2) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> transform(PGL::Transformation2D {lvalue},PGL::RefCountPtr<PGL::Point2Array>)

transformP2Matrix((Transformation2D)arg1, (Point2Matrix)arg2) → Point2Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point2Matrix> transformP2Matrix(PGL::Transformation2D {lvalue},PGL::RefCountPtr<PGL::Point2Matrix>)

transformP3List((Transformation2D)arg1, (Point3Array)arg2) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> transformP3List(PGL::Transformation2D {lvalue},PGL::RefCountPtr<PGL::Point3Array>)

transformP3Matrix((Transformation2D)arg1, (Point3Matrix)arg2) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation2D {lvalue},PGL::RefCountPtr<PGL::Point3Matrix>)

class Transformation3D

transform((Transformation3D)arg1, (Point3Array)arg2) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> transform(PGL::Transformation3D {lvalue},PGL::RefCountPtr<PGL::Point3Array>)

transformP3Matrix((Transformation3D)arg1, (Point3Matrix)arg2) → Point3Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation3D {lvalue},PGL::RefCountPtr<PGL::Point3Matrix>)

transformP4List((Transformation3D)arg1, (Point4Array)arg2) → Point4Array :

C++ signature :

PGL::RefCountPtr<PGL::Point4Array> transformP4List(PGL::Transformation3D {lvalue},PGL::RefCountPtr<PGL::Point4Array>)

transformP4Matrix((Transformation3D)arg1, (Point4Matrix)arg2) → Point4Matrix :

C++ signature :

PGL::RefCountPtr<PGL::Point4Matrix> transformP4Matrix(PGL::Transformation3D {lvalue},PGL::RefCountPtr<PGL::Point4Matrix>)

class Transformed

Abstract base class for trasnformed node. It suppose to contain object on which the transformation is applied.

transformation((Transformed)arg1) → Transformation3D :

C++ signature :

PGL::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.

DEFAULT_TRANSLATION = Vector3(0,0,0)

deepcopy((Translated)arg1) → Translated :

C++ signature :

PGL::RefCountPtr<PGL::Translated> deepcopy(PGL::Translated {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::Translated> deepcopy(PGL::Translated {lvalue},PGL::DeepCopier {lvalue})

isTranslationToDefault((Translated)arg1) → bool :

C++ signature :

bool isTranslationToDefault(PGL::Translated {lvalue})

recast((Translated)arg1) → Translated :

C++ signature :

PGL::RefCountPtr<PGL::Translated> recast(PGL::Translated*)

property translation

class Translation

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.

colorAt((TriangleSet)arg1, (object)arg2) → Color4 :

C++ signature :

PGL::Color4 colorAt(PGL::TriangleSet {lvalue},unsigned int)

colorIndexAt((TriangleSet)arg1, (object)arg2) → Index3 :

C++ signature :

PGL::Tuple3<unsigned int> colorIndexAt(PGL::TriangleSet {lvalue},unsigned int)

property colorIndexList

deepcopy((TriangleSet)arg1) → TriangleSet :

C++ signature :

PGL::RefCountPtr<PGL::TriangleSet> deepcopy(PGL::TriangleSet {lvalue})

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

C++ signature :

PGL::RefCountPtr<PGL::TriangleSet> deepcopy(PGL::TriangleSet {lvalue},PGL::DeepCopier {lvalue})

faceColorAt((TriangleSet)arg1, (object)arg2, (object)arg3) → Color4 :

C++ signature :

PGL::Color4 faceColorAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)

faceNormalAt((TriangleSet)arg1, (object)arg2, (object)arg3) → Vector3 :

C++ signature :

PGL::Vector3 faceNormalAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)

faceTexCoordAt((TriangleSet)arg1, (object)arg2, (object)arg3) → Vector2 :

C++ signature :

PGL::Vector2 faceTexCoordAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)

indexAt((TriangleSet)arg1, (object)arg2) → Index3 :

C++ signature :

PGL::Tuple3<unsigned int> indexAt(PGL::TriangleSet {lvalue},unsigned int)

property indexList

isColorIndexListToDefault((TriangleSet)arg1) → bool :

C++ signature :

bool isColorIndexListToDefault(PGL::TriangleSet {lvalue})

isNormalIndexListToDefault((TriangleSet)arg1) → bool :

C++ signature :

bool isNormalIndexListToDefault(PGL::TriangleSet {lvalue})

isTexCoordIndexListToDefault((TriangleSet)arg1) → bool :

C++ signature :

bool isTexCoordIndexListToDefault(PGL::TriangleSet {lvalue})

normalAt((TriangleSet)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 normalAt(PGL::TriangleSet {lvalue},unsigned int)

normalIndexAt((TriangleSet)arg1, (object)arg2) → Index3 :

C++ signature :

PGL::Tuple3<unsigned int> normalIndexAt(PGL::TriangleSet {lvalue},unsigned int)

property normalIndexList

recast((TriangleSet)arg1) → TriangleSet :

C++ signature :

PGL::RefCountPtr<PGL::TriangleSet> recast(PGL::TriangleSet*)

texCoordAt((TriangleSet)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 texCoordAt(PGL::TriangleSet {lvalue},unsigned int)

texCoordIndexAt((TriangleSet)arg1, (object)arg2) → Index3 :

C++ signature :

PGL::Tuple3<unsigned int> texCoordIndexAt(PGL::TriangleSet {lvalue},unsigned int)

property texCoordIndexList

class UIntArray

append((UIntArray)arg1, (object)arg2) → None :

C++ signature :

void append(PGL::NumericArray1<unsigned int>*,unsigned int)

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

C++ signature :

void append(PGL::NumericArray1<unsigned int>*,PGL::NumericArray1<unsigned int>*)

clear((UIntArray)arg1) → None :

C++ signature :

void clear(PGL::NumericArray1<unsigned int> {lvalue})

empty((UIntArray)arg1) → bool :

C++ signature :

bool empty(PGL::NumericArray1<unsigned int> {lvalue})

getId((UIntArray)arg1) → int :

C++ signature :

unsigned long getId(PGL::NumericArray1<unsigned int>*)

insert((UIntArray)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void insert(PGL::NumericArray1<unsigned int>*,int,unsigned int)

opposite_subset((UIntArray)arg1, (object)arg2) → UIntArray :

Return a subset of the list. Should gives the indices that you do not want in the resulting subset as arguments.

C++ signature :

PGL::NumericArray1<unsigned int>* opposite_subset(PGL::NumericArray1<unsigned int>*,boost::python::api::object)

pop((UIntArray)arg1[, (object)arg2]) → int :

C++ signature :

unsigned int pop(PGL::NumericArray1<unsigned int>* [,int])

prepend((UIntArray)arg1, (object)arg2) → None :

C++ signature :

void prepend(PGL::NumericArray1<unsigned int>*,unsigned int)

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

C++ signature :

void prepend(PGL::NumericArray1<unsigned int>*,PGL::NumericArray1<unsigned int>*)

reverse((UIntArray)arg1) → None :

C++ signature :

void reverse(PGL::NumericArray1<unsigned int> {lvalue})

split((UIntArray)arg1, (object)arg2) → object :

Split the list into 2. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split(PGL::NumericArray1<unsigned int>*,boost::python::api::object)

split_indices((UIntArray)arg1, (object)arg2) → object :

Split the list into 2. Return list of indices of elements of the 2 subsets. Each element is tested with the split method that should return True or False

C++ signature :

boost::python::api::object split_indices(PGL::NumericArray1<unsigned int>*,boost::python::api::object)

split_subset((UIntArray)arg1, (object)arg2) → object :

Return a subset of the list and its complementay subset. Arg is the indices of the first subset.

C++ signature :

boost::python::api::object split_subset(PGL::NumericArray1<unsigned int>*,boost::python::api::object)

subset((UIntArray)arg1, (object)arg2) → UIntArray :

Return a subset of the list. Should gives the indices of the subset as arguments.

C++ signature :

PGL::NumericArray1<unsigned int>* subset(PGL::NumericArray1<unsigned int>*,boost::python::api::object)

apply_colormap((Color3Array)colormap, (RealArray)values) → Color3Array :

C++ signature :

PGL::RefCountPtr<PGL::Color3Array> apply_colormap(PGL::RefCountPtr<PGL::Color3Array>,PGL::RefCountPtr<PGL::RealArray>)

apply_colormap( (Color3Array)colormap, (RealArray)values, (object)minvalue, (object)maxvalue) -> Color3Array :

C++ signature :

PGL::RefCountPtr<PGL::Color3Array> apply_colormap(PGL::RefCountPtr<PGL::Color3Array>,PGL::RefCountPtr<PGL::RealArray>,double,double)

apply_colormap( (Color4Array)colormap, (RealArray)values) -> Color4Array :

C++ signature :

PGL::RefCountPtr<PGL::Color4Array> apply_colormap(PGL::RefCountPtr<PGL::Color4Array>,PGL::RefCountPtr<PGL::RealArray>)

apply_colormap( (Color4Array)colormap, (RealArray)values, (object)minvalue, (object)maxvalue) -> Color4Array :

C++ signature :

PGL::RefCountPtr<PGL::Color4Array> apply_colormap(PGL::RefCountPtr<PGL::Color4Array>,PGL::RefCountPtr<PGL::RealArray>,double,double)

circumsphere((Vector3)arg1, (Vector3)arg2, (Vector3)arg3) → object :

C++ signature :

boost::python::api::object circumsphere(PGL::Vector3,PGL::Vector3,PGL::Vector3)

closestPointToSegment((Vector3)point, (Vector3)segA, (Vector3)segB) → object :

C++ signature :

boost::python::api::object closestPointToSegment(PGL::Vector3,PGL::Vector3,PGL::Vector3)

closestPointToSegment( (Vector2)point, (Vector2)segA, (Vector2)segB) -> object :

Find the closest point from segment to a given point. Return closest point, distance, and u value of closest point on the segment

C++ signature :

boost::python::api::object closestPointToSegment(PGL::Vector2,PGL::Vector2,PGL::Vector2)

class eColor3Format

eBGR = openalea.plantgl.scenegraph._pglsg.eColor3Format.eBGR

eBRG = openalea.plantgl.scenegraph._pglsg.eColor3Format.eBRG

eGBR = openalea.plantgl.scenegraph._pglsg.eColor3Format.eGBR

eGRB = openalea.plantgl.scenegraph._pglsg.eColor3Format.eGRB

eRBG = openalea.plantgl.scenegraph._pglsg.eColor3Format.eRBG

eRGB = openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB

names = {'eBGR': openalea.plantgl.scenegraph._pglsg.eColor3Format.eBGR, 'eBRG': openalea.plantgl.scenegraph._pglsg.eColor3Format.eBRG, 'eGBR': openalea.plantgl.scenegraph._pglsg.eColor3Format.eGBR, 'eGRB': openalea.plantgl.scenegraph._pglsg.eColor3Format.eGRB, 'eRBG': openalea.plantgl.scenegraph._pglsg.eColor3Format.eRBG, 'eRGB': openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB}

values = {258: openalea.plantgl.scenegraph._pglsg.eColor3Format.eBGR, 513: openalea.plantgl.scenegraph._pglsg.eColor3Format.eBRG, 65538: openalea.plantgl.scenegraph._pglsg.eColor3Format.eGBR, 66048: openalea.plantgl.scenegraph._pglsg.eColor3Format.eRBG, 131073: openalea.plantgl.scenegraph._pglsg.eColor3Format.eGRB, 131328: openalea.plantgl.scenegraph._pglsg.eColor3Format.eRGB}

class eColor4Format

eABGR = openalea.plantgl.scenegraph._pglsg.eColor4Format.eABGR

eABRG = openalea.plantgl.scenegraph._pglsg.eColor4Format.eABRG

eAGBR = openalea.plantgl.scenegraph._pglsg.eColor4Format.eAGBR

eAGRB = openalea.plantgl.scenegraph._pglsg.eColor4Format.eAGRB

eARBG = openalea.plantgl.scenegraph._pglsg.eColor4Format.eARBG

eARGB = openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB

eBGRA = openalea.plantgl.scenegraph._pglsg.eColor4Format.eBGRA

eBRGA = openalea.plantgl.scenegraph._pglsg.eColor4Format.eBRGA

eGBRA = openalea.plantgl.scenegraph._pglsg.eColor4Format.eGBRA

eGRBA = openalea.plantgl.scenegraph._pglsg.eColor4Format.eGRBA

eRBGA = openalea.plantgl.scenegraph._pglsg.eColor4Format.eRBGA

eRGBA = openalea.plantgl.scenegraph._pglsg.eColor4Format.eRGBA

names = {'eABGR': openalea.plantgl.scenegraph._pglsg.eColor4Format.eABGR, 'eABRG': openalea.plantgl.scenegraph._pglsg.eColor4Format.eABRG, 'eAGBR': openalea.plantgl.scenegraph._pglsg.eColor4Format.eAGBR, 'eAGRB': openalea.plantgl.scenegraph._pglsg.eColor4Format.eAGRB, 'eARBG': openalea.plantgl.scenegraph._pglsg.eColor4Format.eARBG, 'eARGB': openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB, 'eBGRA': openalea.plantgl.scenegraph._pglsg.eColor4Format.eBGRA, 'eBRGA': openalea.plantgl.scenegraph._pglsg.eColor4Format.eBRGA, 'eGBRA': openalea.plantgl.scenegraph._pglsg.eColor4Format.eGBRA, 'eGRBA': openalea.plantgl.scenegraph._pglsg.eColor4Format.eGRBA, 'eRBGA': openalea.plantgl.scenegraph._pglsg.eColor4Format.eRBGA, 'eRGBA': openalea.plantgl.scenegraph._pglsg.eColor4Format.eRGBA}

values = {66051: openalea.plantgl.scenegraph._pglsg.eColor4Format.eABGR, 66306: openalea.plantgl.scenegraph._pglsg.eColor4Format.eABRG, 131331: openalea.plantgl.scenegraph._pglsg.eColor4Format.eAGBR, 131841: openalea.plantgl.scenegraph._pglsg.eColor4Format.eARBG, 196866: openalea.plantgl.scenegraph._pglsg.eColor4Format.eAGRB, 197121: openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB, 50331906: openalea.plantgl.scenegraph._pglsg.eColor4Format.eBGRA, 50332161: openalea.plantgl.scenegraph._pglsg.eColor4Format.eBRGA, 50397186: openalea.plantgl.scenegraph._pglsg.eColor4Format.eGBRA, 50397696: openalea.plantgl.scenegraph._pglsg.eColor4Format.eRBGA, 50462721: openalea.plantgl.scenegraph._pglsg.eColor4Format.eGRBA, 50462976: openalea.plantgl.scenegraph._pglsg.eColor4Format.eRGBA}

get_pgl_python_error_style() → bool :

C++ signature :

bool get_pgl_python_error_style()

get_pgl_qt_version() → int :

Get the Qt version to which PlantGL is compiled with

C++ signature :

int get_pgl_qt_version()

get_pgl_qt_version_string() → str :

Get the Qt version to which PlantGL is compiled with

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_pgl_qt_version_string()

get_pgl_supported_extensions() → object :

Gives all extensions supported by current version of PlantGL.

C++ signature :

boost::python::api::object get_pgl_supported_extensions()

get_pgl_version() → float :

C++ signature :

float get_pgl_version()

get_pgl_version_string() → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_pgl_version_string()

histogram((RealArray)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object histogram(PGL::RefCountPtr<PGL::RealArray>,unsigned int)

pgl_load_data((str)arg1) → object :

C++ signature :

boost::python::api::object pgl_load_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pgl_register_progressstatus_func((object)func) → None :

C++ signature :

void pgl_register_progressstatus_func(boost::python::api::object)

pgl_save_data((object)arg1, (str)arg2) → bool :

C++ signature :

bool pgl_save_data(boost::python::api::object,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pgl_support_extension((str)ext) → bool :

Tell wether PlantGL support a given extension

C++ signature :

bool pgl_support_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

pgl_unregister_progressstatus_func() → None :

C++ signature :

void pgl_unregister_progressstatus_func()

set_pgl_python_error_style((object)arg1) → None :

C++ signature :

void set_pgl_python_error_style(bool)

to_polarangle((Point3Array)pointarray, (Vector3)center, (object)lateralcoord, (object)depthcoord) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> to_polarangle(PGL::Point3Array*,PGL::Vector3,int,int)

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)

A CSpline interpolate a set of points.

add_point(pt)

bezier_cp(degree=3)

Compute bezier control points from the input points.

bezier_kv(is_linear=False, degree=3)

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, degree=3, stride_factor=10, distances=None)

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()

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()

Compute the distance between the input points.

move_point(i, pt)

class NurbsSwung(profileList, angleList, degree=3, ccw=True, slices=30, stride=30)

build_interpolator()

discretize()

getPointAt(u, v)

cspline(pts, is_closed=False, is_linear=False, distances=None, degree=3)

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

2.4. openalea.plantgl.scenegraph.nurbspatch_nd module

class NurbsPatch3D(ctrlPointMatrix, udegree=3, vdegree=3, wdegree=3, uknotList=None, vknotList=None, wknotList=None, ustride=30, vstride=30, wstride=30)

property ctrlPointMatrix

static default(xsize=4, ysize=4, zsize=4)

return a default nurbs patch

property firstUKnot

property firstVKnot

property firstWKnot

getBoundingBox()

getCtrlPointMatrix()

getIsoUVSectionAt(u, v)

getIsoUWSectionAt(u, w)

getIsoVWSectionAt(v, w)

getPointAt(u, v, w)

Compute point at (u,v,w)

getUPatch(u)

getVPatch(v)

getWDerivativeAt(u, v, w)

Compute point at (u,v,w)

getWPatch(w)

isUDegreeToDefault()

isUKnotListToDefault()

isUStrideToDefault()

isVDegreeToDefault()

isVKnotListToDefault()

isVStrideToDefault()

isValid()

Test whether self is valid or not

isWDegreeToDefault()

isWKnotListToDefault()

isWStrideToDefault()

property lastUKnot

property lastVKnot

property lastWKnot

setCtrlPointMatrix(points)