2. Scene Graph library

Contents

• Scene Graph library
  • Class Inheritance diagram
  • openalea.plantgl.scenegraph module
  • openalea.plantgl.scenegraph.cspline module
  • openalea.plantgl.scenegraph.nurbspatch_nd module

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 :

from openalea.plantgl.scenegraph import AmapSymbol
from openalea.plantgl.all import get_shared_data, Viewer, Scene
from os.path import join as pj
sym = AmapSymbol(get_shared_data(pj('amapsymbols','enpomf.smb')))
scene = Scene()
scene += sym
Viewer.display(scene)   
Viewer.frameGL.saveImage('amapsymbol.png', 'png') 

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

AmapSymbol(filename)

C++ signature :

void __init__(_object* [,std::string [,bool]])

deepcopy()

deepcopy( (AmapSymbol)arg1) -> AmapSymbol :

C++ signature :

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

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

C++ signature :

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

filename

readFile()

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

C++ signature :

bool readFile(PGL::AmapSymbol {lvalue},std::string)

recast()

recast( (AmapSymbol)arg1) -> AmapSymbol :

C++ signature :

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

class Appearance

Abstract base class for all appearance objects.

Raises an exception This class cannot be instantiated from Python

isTexture()

isTexture( (Appearance)arg1) -> bool :

Tell wether self is of type texture

C++ signature :

bool isTexture(PGL::Appearance {lvalue})

class AsymmetricHull

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

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

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

C++ signature :

void __init__(_object* [,double=0.5 [,double=0.5 [,double=0.5 [,double=0.5 [,double=0.0 [,double=0.0 [,double=0.0 [,double=0.0 [,TOOLS::Vector3=Vector3(0,0,-0.5) [,TOOLS::Vector3=Vector3(0,0,0.5) [,double=2.0 [,double=2.0 [,unsigned char=4 [,unsigned char=4]]]]]]]]]]]]]])

bottom

bottomShape

deepcopy()

deepcopy( (AsymmetricHull)arg1) -> AsymmetricHull :

C++ signature :

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

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

C++ signature :

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

isBottomShapeToDefault()

isBottomShapeToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isBottomShapeToDefault(PGL::AsymmetricHull {lvalue})

isBottomToDefault()

isBottomToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isBottomToDefault(PGL::AsymmetricHull {lvalue})

isNegXHeightToDefault()

isNegXHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isNegXHeightToDefault(PGL::AsymmetricHull {lvalue})

isNegXRadiusToDefault()

isNegXRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isNegXRadiusToDefault(PGL::AsymmetricHull {lvalue})

isNegYHeightToDefault()

isNegYHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isNegYHeightToDefault(PGL::AsymmetricHull {lvalue})

isNegYRadiusToDefault()

isNegYRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isNegYRadiusToDefault(PGL::AsymmetricHull {lvalue})

isPosXHeightToDefault()

isPosXHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isPosXHeightToDefault(PGL::AsymmetricHull {lvalue})

isPosXRadiusToDefault()

isPosXRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isPosXRadiusToDefault(PGL::AsymmetricHull {lvalue})

isPosYHeightToDefault()

isPosYHeightToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isPosYHeightToDefault(PGL::AsymmetricHull {lvalue})

isPosYRadiusToDefault()

isPosYRadiusToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isPosYRadiusToDefault(PGL::AsymmetricHull {lvalue})

isSlicesToDefault()

isSlicesToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isSlicesToDefault(PGL::AsymmetricHull {lvalue})

isStacksToDefault()

isStacksToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isStacksToDefault(PGL::AsymmetricHull {lvalue})

isTopShapeToDefault()

isTopShapeToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isTopShapeToDefault(PGL::AsymmetricHull {lvalue})

isTopToDefault()

isTopToDefault( (AsymmetricHull)arg1) -> bool :

C++ signature :

bool isTopToDefault(PGL::AsymmetricHull {lvalue})

negXHeight

negXRadius

negYHeight

negYRadius

posXHeight

posXRadius

posYHeight

posYRadius

recast()

recast( (AsymmetricHull)arg1) -> AsymmetricHull :

C++ signature :

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

slices

stacks

top

topShape

class AxisRotated

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

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

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

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

AxisRotated( Vector3 axis, radian angle, geometry)

C++ signature :

void __init__(_object* [,TOOLS::Vector3=Vector3(0,0,1) [,double=0.0 [,TOOLS::RefCountPtr<PGL::Geometry>=None]]])

angle

axis

deepcopy()

deepcopy( (AxisRotated)arg1) -> AxisRotated :

C++ signature :

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

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

C++ signature :

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

isAngleToDefault()

isAngleToDefault( (AxisRotated)arg1) -> bool :

C++ signature :

bool isAngleToDefault(PGL::AxisRotated {lvalue})

isAxisToDefault()

isAxisToDefault( (AxisRotated)arg1) -> bool :

C++ signature :

bool isAxisToDefault(PGL::AxisRotated {lvalue})

recast()

recast( (AxisRotated)arg1) -> AxisRotated :

C++ signature :

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

class AxisRotation

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

C++ signature :

void __init__(_object*,TOOLS::Vector3,double)

class BaseOrientation

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

C++ signature :

void __init__(_object*,TOOLS::Vector3,TOOLS::Vector3)

class BezierCurve

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,unsigned int [,unsigned char]])

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

Create a BezierCurve from a list of 3d points.

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Array> [,unsigned int=30 [,unsigned char=1]])

bernstein()

bernstein( (int)i, (int)n, (float)u) -> float :

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

C++ signature :

double bernstein(unsigned int,unsigned int,double)

bernstein_factors()

bernstein_factors( (int)n, (float)u) -> object :

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

C++ signature :

boost::python::api::object bernstein_factors(unsigned int,double)

ctrlPointList

deepcopy()

deepcopy( (BezierCurve)arg1) -> BezierCurve :

C++ signature :

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

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

C++ signature :

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

isStrideToDefault()

isStrideToDefault( (BezierCurve)arg1) -> bool :

C++ signature :

bool isStrideToDefault(PGL::BezierCurve {lvalue})

recast()

recast( (BezierCurve)arg1) -> BezierCurve :

C++ signature :

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

stride

class BezierCurve2D

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned int [,unsigned char]])

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

Create a BezierCurve from a list of 3d points.

C++ signature :

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

ctrlPointList

deepcopy()

deepcopy( (BezierCurve2D)arg1) -> BezierCurve2D :

C++ signature :

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

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

C++ signature :

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

isStrideToDefault()

isStrideToDefault( (BezierCurve2D)arg1) -> bool :

C++ signature :

bool isStrideToDefault(PGL::BezierCurve2D {lvalue})

recast()

recast( (BezierCurve2D)arg1) -> BezierCurve2D :

C++ signature :

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

stride

class BezierPatch

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

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

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

C++ signature :

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

ctrlPointMatrix

deepcopy()

deepcopy( (BezierPatch)arg1) -> BezierPatch :

C++ signature :

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

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

C++ signature :

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

getPointAt()

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

C++ signature :

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

getUSection()

getUSection( (BezierPatch)arg1, (float)u) -> LineicModel :

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

C++ signature :

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

getVSection()

getVSection( (BezierPatch)arg1, (float)v) -> LineicModel :

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

C++ signature :

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

isUStrideToDefault()

isUStrideToDefault( (BezierPatch)arg1) -> bool :

C++ signature :

bool isUStrideToDefault(PGL::BezierPatch {lvalue})

isVStrideToDefault()

isVStrideToDefault( (BezierPatch)arg1) -> bool :

C++ signature :

bool isVStrideToDefault(PGL::BezierPatch {lvalue})

recast()

recast( (BezierPatch)arg1) -> BezierPatch :

C++ signature :

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

udegree

ustride

vdegree

vstride

class BoundingBox

An axis aligned box represented by 2 opposite corners.

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

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

C++ signature :

void __init__(_object* [,TOOLS::Vector3=Vector3(0,0,0) [,TOOLS::Vector3=Vector3(0,0,0)]])

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

change()

change( (BoundingBox)arg1, (Vector3)arg2, (Vector3)arg3) -> None :

change(center)

C++ signature :

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

contains()

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

C++ signature :

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

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

C++ signature :

bool contains(PGL::BoundingBox*,TOOLS::Vector3)

getCenter()

getCenter( (BoundingBox)arg1) -> Vector3 :

C++ signature :

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

getId()

getId( (BoundingBox)arg1) -> int :

C++ signature :

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

getSize()

getSize( (BoundingBox)arg1) -> Vector3 :

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

C++ signature :

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

getXMax()

getXMax( (BoundingBox)arg1) -> float :

C++ signature :

double getXMax(PGL::BoundingBox {lvalue})

getXMin()

getXMin( (BoundingBox)arg1) -> float :

C++ signature :

double getXMin(PGL::BoundingBox {lvalue})

getXRange()

getXRange( (BoundingBox)arg1) -> float :

C++ signature :

double getXRange(PGL::BoundingBox {lvalue})

getYMax()

getYMax( (BoundingBox)arg1) -> float :

C++ signature :

double getYMax(PGL::BoundingBox {lvalue})

getYMin()

getYMin( (BoundingBox)arg1) -> float :

C++ signature :

double getYMin(PGL::BoundingBox {lvalue})

getYRange()

getYRange( (BoundingBox)arg1) -> float :

C++ signature :

double getYRange(PGL::BoundingBox {lvalue})

getZMax()

getZMax( (BoundingBox)arg1) -> float :

C++ signature :

double getZMax(PGL::BoundingBox {lvalue})

getZMin()

getZMin( (BoundingBox)arg1) -> float :

C++ signature :

double getZMin(PGL::BoundingBox {lvalue})

getZRange()

getZRange( (BoundingBox)arg1) -> float :

C++ signature :

double getZRange(PGL::BoundingBox {lvalue})

lowerLeftCorner

scale()

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

C++ signature :

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

set()

set( (BoundingBox)arg1, (Vector3)arg2, (Vector3)arg3) -> None :

set(lowerLeft,upperRight)

C++ signature :

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

transform()

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

C++ signature :

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

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

C++ signature :

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

translate()

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

C++ signature :

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

upperRightCorner

class Box

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

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

Box(Vector3(x,y,z))

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

deepcopy()

deepcopy( (Box)arg1) -> Box :

C++ signature :

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

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

C++ signature :

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

isSizeToDefault()

isSizeToDefault( (Box)arg1) -> bool :

C++ signature :

bool isSizeToDefault(PGL::Box {lvalue})

recast()

recast( (Box)arg1) -> Box :

C++ signature :

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

size

class Color3

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

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

C++ signature :

void __init__(_object*,PGL::Color3)

__init__( (object)arg1 [, (int)red=0 [, (int)green=0 [, (int)blue=0]]]) -> None :

Color3(red,green,blue)

C++ signature :

void __init__(_object* [,unsigned char=0 [,unsigned char=0 [,unsigned char=0]]])

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

C++ signature :

void __init__(_object* [,unsigned char=0])

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

C++ signature :

void __init__(_object*,PGL::Color4)

blue

clampedBlue()

clampedBlue( (Color3)arg1) -> float :

C++ signature :

double clampedBlue(PGL::Color3*)

clampedGreen()

clampedGreen( (Color3)arg1) -> float :

C++ signature :

double clampedGreen(PGL::Color3*)

clampedRed()

clampedRed( (Color3)arg1) -> float :

C++ signature :

double clampedRed(PGL::Color3*)

fromUint()

fromUint( (int)arg1) -> Color3 :

C++ signature :

PGL::Color3 fromUint(unsigned int)

getAverage()

getAverage( (Color3)arg1) -> float :

C++ signature :

double getAverage(PGL::Color3 {lvalue})

getAverageClamped()

getAverageClamped( (Color3)arg1) -> float :

C++ signature :

double getAverageClamped(PGL::Color3 {lvalue})

green

red

setClampedBlue()

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

C++ signature :

void setClampedBlue(PGL::Color3*,double)

setClampedGreen()

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

C++ signature :

void setClampedGreen(PGL::Color3*,double)

setClampedRed()

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

C++ signature :

void setClampedRed(PGL::Color3*,double)

toUint()

toUint( (Color3)arg1) -> int :

C++ signature :

unsigned int toUint(PGL::Color3 {lvalue})

class Color3Array

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

Color3Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

void append(PGL::Color3Array*,PGL::Color3)

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

C++ signature :

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

clear()

clear( (Color3Array)arg1) -> None :

C++ signature :

void clear(PGL::Color3Array {lvalue})

getId()

getId( (Color3Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Color3Array*)

getPglId()

getPglId( (Color3Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Color3Array)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

void prepend(PGL::Color3Array*,PGL::Color3)

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

C++ signature :

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

reverse()

reverse( (Color3Array)arg1) -> None :

C++ signature :

void reverse(PGL::Color3Array {lvalue})

class Color4

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

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

C++ signature :

void __init__(_object*,PGL::Color4)

__init__( (object)arg1 [, (int)red=0 [, (int)green=0 [, (int)blue=0 [, (int)alpha=0]]]]) -> None :

Color4(red,green,blue,alpha)

C++ signature :

void __init__(_object* [,unsigned char=0 [,unsigned char=0 [,unsigned char=0 [,unsigned char=0]]]])

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

C++ signature :

void __init__(_object* [,unsigned char=0])

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

C++ signature :

void __init__(_object* [,PGL::Color3=0 [,unsigned char=0]])

alpha

blue

clampedAlpha()

clampedAlpha( (Color4)arg1) -> float :

C++ signature :

double clampedAlpha(PGL::Color4*)

clampedBlue()

clampedBlue( (Color4)arg1) -> float :

C++ signature :

double clampedBlue(PGL::Color4*)

clampedGreen()

clampedGreen( (Color4)arg1) -> float :

C++ signature :

double clampedGreen(PGL::Color4*)

clampedRed()

clampedRed( (Color4)arg1) -> float :

C++ signature :

double clampedRed(PGL::Color4*)

fromUint()

fromUint( (int)arg1) -> Color4 :

C++ signature :

PGL::Color4 fromUint(unsigned int)

getAverage()

getAverage( (Color4)arg1) -> float :

C++ signature :

double getAverage(PGL::Color4 {lvalue})

getAverageClamped()

getAverageClamped( (Color4)arg1) -> float :

C++ signature :

double getAverageClamped(PGL::Color4 {lvalue})

getRGBAverage()

getRGBAverage( (Color4)arg1) -> float :

C++ signature :

double getRGBAverage(PGL::Color4 {lvalue})

getRGBAverageClamped()

getRGBAverageClamped( (Color4)arg1) -> float :

C++ signature :

double getRGBAverageClamped(PGL::Color4 {lvalue})

green

red

setClampedAlpha()

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

C++ signature :

void setClampedAlpha(PGL::Color4*,double)

setClampedBlue()

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

C++ signature :

void setClampedBlue(PGL::Color4*,double)

setClampedGreen()

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

C++ signature :

void setClampedGreen(PGL::Color4*,double)

setClampedRed()

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

C++ signature :

void setClampedRed(PGL::Color4*,double)

toUint()

toUint( (Color4)arg1) -> int :

C++ signature :

unsigned int toUint(PGL::Color4 {lvalue})

class Color4Array

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

Color4Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

void append(PGL::Color4Array*,PGL::Color4)

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

C++ signature :

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

clear()

clear( (Color4Array)arg1) -> None :

C++ signature :

void clear(PGL::Color4Array {lvalue})

getId()

getId( (Color4Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Color4Array*)

getPglId()

getPglId( (Color4Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Color4Array)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

void prepend(PGL::Color4Array*,PGL::Color4)

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

C++ signature :

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

reverse()

reverse( (Color4Array)arg1) -> None :

C++ signature :

void reverse(PGL::Color4Array {lvalue})

class Cone

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

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

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

C++ signature :

void __init__(_object* [,double=0.5 [,double=1.0 [,bool=True [,unsigned char=8]]]])

deepcopy()

deepcopy( (Cone)arg1) -> Cone :

C++ signature :

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

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

C++ signature :

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

height

isHeightToDefault()

isHeightToDefault( (Cone)arg1) -> bool :

C++ signature :

bool isHeightToDefault(PGL::Cone {lvalue})

isRadiusToDefault()

isRadiusToDefault( (Cone)arg1) -> bool :

C++ signature :

bool isRadiusToDefault(PGL::Cone {lvalue})

isSolidToDefault()

isSolidToDefault( (Cone)arg1) -> bool :

C++ signature :

bool isSolidToDefault(PGL::Cone {lvalue})

radius

recast()

recast( (Cone)arg1) -> Cone :

C++ signature :

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

solid

class Curve2D

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

Raises an exception This class cannot be instantiated from Python

findClosest()

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

findClosest(point) : return closestpoint, u

C++ signature :

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

firstKnot

getArcLengthToUMapping()

getArcLengthToUMapping( (Curve2D)arg1) -> QuantisedFunction :

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

C++ signature :

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

getLength()

getLength( (Curve2D)arg1) -> float :

C++ signature :

double getLength(PGL::Curve2D {lvalue})

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

C++ signature :

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

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

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

C++ signature :

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

getNormalAt()

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

C++ signature :

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

getPointAt()

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

C++ signature :

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

getTangentAt()

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

C++ signature :

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

getUToArcLengthMapping()

getUToArcLengthMapping( (Curve2D)arg1) -> QuantisedFunction :

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

C++ signature :

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

isWidthToDefault()

isWidthToDefault( (Curve2D)arg1) -> bool :

C++ signature :

bool isWidthToDefault(PGL::Curve2D {lvalue})

lastKnot

stride

width

class Curve2DArray

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

Curve2DArray(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

Curve2DArray([Curve2D,...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Curve2DArray)arg1) -> None :

C++ signature :

void clear(PGL::Curve2DArray {lvalue})

getId()

getId( (Curve2DArray)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Curve2DArray*)

getPglId()

getPglId( (Curve2DArray)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Curve2DArray)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (Curve2DArray)arg1) -> None :

C++ signature :

void reverse(PGL::Curve2DArray {lvalue})

class CurveArray

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

CurveArray(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

CurveArray([Curve,...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (CurveArray)arg1) -> None :

C++ signature :

void clear(PGL::CurveArray {lvalue})

getId()

getId( (CurveArray)arg1) -> int :

C++ signature :

unsigned long getId(PGL::CurveArray*)

getPglId()

getPglId( (CurveArray)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (CurveArray)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (CurveArray)arg1) -> None :

C++ signature :

void reverse(PGL::CurveArray {lvalue})

class Cylinder

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

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

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

C++ signature :

void __init__(_object* [,double=0.5 [,double=1.0 [,bool=True [,unsigned char=8]]]])

deepcopy()

deepcopy( (Cylinder)arg1) -> Cylinder :

C++ signature :

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

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

C++ signature :

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

recast()

recast( (Cylinder)arg1) -> Cylinder :

C++ signature :

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

class DeepCopier

Base class for recursive deep copy of a scene.

__init__( (object)arg1) -> None :

DeepCopier

C++ signature :

void __init__(_object*)

clear()

clear( (DeepCopier)arg1) -> None :

C++ signature :

void clear(PGL::DeepCopier {lvalue})

class Deformation

Raises an exception This class cannot be instantiated from Python

class Disc

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

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

Disc(radius, slices)

C++ signature :

void __init__(_object* [,double=0.5 [,unsigned char=8]])

deepcopy()

deepcopy( (Disc)arg1) -> Disc :

C++ signature :

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

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

C++ signature :

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

isRadiusToDefault()

isRadiusToDefault( (Disc)arg1) -> bool :

C++ signature :

bool isRadiusToDefault(PGL::Disc {lvalue})

radius

recast()

recast( (Disc)arg1) -> Disc :

C++ signature :

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

class ElevationGrid

A regular grid of elevations.

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

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

C++ signature :

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

deepcopy()

deepcopy( (ElevationGrid)arg1) -> ElevationGrid :

C++ signature :

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

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

C++ signature :

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

getHeightAt()

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

C++ signature :

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

getPointAt()

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

C++ signature :

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

getXDim()

getXDim( (ElevationGrid)arg1) -> int :

C++ signature :

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

getXSize()

getXSize( (ElevationGrid)arg1) -> float :

C++ signature :

double getXSize(PGL::ElevationGrid {lvalue})

getYDim()

getYDim( (ElevationGrid)arg1) -> int :

C++ signature :

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

getYSize()

getYSize( (ElevationGrid)arg1) -> float :

C++ signature :

double getYSize(PGL::ElevationGrid {lvalue})

heightList

isXSpacingToDefault()

isXSpacingToDefault( (ElevationGrid)arg1) -> bool :

C++ signature :

bool isXSpacingToDefault(PGL::ElevationGrid {lvalue})

isYSpacingToDefault()

isYSpacingToDefault( (ElevationGrid)arg1) -> bool :

C++ signature :

bool isYSpacingToDefault(PGL::ElevationGrid {lvalue})

recast()

recast( (ElevationGrid)arg1) -> ElevationGrid :

C++ signature :

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

xspacing

yspacing

class EulerRotated

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

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

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

-se ce*sr ce*cr |

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

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

EulerRotated(azimuth,elevation,roll,geometry)

C++ signature :

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

azimuth

deepcopy()

deepcopy( (EulerRotated)arg1) -> EulerRotated :

C++ signature :

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

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

C++ signature :

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

elevation

isAzimuthToDefault()

isAzimuthToDefault( (EulerRotated)arg1) -> bool :

C++ signature :

bool isAzimuthToDefault(PGL::EulerRotated {lvalue})

isElevationToDefault()

isElevationToDefault( (EulerRotated)arg1) -> bool :

C++ signature :

bool isElevationToDefault(PGL::EulerRotated {lvalue})

isRollToDefault()

isRollToDefault( (EulerRotated)arg1) -> bool :

C++ signature :

bool isRollToDefault(PGL::EulerRotated {lvalue})

recast()

recast( (EulerRotated)arg1) -> EulerRotated :

C++ signature :

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

roll

class EulerRotation

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

C++ signature :

void __init__(_object*,double,double,double)

class ExplicitModel

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

Raises an exception This class cannot be instantiated from Python

colorList

isColorListToDefault()

isColorListToDefault( (ExplicitModel)arg1) -> bool :

C++ signature :

bool isColorListToDefault(PGL::ExplicitModel {lvalue})

pointList

transform()

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

C++ signature :

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

class ExtrudedHull

A hull extruded by a vertical and an horizontal profiles.

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2D>,TOOLS::RefCountPtr<PGL::Curve2D> [,bool=True])

ccw

deepcopy()

deepcopy( (ExtrudedHull)arg1) -> ExtrudedHull :

C++ signature :

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

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

C++ signature :

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

horizontal

isCCWToDefault()

isCCWToDefault( (ExtrudedHull)arg1) -> bool :

C++ signature :

bool isCCWToDefault(PGL::ExtrudedHull {lvalue})

recast()

recast( (ExtrudedHull)arg1) -> ExtrudedHull :

C++ signature :

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

vertical

class Extrusion

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

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::LineicModel>,TOOLS::RefCountPtr<PGL::Curve2D> [,TOOLS::RefCountPtr<PGL::Point2Array>=None [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,TOOLS::RefCountPtr<TOOLS::RealArray>=None [,bool=False [,bool=True [,TOOLS::Vector3=Vector3(0,0,0)]]]]]])

axis

ccw

crossSection

deepcopy()

deepcopy( (Extrusion)arg1) -> Extrusion :

C++ signature :

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

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

C++ signature :

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

getInitialNormalValue()

getInitialNormalValue( (Extrusion)arg1) -> Vector3 :

C++ signature :

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

initialNormal

isCCWToDefault()

isCCWToDefault( (Extrusion)arg1) -> bool :

C++ signature :

bool isCCWToDefault(PGL::Extrusion {lvalue})

isInitialNormalToDefault()

isInitialNormalToDefault( (Extrusion)arg1) -> bool :

C++ signature :

bool isInitialNormalToDefault(PGL::Extrusion {lvalue})

isOrientationToDefault()

isOrientationToDefault( (Extrusion)arg1) -> bool :

C++ signature :

bool isOrientationToDefault(PGL::Extrusion {lvalue})

isScaleToDefault()

isScaleToDefault( (Extrusion)arg1) -> bool :

C++ signature :

bool isScaleToDefault(PGL::Extrusion {lvalue})

isSolidToDefault()

isSolidToDefault( (Extrusion)arg1) -> bool :

C++ signature :

bool isSolidToDefault(PGL::Extrusion {lvalue})

knotList

orientation

orientationList

recast()

recast( (Extrusion)arg1) -> Extrusion :

C++ signature :

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

scale

scaleList

solid

class FaceSet

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

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

Construct from TriangleSet

C++ signature :

void __init__(_object*,PGL::TriangleSet)

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

Construct from QuadSet

C++ signature :

void __init__(_object*,PGL::QuadSet)

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

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

C++ signature :

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

colorAt()

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

C++ signature :

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

colorIndexAt()

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

C++ signature :

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

colorIndexList

deepcopy()

deepcopy( (FaceSet)arg1) -> FaceSet :

C++ signature :

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

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

C++ signature :

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

faceColorAt()

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

C++ signature :

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

faceNormalAt()

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

C++ signature :

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

faceTexCoordAt()

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

C++ signature :

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

indexAt()

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

C++ signature :

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

indexList

isColorIndexListToDefault()

isColorIndexListToDefault( (FaceSet)arg1) -> bool :

C++ signature :

bool isColorIndexListToDefault(PGL::FaceSet {lvalue})

isNormalIndexListToDefault()

isNormalIndexListToDefault( (FaceSet)arg1) -> bool :

C++ signature :

bool isNormalIndexListToDefault(PGL::FaceSet {lvalue})

isTexCoordIndexListToDefault()

isTexCoordIndexListToDefault( (FaceSet)arg1) -> bool :

C++ signature :

bool isTexCoordIndexListToDefault(PGL::FaceSet {lvalue})

normalAt()

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

C++ signature :

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

normalIndexAt()

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

C++ signature :

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

normalIndexList

recast()

recast( (FaceSet)arg1) -> FaceSet :

C++ signature :

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

texCoordAt()

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

C++ signature :

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

texCoordIndexAt()

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

C++ signature :

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

texCoordIndexList

class Font

Font describes how text is displayed.

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

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

C++ signature :

void __init__(_object* [,std::string=’’ [,int=10 [,bool=False [,bool=False]]]])

bold

deepcopy()

deepcopy( (Font)arg1) -> Font :

C++ signature :

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

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

C++ signature :

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

family

isBoldToDefault()

isBoldToDefault( (Font)arg1) -> bool :

C++ signature :

bool isBoldToDefault(PGL::Font {lvalue})

isItalicToDefault()

isItalicToDefault( (Font)arg1) -> bool :

C++ signature :

bool isItalicToDefault(PGL::Font {lvalue})

isSizeToDefault()

isSizeToDefault( (Font)arg1) -> bool :

C++ signature :

bool isSizeToDefault(PGL::Font {lvalue})

italic

recast()

recast( (Font)arg1) -> Font :

C++ signature :

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

size

class Frustum

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

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

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

C++ signature :

void __init__(_object* [,double=0.5 [,double=1.0 [,double=0.5 [,bool=True [,unsigned char=8]]]]])

deepcopy()

deepcopy( (Frustum)arg1) -> Frustum :

C++ signature :

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

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

C++ signature :

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

isTaperToDefault()

isTaperToDefault( (Frustum)arg1) -> bool :

C++ signature :

bool isTaperToDefault(PGL::Frustum {lvalue})

recast()

recast( (Frustum)arg1) -> Frustum :

C++ signature :

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

taper

class Geometry

Abstract base class for all geometrical structure.

Raises an exception This class cannot be instantiated from Python

isACurve()

isACurve( (Geometry)arg1) -> bool :

C++ signature :

bool isACurve(PGL::Geometry {lvalue})

isASurface()

isASurface( (Geometry)arg1) -> bool :

C++ signature :

bool isASurface(PGL::Geometry {lvalue})

isAVolume()

isAVolume( (Geometry)arg1) -> bool :

C++ signature :

bool isAVolume(PGL::Geometry {lvalue})

isExplicit()

isExplicit( (Geometry)arg1) -> bool :

C++ signature :

bool isExplicit(PGL::Geometry {lvalue})

class GeometryArray

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

GeometryArray(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

GeometryArray([Geometry,...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (GeometryArray)arg1) -> None :

C++ signature :

void clear(PGL::GeometryArray {lvalue})

getId()

getId( (GeometryArray)arg1) -> int :

C++ signature :

unsigned long getId(PGL::GeometryArray*)

getPglId()

getPglId( (GeometryArray)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (GeometryArray)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (GeometryArray)arg1) -> None :

C++ signature :

void reverse(PGL::GeometryArray {lvalue})

class Group

A Group of Geometry

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

Group(list geometryList [,Polyline skeleton])

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

deepcopy()

deepcopy( (Group)arg1) -> Group :

C++ signature :

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

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

C++ signature :

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

geometryList

isSkeletonToDefault()

isSkeletonToDefault( (Group)arg1) -> bool :

C++ signature :

bool isSkeletonToDefault(PGL::Group {lvalue})

recast()

recast( (Group)arg1) -> Group :

C++ signature :

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

skeleton

class Hull

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

Raises an exception This class cannot be instantiated from Python

class IFS

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

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

IFS(depth, transfoList, geometry)

C++ signature :

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

deepcopy()

deepcopy( (IFS)arg1) -> IFS :

C++ signature :

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

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

C++ signature :

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

depth

geometry

getAllTransformations()

getAllTransformations( (IFS)arg1) -> Matrix4Array :

C++ signature :

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

isDepthToDefault()

isDepthToDefault( (IFS)arg1) -> bool :

C++ signature :

bool isDepthToDefault(PGL::IFS {lvalue})

recast()

recast( (IFS)arg1) -> IFS :

C++ signature :

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

transfoList

class ImageTexture

The image of a textured object.

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

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

C++ signature :

void __init__(_object*,std::string [,double=0.0 [,bool=True [,bool=True [,bool=True]]]])

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

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

C++ signature :

void __init__(_object*,std::string,std::string [,double=0.0 [,bool=True [,bool=True [,bool=True]]]])

filename

isMipmapingToDefault()

isMipmapingToDefault( (ImageTexture)arg1) -> bool :

C++ signature :

bool isMipmapingToDefault(PGL::ImageTexture {lvalue})

isRepeatSToDefault()

isRepeatSToDefault( (ImageTexture)arg1) -> bool :

C++ signature :

bool isRepeatSToDefault(PGL::ImageTexture {lvalue})

isRepeatTToDefault()

isRepeatTToDefault( (ImageTexture)arg1) -> bool :

C++ signature :

bool isRepeatTToDefault(PGL::ImageTexture {lvalue})

isTransparencyToDefault()

isTransparencyToDefault( (ImageTexture)arg1) -> bool :

C++ signature :

bool isTransparencyToDefault(PGL::ImageTexture {lvalue})

mipmaping

repeatS

repeatT

transparency

class Index

A set of indices

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

Index(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

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

Index(int i, int j, int k)

C++ signature :

void* __init__(boost::python::api::object,unsigned int,unsigned int,unsigned int)

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

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

C++ signature :

void* __init__(boost::python::api::object,unsigned int,unsigned int,unsigned int,unsigned int)

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

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

C++ signature :

void* __init__(boost::python::api::object,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Index)arg1) -> None :

C++ signature :

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

getId()

getId( (Index)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (Index)arg1) -> None :

C++ signature :

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

class Index3

A set of 3 indices

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

C++ signature :

void __init__(_object* [,unsigned long [,unsigned long [,unsigned long]]])

class Index3Array

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

Index3Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Index3Array)arg1) -> None :

C++ signature :

void clear(PGL::Index3Array {lvalue})

getId()

getId( (Index3Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Index3Array*)

getPglId()

getPglId( (Index3Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Index3Array)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (Index3Array)arg1) -> None :

C++ signature :

void reverse(PGL::Index3Array {lvalue})

class Index4

A set of 4 indices

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

C++ signature :

void __init__(_object* [,unsigned long [,unsigned long [,unsigned long [,unsigned long]]]])

class Index4Array

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

Index4Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Index4Array)arg1) -> None :

C++ signature :

void clear(PGL::Index4Array {lvalue})

getId()

getId( (Index4Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Index4Array*)

getPglId()

getPglId( (Index4Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Index4Array)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (Index4Array)arg1) -> None :

C++ signature :

void reverse(PGL::Index4Array {lvalue})

triangulate()

triangulate( (Index4Array)arg1) -> Index3Array :

C++ signature :

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

class IndexArray

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

IndexArray(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (IndexArray)arg1) -> None :

C++ signature :

void clear(PGL::IndexArray {lvalue})

getId()

getId( (IndexArray)arg1) -> int :

C++ signature :

unsigned long getId(PGL::IndexArray*)

getPglId()

getPglId( (IndexArray)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (IndexArray)arg1) -> int :

C++ signature :

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

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (IndexArray)arg1) -> None :

C++ signature :

void reverse(PGL::IndexArray {lvalue})

triangulate()

triangulate( (IndexArray)arg1) -> Index3Array :

C++ signature :

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

class LineicModel

Abstract base class for all lineic model.

Raises an exception This class cannot be instantiated from Python

findClosest()

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

findClosest(point) : return closestpoint, u

C++ signature :

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

firstKnot

getArcLengthToUMapping()

getArcLengthToUMapping( (LineicModel)arg1) -> QuantisedFunction :

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

C++ signature :

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

getLength()

getLength( (LineicModel)arg1) -> float :

C++ signature :

double getLength(PGL::LineicModel {lvalue})

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

C++ signature :

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

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

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

C++ signature :

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

getNormalAt()

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

C++ signature :

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

getPointAt()

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

C++ signature :

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

getTangentAt()

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

C++ signature :

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

getUToArcLengthMapping()

getUToArcLengthMapping( (LineicModel)arg1) -> QuantisedFunction :

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

C++ signature :

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

isWidthToDefault()

isWidthToDefault( (LineicModel)arg1) -> bool :

C++ signature :

bool isWidthToDefault(PGL::LineicModel {lvalue})

lastKnot

stride

width

class Material

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

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

C++ signature :

void __init__(_object*,PGL::Material)

__init__( (object)arg1 [, (Color3)ambient=Color3(80,80,80) [, (float)diffuse=2.0 [, (Color3)specular=Color3(40,40,40) [, (Color3)emission=Color3(0,0,0) [, (float)shininess=1.0 [, (float)transparency=0.0]]]]]]) -> None :

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

C++ signature :

void __init__(_object* [,PGL::Color3=Color3(80,80,80) [,double=2.0 [,PGL::Color3=Color3(40,40,40) [,PGL::Color3=Color3(0,0,0) [,double=1.0 [,double=0.0]]]]]])

__init__( (object)arg1, (str)name [, (Color3)ambient=Color3(80,80,80) [, (float)diffuse=2.0 [, (Color3)specular=Color3(40,40,40) [, (Color3)emission=Color3(0,0,0) [, (float)shininess=1.0 [, (float)transparency=0.0]]]]]]) -> None :

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

C++ signature :

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

ambient

deepcopy()

deepcopy( (Material)arg1) -> Material :

C++ signature :

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

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

C++ signature :

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

diffuse

emission

isAmbientToDefault()

isAmbientToDefault( (Material)arg1) -> bool :

C++ signature :

bool isAmbientToDefault(PGL::Material {lvalue})

isDiffuseToDefault()

isDiffuseToDefault( (Material)arg1) -> bool :

C++ signature :

bool isDiffuseToDefault(PGL::Material {lvalue})

isEmissionToDefault()

isEmissionToDefault( (Material)arg1) -> bool :

C++ signature :

bool isEmissionToDefault(PGL::Material {lvalue})

isShininessToDefault()

isShininessToDefault( (Material)arg1) -> bool :

C++ signature :

bool isShininessToDefault(PGL::Material {lvalue})

isSimilar()

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

C++ signature :

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

isSpecularToDefault()

isSpecularToDefault( (Material)arg1) -> bool :

C++ signature :

bool isSpecularToDefault(PGL::Material {lvalue})

isTransparencyToDefault()

isTransparencyToDefault( (Material)arg1) -> bool :

C++ signature :

bool isTransparencyToDefault(PGL::Material {lvalue})

recast()

recast( (Material)arg1) -> Material :

C++ signature :

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

shininess

specular

transparency

class Matrix3Transformation

Raises an exception This class cannot be instantiated from Python

class Matrix4Array

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

Matrix4Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Matrix4Array)arg1) -> None :

C++ signature :

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

getId()

getId( (Matrix4Array)arg1) -> int :

C++ signature :

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

getPglId()

getPglId( (Matrix4Array)arg1) -> int :

C++ signature :

unsigned long getPglId(TOOLS::Array1<TOOLS::Matrix4> {lvalue})

getPglReferenceCount()

getPglReferenceCount( (Matrix4Array)arg1) -> int :

C++ signature :

unsigned long getPglReferenceCount(TOOLS::Array1<TOOLS::Matrix4> {lvalue})

insert()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (Matrix4Array)arg1) -> None :

C++ signature :

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

class Matrix4Transformation

Raises an exception This class cannot be instantiated from Python

getMatrix()

getMatrix( (Matrix4Transformation)arg1) -> Matrix4 :

C++ signature :

TOOLS::Matrix4 getMatrix(PGL::Matrix4Transformation {lvalue})

class MatrixTransformed

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

Raises an exception This class cannot be instantiated from Python

geometry

class Mesh

Abstract base class for objects of type of mesh.

Raises an exception This class cannot be instantiated from Python

ccw

colorPerVertex

computeNormalList()

computeNormalList( (Mesh)arg1) -> None :

C++ signature :

void computeNormalList(PGL::Mesh {lvalue})

faceCenter()

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

C++ signature :

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

faceSize()

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

C++ signature :

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

indexListSize()

indexListSize( (Mesh)arg1) -> int :

C++ signature :

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

isCCWToDefault()

isCCWToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isCCWToDefault(PGL::Mesh {lvalue})

isColorPerVertexToDefault()

isColorPerVertexToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isColorPerVertexToDefault(PGL::Mesh {lvalue})

isNormalListToDefault()

isNormalListToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isNormalListToDefault(PGL::Mesh {lvalue})

isNormalPerVertexToDefault()

isNormalPerVertexToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isNormalPerVertexToDefault(PGL::Mesh {lvalue})

isSkeletonToDefault()

isSkeletonToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isSkeletonToDefault(PGL::Mesh {lvalue})

isSolidToDefault()

isSolidToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isSolidToDefault(PGL::Mesh {lvalue})

isTexCoordListToDefault()

isTexCoordListToDefault( (Mesh)arg1) -> bool :

C++ signature :

bool isTexCoordListToDefault(PGL::Mesh {lvalue})

normalList

normalPerVertex

pointAt()

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

C++ signature :

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

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

C++ signature :

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

skeleton

solid

texCoordList

class MonoSpectral

Mono spectral appearance property of an object.

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

MonoSpectral([ reflectance, transmittance ])

C++ signature :

void __init__(_object* [,double [,double]])

deepcopy()

deepcopy( (MonoSpectral)arg1) -> MonoSpectral :

C++ signature :

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

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

C++ signature :

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

recast()

recast( (MonoSpectral)arg1) -> MonoSpectral :

C++ signature :

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

reflectance

transmittance

class MultiSpectral

Multi spectral appearance property of an object.

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

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

C++ signature :

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

deepcopy()

deepcopy( (MultiSpectral)arg1) -> MultiSpectral :

C++ signature :

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

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

C++ signature :

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

recast()

recast( (MultiSpectral)arg1) -> MultiSpectral :

C++ signature :

TOOLS::RefCountPtr<PGL::MultiSpectral> recast(PGL::MultiSpectral*)

class NurbsCurve

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

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

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

C++ signature :

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Array>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int [,unsigned int [,unsigned char]]])

static CBezier(ctrl_points, uniform=False, stride=60)

Construct a nurbs from a set of ctrl_points

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

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

Parameters :

• ctrl_points (list of Vector) - a list

  of control points

• uniform (bool) - if True, the parameterization

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

• stride (int) - number of points to discretize

  the curve

Returns Type:

:class:NurbsCurve

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

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

basisFunctions()

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

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

C++ signature :

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

deepcopy()

deepcopy( (NurbsCurve)arg1) -> NurbsCurve :

C++ signature :

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

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

C++ signature :

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

defaultKnotList()

defaultKnotList( (int)nbCtrlPoints, (int)degree) -> RealArray :

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

C++ signature :

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

defaultKnotListTest()

defaultKnotListTest( (RealArray)knots, (int)nbCtrlPoints, (int)degree) -> bool :

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

C++ signature :

bool defaultKnotListTest(TOOLS::RefCountPtr<TOOLS::RealArray>,unsigned int,unsigned int)

degree

derivatesBasisFunctions()

derivatesBasisFunctions( (int)n, (float)u, (int)span, (int)degree, (RealArray)knotList) -> RealArray2 :

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

C++ signature :

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

findSpan()

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

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

C++ signature :

unsigned int findSpan(double,unsigned int,TOOLS::RefCountPtr<TOOLS::RealArray>)

fit()

fit([ (Point3Array)points=None [, (int)degree=3 [, (int)nbctrlpoints=4]]]) -> object :

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

C++ signature :

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

getDerivativeAt()

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

C++ signature :

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

getDerivativesAt()

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

C++ signature :

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

isDegreeToDefault()

isDegreeToDefault( (NurbsCurve)arg1) -> bool :

C++ signature :

bool isDegreeToDefault(PGL::NurbsCurve {lvalue})

isKnotListToDefault()

isKnotListToDefault( (NurbsCurve)arg1) -> bool :

C++ signature :

bool isKnotListToDefault(PGL::NurbsCurve {lvalue})

knotList

recast()

recast( (NurbsCurve)arg1) -> NurbsCurve :

C++ signature :

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

setKnotListToDefault()

setKnotListToDefault( (NurbsCurve)arg1) -> bool :

C++ signature :

bool setKnotListToDefault(PGL::NurbsCurve {lvalue})

class NurbsCurve2D

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

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

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

C++ signature :

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int [,unsigned int [,unsigned char]]])

static CBezier(ctrl_points, uniform=False, stride=60)

Construct a nurbs from a set of ctrl_points

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

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

Parameters :

• ctrl_points (list of Vector) - a list

  of control points

• uniform (bool) - if True, the parameterization

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

• stride (int) - number of points to discretize

  the curve

Returns Type:

:class:NurbsCurve2D

deepcopy()

deepcopy( (NurbsCurve2D)arg1) -> NurbsCurve2D :

C++ signature :

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

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

C++ signature :

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

degree

fit()

fit( (Point2Array)points) -> object :

C++ signature :

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

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

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

C++ signature :

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

fit( (Polyline2D)points) -> object :

C++ signature :

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

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

C++ signature :

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

isDegreeToDefault()

isDegreeToDefault( (NurbsCurve2D)arg1) -> bool :

C++ signature :

bool isDegreeToDefault(PGL::NurbsCurve2D {lvalue})

isKnotListToDefault()

isKnotListToDefault( (NurbsCurve2D)arg1) -> bool :

C++ signature :

bool isKnotListToDefault(PGL::NurbsCurve2D {lvalue})

knotList

recast()

recast( (NurbsCurve2D)arg1) -> NurbsCurve2D :

C++ signature :

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

setKnotListToDefault()

setKnotListToDefault( (NurbsCurve2D)arg1) -> bool :

C++ signature :

bool setKnotListToDefault(PGL::NurbsCurve2D {lvalue})

class NurbsPatch

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

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

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

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point4Matrix> [,TOOLS::RefCountPtr<TOOLS::RealArray> [,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int [,unsigned int [,unsigned int [,unsigned int [,bool]]]]]]])

__init__( (object)arg1, (Point4Matrix)ctrlPointList [, (int)udegree=3 [, (int)vdegree=3 [, (RealArray)uknotList=None [, (RealArray)vknotList=None [, (int)ustride=30 [, (int)vstride=30 [, (bool)ccw=True]]]]]]]) -> None :

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

C++ signature :

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

deepcopy()

deepcopy( (NurbsPatch)arg1) -> NurbsPatch :

C++ signature :

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

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

C++ signature :

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

deriveAt()

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

C++ signature :

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

getDerivativeAt()

getDerivativeAt( (NurbsPatch)arg1, (float)u, (float)v, (int)du, (int)dv) -> Vector4 :

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

C++ signature :

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

getDerivativesAt()

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

C++ signature :

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

getNormalAt()

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

C++ signature :

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

getUTangentAt()

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

C++ signature :

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

getVTangentAt()

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

C++ signature :

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

isUDegreeToDefault()

isUDegreeToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :

bool isUDegreeToDefault(PGL::NurbsPatch {lvalue})

isUKnotListToDefault()

isUKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :

bool isUKnotListToDefault(PGL::NurbsPatch {lvalue})

isVDegreeToDefault()

isVDegreeToDefault( (NurbsPatch)arg1) -> int :

C++ signature :

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

isVKnotListToDefault()

isVKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :

bool isVKnotListToDefault(PGL::NurbsPatch {lvalue})

recast()

recast( (NurbsPatch)arg1) -> NurbsPatch :

C++ signature :

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

setUKnotListToDefault()

setUKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :

bool setUKnotListToDefault(PGL::NurbsPatch {lvalue})

setVKnotListToDefault()

setVKnotListToDefault( (NurbsPatch)arg1) -> bool :

C++ signature :

bool setVKnotListToDefault(PGL::NurbsPatch {lvalue})

udegree

uknotList

vdegree

vknotList

class Oriented

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

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

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

C++ signature :

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

deepcopy()

deepcopy( (Oriented)arg1) -> Oriented :

C++ signature :

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

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

C++ signature :

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

isPrimaryToDefault()

isPrimaryToDefault( (Oriented)arg1) -> bool :

C++ signature :

bool isPrimaryToDefault(PGL::Oriented {lvalue})

isSecondaryToDefault()

isSecondaryToDefault( (Oriented)arg1) -> bool :

C++ signature :

bool isSecondaryToDefault(PGL::Oriented {lvalue})

primary

recast()

recast( (Oriented)arg1) -> Oriented :

C++ signature :

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

secondary

class OrthoTransformed

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

Raises an exception This class cannot be instantiated from Python

class OrthonormalBasis3D

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

C++ signature :

void __init__(_object*,TOOLS::Matrix3)

getMatrix()

getMatrix( (OrthonormalBasis3D)arg1) -> Matrix4 :

C++ signature :

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

getMatrix3()

getMatrix3( (OrthonormalBasis3D)arg1) -> Matrix3 :

C++ signature :

TOOLS::Matrix3 getMatrix3(PGL::OrthonormalBasis3D {lvalue})

class Paraboloid

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

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

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

C++ signature :

void __init__(_object* [,double=0.5 [,double=1.0 [,double=2.0 [,bool=True [,unsigned char=8 [,unsigned char=8]]]]]])

deepcopy()

deepcopy( (Paraboloid)arg1) -> Paraboloid :

C++ signature :

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

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

C++ signature :

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

isShapeToDefault()

isShapeToDefault( (Paraboloid)arg1) -> bool :

C++ signature :

bool isShapeToDefault(PGL::Paraboloid {lvalue})

isStacksToDefault()

isStacksToDefault( (Paraboloid)arg1) -> bool :

C++ signature :

bool isStacksToDefault(PGL::Paraboloid {lvalue})

recast()

recast( (Paraboloid)arg1) -> Paraboloid :

C++ signature :

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

shape

stacks

class ParametricModel

Abstract base class for all parametric primitives

Raises an exception This class cannot be instantiated from Python

class Patch

Abstract base class for patches.

Raises an exception This class cannot be instantiated from Python

ccw

isCCWToDefault()

isCCWToDefault( (Patch)arg1) -> bool :

C++ signature :

bool isCCWToDefault(PGL::Patch {lvalue})

class PlanarModel

Raises an exception This class cannot be instantiated from Python

class Point2Array

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

Point2Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Point2Array)arg1) -> None :

C++ signature :

void clear(PGL::Point2Array {lvalue})

findClosest()

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

Find closest point in the PointArray2 from arg

C++ signature :

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

getBounds()

getBounds( (Point2Array)arg1) -> object :

C++ signature :

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

getCenter()

getCenter( (Point2Array)arg1) -> Vector2 :

C++ signature :

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

getExtent()

getExtent( (Point2Array)arg1) -> Vector2 :

C++ signature :

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

getId()

getId( (Point2Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Point2Array*)

getLength()

getLength( (Point2Array)arg1) -> float :

C++ signature :

double getLength(PGL::Point2Array {lvalue})

getPglId()

getPglId( (Point2Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Point2Array)arg1) -> int :

C++ signature :

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

getXMaxIndex()

getXMaxIndex( (Point2Array)arg1) -> int :

C++ signature :

int getXMaxIndex(PGL::Point2Array const*)

getXMinAndMaxIndex()

getXMinAndMaxIndex( (Point2Array)arg1) -> object :

C++ signature :

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

getXMinIndex()

getXMinIndex( (Point2Array)arg1) -> int :

C++ signature :

int getXMinIndex(PGL::Point2Array const*)

getYMaxIndex()

getYMaxIndex( (Point2Array)arg1) -> int :

C++ signature :

int getYMaxIndex(PGL::Point2Array const*)

getYMinAndMaxIndex()

getYMinAndMaxIndex( (Point2Array)arg1) -> object :

C++ signature :

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

getYMinIndex()

getYMinIndex( (Point2Array)arg1) -> int :

C++ signature :

int getYMinIndex(PGL::Point2Array const*)

hausdorff_distance()

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

C++ signature :

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

insert()

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

C++ signature :

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

normalize()

normalize( (Point2Array)arg1) -> None :

C++ signature :

void normalize(PGL::Point2Array {lvalue})

partition()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

reverse()

reverse( (Point2Array)arg1) -> None :

C++ signature :

void reverse(PGL::Point2Array {lvalue})

sort()

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

C++ signature :

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

sortX()

sortX( (Point2Array)arg1) -> None :

C++ signature :

void sortX(PGL::Point2Array*)

sortY()

sortY( (Point2Array)arg1) -> None :

C++ signature :

void sortY(PGL::Point2Array*)

transform()

transform( (Point2Array)arg1, (Matrix2)arg2) -> None :

C++ signature :

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

class Point2Matrix

__init__( (object)arg1, (int)rows, (int)cols) -> None :

Point2Matrix(int rows, int cols)

C++ signature :

void __init__(_object*,unsigned long,unsigned long)

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

Point2Matrix([[a,b,c],[d,e,f]])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

clear()

clear( (Point2Matrix)arg1) -> None :

C++ signature :

void clear(PGL::Point2Matrix {lvalue})

empty()

empty( (Point2Matrix)arg1) -> bool :

C++ signature :

bool empty(PGL::Point2Matrix {lvalue})

getColumn()

getColumn( (Point2Matrix)arg1, (int)arg2) -> object :

C++ signature :

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

getColumnNb()

getColumnNb( (Point2Matrix)arg1) -> int :

C++ signature :

unsigned long getColumnNb(PGL::Point2Matrix*)

getDiagonal()

getDiagonal( (Point2Matrix)arg1) -> object :

C++ signature :

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

getRow()

getRow( (Point2Matrix)arg1, (int)arg2) -> object :

C++ signature :

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

getRowNb()

getRowNb( (Point2Matrix)arg1) -> int :

C++ signature :

unsigned long getRowNb(PGL::Point2Matrix*)

insertColumn()

insertColumn( (Point2Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

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

insertRow()

insertRow( (Point2Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

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

isUnique()

isUnique( (Point2Matrix)arg1) -> bool :

C++ signature :

bool isUnique(PGL::Point2Matrix {lvalue})

pushColumn()

pushColumn( (Point2Matrix)arg1, (object)arg2) -> None :

C++ signature :

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

pushRow()

pushRow( (Point2Matrix)arg1, (object)arg2) -> None :

C++ signature :

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

submatrix()

submatrix( (Point2Matrix)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> Point2Matrix :

C++ signature :

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

transpose()

transpose( (Point2Matrix)arg1) -> Point2Matrix :

C++ signature :

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

class Point3Array

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

Point3Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

Point3Array([Vector3(x,y,z),...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

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

Point3Array(Point2Array a, z)

C++ signature :

void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Point2Array>,double)

append()

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

C++ signature :

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

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

C++ signature :

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

clear()

clear( (Point3Array)arg1) -> None :

C++ signature :

void clear(PGL::Point3Array {lvalue})

findClosest()

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

Find closest point in the PointArray3 from arg

C++ signature :

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

getBounds()

getBounds( (Point3Array)arg1) -> object :

C++ signature :

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

getCenter()

getCenter( (Point3Array)arg1) -> Vector3 :

C++ signature :

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

getExtent()

getExtent( (Point3Array)arg1) -> Vector3 :

C++ signature :

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

getId()

getId( (Point3Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Point3Array*)

getLength()

getLength( (Point3Array)arg1) -> float :

C++ signature :

double getLength(PGL::Point3Array {lvalue})

getPglId()

getPglId( (Point3Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Point3Array)arg1) -> int :

C++ signature :

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

getXMaxIndex()

getXMaxIndex( (Point3Array)arg1) -> int :

C++ signature :

int getXMaxIndex(PGL::Point3Array const*)

getXMinAndMaxIndex()

getXMinAndMaxIndex( (Point3Array)arg1) -> object :

C++ signature :

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

getXMinIndex()

getXMinIndex( (Point3Array)arg1) -> int :

C++ signature :

int getXMinIndex(PGL::Point3Array const*)

getYMaxIndex()

getYMaxIndex( (Point3Array)arg1) -> int :

C++ signature :

int getYMaxIndex(PGL::Point3Array const*)

getYMinAndMaxIndex()

getYMinAndMaxIndex( (Point3Array)arg1) -> object :

C++ signature :

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

getYMinIndex()

getYMinIndex( (Point3Array)arg1) -> int :

C++ signature :

int getYMinIndex(PGL::Point3Array const*)

getZMaxIndex()

getZMaxIndex( (Point3Array)arg1) -> int :

C++ signature :

int getZMaxIndex(PGL::Point3Array const*)

getZMinAndMaxIndex()

getZMinAndMaxIndex( (Point3Array)arg1) -> object :

C++ signature :

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

getZMinIndex()

getZMinIndex( (Point3Array)arg1) -> int :

C++ signature :

int getZMinIndex(PGL::Point3Array const*)

hausdorff_distance()

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

C++ signature :

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

insert()

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

C++ signature :

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

normalize()

normalize( (Point3Array)arg1) -> None :

C++ signature :

void normalize(PGL::Point3Array {lvalue})

partition()

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

C++ signature :

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

pop()

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

C++ signature :

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

prepend()

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

C++ signature :

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

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

C++ signature :

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

project()

project( (Point3Array)arg1) -> Point2Array :

C++ signature :

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

reverse()

reverse( (Point3Array)arg1) -> None :

C++ signature :

void reverse(PGL::Point3Array {lvalue})

sort()

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

C++ signature :

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

sortX()

sortX( (Point3Array)arg1) -> None :

C++ signature :

void sortX(PGL::Point3Array*)

sortY()

sortY( (Point3Array)arg1) -> None :

C++ signature :

void sortY(PGL::Point3Array*)

sortZ()

sortZ( (Point3Array)arg1) -> None :

C++ signature :

void sortZ(PGL::Point3Array*)

transform()

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

C++ signature :

void transform(PGL::Point3Array {lvalue},TOOLS::Matrix3)

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

C++ signature :

void transform(PGL::Point3Array {lvalue},TOOLS::Matrix4)

class Point3Matrix

__init__( (object)arg1, (int)rows, (int)cols) -> None :

Point3Matrix(int rows, int cols)

C++ signature :

void __init__(_object*,unsigned long,unsigned long)

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

Point3Matrix([[a,b,c],[d,e,f]])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

clear()

clear( (Point3Matrix)arg1) -> None :

C++ signature :

void clear(PGL::Point3Matrix {lvalue})

empty()

empty( (Point3Matrix)arg1) -> bool :

C++ signature :

bool empty(PGL::Point3Matrix {lvalue})

getColumn()

getColumn( (Point3Matrix)arg1, (int)arg2) -> object :

C++ signature :

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

getColumnNb()

getColumnNb( (Point3Matrix)arg1) -> int :

C++ signature :

unsigned long getColumnNb(PGL::Point3Matrix*)

getDiagonal()

getDiagonal( (Point3Matrix)arg1) -> object :

C++ signature :

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

getRow()

getRow( (Point3Matrix)arg1, (int)arg2) -> object :

C++ signature :

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

getRowNb()

getRowNb( (Point3Matrix)arg1) -> int :

C++ signature :

unsigned long getRowNb(PGL::Point3Matrix*)

insertColumn()

insertColumn( (Point3Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

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

insertRow()

insertRow( (Point3Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

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

isUnique()

isUnique( (Point3Matrix)arg1) -> bool :

C++ signature :

bool isUnique(PGL::Point3Matrix {lvalue})

pushColumn()

pushColumn( (Point3Matrix)arg1, (object)arg2) -> None :

C++ signature :

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

pushRow()

pushRow( (Point3Matrix)arg1, (object)arg2) -> None :

C++ signature :

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

submatrix()

submatrix( (Point3Matrix)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> Point3Matrix :

C++ signature :

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

transpose()

transpose( (Point3Matrix)arg1) -> Point3Matrix :

C++ signature :

TOOLS::RefCountPtr<PGL::Point3Matrix> transpose(PGL::Point3Matrix*)

class Point4Array

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

Point4Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

Point4Array([Vector4(x,y,z,w),...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

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

Point4Array(Point2Array a, z, w)

C++ signature :

void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Point2Array>,double,double)

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

Point4Array(Point3Array a, w)

C++ signature :

void* __init__(boost::python::api::object,TOOLS::RefCountPtr<PGL::Point3Array>,double)

append()

append( (Point4Array)arg1, (Vector4)arg2) -> None :

C++ signature :

void append(PGL::Point4Array*,TOOLS::Vector4)

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

C++ signature :

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

clear()

clear( (Point4Array)arg1) -> None :

C++ signature :

void clear(PGL::Point4Array {lvalue})

findClosest()

findClosest( (Point4Array)arg1, (Vector4)point) -> object :

Find closest point in the PointArray4 from arg

C++ signature :

boost::python::api::object findClosest(PGL::Point4Array*,TOOLS::Vector4)

getBounds()

getBounds( (Point4Array)arg1) -> object :

C++ signature :

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

getCenter()

getCenter( (Point4Array)arg1) -> Vector4 :

C++ signature :

TOOLS::Vector4 getCenter(PGL::Point4Array {lvalue})

getExtent()

getExtent( (Point4Array)arg1) -> Vector4 :

C++ signature :

TOOLS::Vector4 getExtent(PGL::Point4Array {lvalue})

getId()

getId( (Point4Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::Point4Array*)

getLength()

getLength( (Point4Array)arg1) -> float :

C++ signature :

double getLength(PGL::Point4Array {lvalue})

getPglId()

getPglId( (Point4Array)arg1) -> int :

C++ signature :

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

getPglReferenceCount()

getPglReferenceCount( (Point4Array)arg1) -> int :

C++ signature :

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

getWMaxIndex()

getWMaxIndex( (Point4Array)arg1) -> int :

C++ signature :

int getWMaxIndex(PGL::Point4Array const*)

getWMinAndMaxIndex()

getWMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :

boost::python::api::object getWMinAndMaxIndex(PGL::Point4Array const*)

getWMinIndex()

getWMinIndex( (Point4Array)arg1) -> int :

C++ signature :

int getWMinIndex(PGL::Point4Array const*)

getXMaxIndex()

getXMaxIndex( (Point4Array)arg1) -> int :

C++ signature :

int getXMaxIndex(PGL::Point4Array const*)

getXMinAndMaxIndex()

getXMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :

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

getXMinIndex()

getXMinIndex( (Point4Array)arg1) -> int :

C++ signature :

int getXMinIndex(PGL::Point4Array const*)

getYMaxIndex()

getYMaxIndex( (Point4Array)arg1) -> int :

C++ signature :

int getYMaxIndex(PGL::Point4Array const*)

getYMinAndMaxIndex()

getYMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :

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

getYMinIndex()

getYMinIndex( (Point4Array)arg1) -> int :

C++ signature :

int getYMinIndex(PGL::Point4Array const*)

getZMaxIndex()

getZMaxIndex( (Point4Array)arg1) -> int :

C++ signature :

int getZMaxIndex(PGL::Point4Array const*)

getZMinAndMaxIndex()

getZMinAndMaxIndex( (Point4Array)arg1) -> object :

C++ signature :

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

getZMinIndex()

getZMinIndex( (Point4Array)arg1) -> int :

C++ signature :

int getZMinIndex(PGL::Point4Array const*)

hausdorff_distance()

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

C++ signature :

double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point4Array>,TOOLS::RefCountPtr<PGL::Point4Array>)

insert()

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

C++ signature :

void insert(PGL::Point4Array*,int,TOOLS::Vector4)

normalize()

normalize( (Point4Array)arg1) -> None :

C++ signature :

void normalize(PGL::Point4Array {lvalue})

partition()

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

C++ signature :

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

pop()

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

C++ signature :

TOOLS::Vector4 pop(PGL::Point4Array* [,int])

prepend()

prepend( (Point4Array)arg1, (Vector4)arg2) -> None :

C++ signature :

void prepend(PGL::Point4Array*,TOOLS::Vector4)

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

C++ signature :

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

project()

project( (Point4Array)arg1) -> Point3Array :

C++ signature :

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

reverse()

reverse( (Point4Array)arg1) -> None :

C++ signature :

void reverse(PGL::Point4Array {lvalue})

sort()

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

C++ signature :

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

sortW()

sortW( (Point4Array)arg1) -> None :

C++ signature :

void sortW(PGL::Point4Array*)

sortX()

sortX( (Point4Array)arg1) -> None :

C++ signature :

void sortX(PGL::Point4Array*)

sortY()

sortY( (Point4Array)arg1) -> None :

C++ signature :

void sortY(PGL::Point4Array*)

sortZ()

sortZ( (Point4Array)arg1) -> None :

C++ signature :

void sortZ(PGL::Point4Array*)

transform()

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

C++ signature :

void transform(PGL::Point4Array {lvalue},TOOLS::Matrix4)

class Point4Matrix

__init__( (object)arg1, (int)rows, (int)cols) -> None :

Point4Matrix(int rows, int cols)

C++ signature :

void __init__(_object*,unsigned long,unsigned long)

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

Point4Matrix([[a,b,c],[d,e,f]])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

clear()

clear( (Point4Matrix)arg1) -> None :

C++ signature :

void clear(PGL::Point4Matrix {lvalue})

empty()

empty( (Point4Matrix)arg1) -> bool :

C++ signature :

bool empty(PGL::Point4Matrix {lvalue})

getColumn()

getColumn( (Point4Matrix)arg1, (int)arg2) -> object :

C++ signature :

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

getColumnNb()

getColumnNb( (Point4Matrix)arg1) -> int :

C++ signature :

unsigned long getColumnNb(PGL::Point4Matrix*)

getDiagonal()

getDiagonal( (Point4Matrix)arg1) -> object :

C++ signature :

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

getRow()

getRow( (Point4Matrix)arg1, (int)arg2) -> object :

C++ signature :

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

getRowNb()

getRowNb( (Point4Matrix)arg1) -> int :

C++ signature :

unsigned long getRowNb(PGL::Point4Matrix*)

insertColumn()

insertColumn( (Point4Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

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

insertRow()

insertRow( (Point4Matrix)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

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

isUnique()

isUnique( (Point4Matrix)arg1) -> bool :

C++ signature :

bool isUnique(PGL::Point4Matrix {lvalue})

pushColumn()

pushColumn( (Point4Matrix)arg1, (object)arg2) -> None :

C++ signature :

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

pushRow()

pushRow( (Point4Matrix)arg1, (object)arg2) -> None :

C++ signature :

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

submatrix()

submatrix( (Point4Matrix)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> Point4Matrix :

C++ signature :

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

transpose()

transpose( (Point4Matrix)arg1) -> Point4Matrix :

C++ signature :

TOOLS::RefCountPtr<PGL::Point4Matrix> transpose(PGL::Point4Matrix*)

class PointSet

PointSet describes an explicit set of points

__init__( (object)arg1, (Point3Array)pointList [, (Color4Array)colorList=None [, (int)width=1]]) -> None :

PointSet(Point3Array pointList, Color4Array colorList = None)

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,TOOLS::RefCountPtr<PGL::Color4Array>=None [,unsigned char=1]])

convertToShapes()

convertToShapes( (PointSet)arg1 [, (Vector3)translation=Vector3(0,0,0)]) -> Scene :

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> convertToShapes(PGL::PointSet* [,TOOLS::Vector3=Vector3(0,0,0)])

deepcopy()

deepcopy( (PointSet)arg1) -> PointSet :

C++ signature :

TOOLS::RefCountPtr<PGL::PointSet> deepcopy(PGL::PointSet {lvalue})

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

C++ signature :

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

findClosest()

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

Find closest point in the PointSet from arg

C++ signature :

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

isWidthToDefault()

isWidthToDefault( (PointSet)arg1) -> bool :

C++ signature :

bool isWidthToDefault(PGL::PointSet {lvalue})

recast()

recast( (PointSet)arg1) -> PointSet :

C++ signature :

TOOLS::RefCountPtr<PGL::PointSet> recast(PGL::PointSet*)

transform()

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

C++ signature :

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

width

class PointSet2D

PointSet2D describes an explicit set of 2D points. See PointSet.

__init__( (object)arg1, (Point2Array)pointList [, (int)width=1]) -> None :

PointSet2D(pointList[,width])

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned char=1])

deepcopy()

deepcopy( (PointSet2D)arg1) -> PointSet2D :

C++ signature :

TOOLS::RefCountPtr<PGL::PointSet2D> deepcopy(PGL::PointSet2D {lvalue})

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

C++ signature :

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

findClosest()

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

Find closest point in the PointSet from arg

C++ signature :

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

isWidthToDefault()

isWidthToDefault( (PointSet2D)arg1) -> bool :

C++ signature :

bool isWidthToDefault(PGL::PointSet2D {lvalue})

pointList

recast()

recast( (PointSet2D)arg1) -> PointSet2D :

C++ signature :

TOOLS::RefCountPtr<PGL::PointSet2D> recast(PGL::PointSet2D*)

width

class Polyline

A Polyline describes a curve formed by connected segments. It is defined by a set of points. A color can be associated to each point for visualisation.

__init__( (object)arg1, (Point3Array)pointList [, (Color4Array)colorList]) -> None :

Polyline(Point3Array pointList, Color4Array colorList = None)

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,TOOLS::RefCountPtr<PGL::Color4Array>])

__init__( (object)arg1, (Point3Array)pointList, (Color4Array)colorList [, (int)width=1]) -> None :

Polyline(Point3Array pointList, Color4Array colorList = None, width = 1)

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array>,TOOLS::RefCountPtr<PGL::Color4Array> [,unsigned char=1])

__init__( (object)arg1, (Point3Array)pointList [, (int)width=1]) -> None :

Polyline(Point3Array pointList, width = 1)

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point3Array> [,unsigned char=1])

deepcopy()

deepcopy( (Polyline)arg1) -> Polyline :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline> deepcopy(PGL::Polyline {lvalue})

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

C++ signature :

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

recast()

recast( (Polyline)arg1) -> Polyline :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline> recast(PGL::Polyline*)

split()

split( (Polyline)arg1, (float)u) -> object :

C++ signature :

boost::python::api::object split(PGL::Polyline*,double)

class Polyline2D

A Polyline2D describes a curve formed by connected 2D segments. It is defined by a set of 2D points. See Polyline.

__init__( (object)arg1, (Point2Array)pointList [, (int)width=1]) -> None :

Polyline2D(pointList[,width])

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned char=1])

ArcOfCircle()

ArcOfCircle([ (float)radius=0.5 [, (float)starting_angle=0 [, (float)angle_range=3.141592653589793 [, (int)slices=8]]]]) -> Polyline2D :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline2D> ArcOfCircle([ double=0.5 [,double=0 [,double=3.141592653589793 [,unsigned char=8]]]])

Circle()

Circle([ (float)radius=0.5 [, (int)slices=8]]) -> Polyline2D :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline2D> Circle([ double=0.5 [,unsigned char=8]])

SuperEllipsis()

SuperEllipsis([ (float)radius=0.5 [, (float)height=0.5 [, (float)degree=2 [, (float)starting_angle=0 [, (float)angle_range=6.2831853072 [, (int)slices=8]]]]]]) -> Polyline2D :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline2D> SuperEllipsis([ double=0.5 [,double=0.5 [,double=2 [,double=0 [,double=6.2831853072 [,unsigned char=8]]]]]])

deepcopy()

deepcopy( (Polyline2D)arg1) -> Polyline2D :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline2D> deepcopy(PGL::Polyline2D {lvalue})

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

C++ signature :

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

getNormalAt()

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

C++ signature :

TOOLS::Vector2 getNormalAt(PGL::Polyline2D {lvalue},double)

getTangentAt()

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

C++ signature :

TOOLS::Vector2 getTangentAt(PGL::Polyline2D {lvalue},double)

pointList

recast()

recast( (Polyline2D)arg1) -> Polyline2D :

C++ signature :

TOOLS::RefCountPtr<PGL::Polyline2D> recast(PGL::Polyline2D*)

split()

split( (Polyline2D)arg1, (float)u) -> object :

C++ signature :

boost::python::api::object split(PGL::Polyline2D*,double)

class Primitive

Abstract base class for all predefined primitives.

Raises an exception This class cannot be instantiated from Python

class ProfileInterpolation

__init__( (object)arg1, (Curve2DArray)profiles, (RealArray)knotList [, (int)degree=3 [, (int)stride=0]]) -> None :

ProfileInterpolation([Curve2D] profiles,[float] knotList,int degree,int stride

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2DArray>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned int=3 [,unsigned int=0]])

degree

getSectionAt()

getSectionAt( (ProfileInterpolation)arg1, (float)arg2) -> object :

C++ signature :

boost::python::api::object getSectionAt(PGL::ProfileInterpolation*,double)

isDegreeToDefault()

isDegreeToDefault( (ProfileInterpolation)arg1) -> bool :

C++ signature :

bool isDegreeToDefault(PGL::ProfileInterpolation {lvalue})

isStrideToDefault()

isStrideToDefault( (ProfileInterpolation)arg1) -> bool :

C++ signature :

bool isStrideToDefault(PGL::ProfileInterpolation {lvalue})

knotList

profileList

stride

umax

umin

class QuadSet

A QuadSet describes a surface formed by a set of connected quadrilaterals, i.e. four sided polygons. Quads are specified using set of tuples of 4 indices (Index4) pointing to a list of points.

__init__( (object)arg1 [, (Point3Array)pointList=None [, (Index4Array)indexList=None [, (Point3Array)normalList=None [, (Index4Array)normalIndexList=None [, (Color4Array)colorList=None [, (Index4Array)colorIndexList=None [, (Point2Array)texCoordList=None [, (Index4Array)texCoordIndexList=None [, (bool)normalPerVertex=True [, (bool)colorPerVertex=True [, (bool)ccw=True [, (bool)solid=False [, (Polyline)skeleton=None]]]]]]]]]]]]]) -> None :

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

C++ signature :

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

colorAt()

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

C++ signature :

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

colorIndexAt()

colorIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :

TOOLS::Tuple4<unsigned int> colorIndexAt(PGL::QuadSet {lvalue},unsigned int)

colorIndexList

deepcopy()

deepcopy( (QuadSet)arg1) -> QuadSet :

C++ signature :

TOOLS::RefCountPtr<PGL::QuadSet> deepcopy(PGL::QuadSet {lvalue})

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

C++ signature :

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

faceColorAt()

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

C++ signature :

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

faceNormalAt()

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

C++ signature :

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

faceTexCoordAt()

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

C++ signature :

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

indexAt()

indexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :

TOOLS::Tuple4<unsigned int> indexAt(PGL::QuadSet {lvalue},unsigned int)

indexList

isColorIndexListToDefault()

isColorIndexListToDefault( (QuadSet)arg1) -> bool :

C++ signature :

bool isColorIndexListToDefault(PGL::QuadSet {lvalue})

isNormalIndexListToDefault()

isNormalIndexListToDefault( (QuadSet)arg1) -> bool :

C++ signature :

bool isNormalIndexListToDefault(PGL::QuadSet {lvalue})

isTexCoordIndexListToDefault()

isTexCoordIndexListToDefault( (QuadSet)arg1) -> bool :

C++ signature :

bool isTexCoordIndexListToDefault(PGL::QuadSet {lvalue})

normalAt()

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

C++ signature :

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

normalIndexAt()

normalIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :

TOOLS::Tuple4<unsigned int> normalIndexAt(PGL::QuadSet {lvalue},unsigned int)

normalIndexList

recast()

recast( (QuadSet)arg1) -> QuadSet :

C++ signature :

TOOLS::RefCountPtr<PGL::QuadSet> recast(PGL::QuadSet*)

texCoordAt()

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

C++ signature :

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

texCoordIndexAt()

texCoordIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :

C++ signature :

TOOLS::Tuple4<unsigned int> texCoordIndexAt(PGL::QuadSet {lvalue},unsigned int)

texCoordIndexList

class QuantisedFunction

A 2D quantised injective function (homomorphism) defined on the range [firstx,lastx].

__init__( (object)arg1, (Curve2D)curve [, (int)sampling]) -> None :

QuantisedFunction(curve[,sampling,clamped]) : Quantised 2D function. If clamped parameter is set to False, if a x value is out of range, first or last value is returned. Otherwise an exception is raised.

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2D> [,unsigned int])

__init__( (object)arg1, (Point2Array)points [, (int)sampling]) -> None :

Function(points [,sampling])

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Point2Array> [,unsigned int])

build()

build( (QuantisedFunction)arg1, (Curve2D)curve, (int)sampling) -> bool :

C++ signature :

bool build(PGL::QuantisedFunction {lvalue},TOOLS::RefCountPtr<PGL::Curve2D>,unsigned int)

build( (QuantisedFunction)arg1, (Curve2D)arg2) -> bool :

C++ signature :

bool build(PGL::QuantisedFunction {lvalue},TOOLS::RefCountPtr<PGL::Curve2D>)

checkQuantisableFunction()

checkQuantisableFunction( (Curve2D)arg1) -> bool :

C++ signature :

bool checkQuantisableFunction(TOOLS::RefCountPtr<PGL::Curve2D>)

clamped

findX()

findX( (QuantisedFunction)arg1, (float)y) -> object :

C++ signature :

boost::python::api::object findX(PGL::QuantisedFunction*,double)

findX( (QuantisedFunction)arg1, (float)y, (float)startingX) -> object :

findX(y[,startingX]) : find the first x value such as f(x) = y.

C++ signature :

boost::python::api::object findX(PGL::QuantisedFunction*,double,double)

firstx

getValue()

getValue( (QuantisedFunction)arg1, (float)x) -> float :

C++ signature :

double getValue(PGL::QuantisedFunction*,double)

inverse()

inverse( (QuantisedFunction)arg1) -> QuantisedFunction :

C++ signature :

TOOLS::RefCountPtr<PGL::QuantisedFunction> inverse(PGL::QuantisedFunction {lvalue})

isClampedToDefault()

isClampedToDefault( (QuantisedFunction)arg1) -> bool :

C++ signature :

bool isClampedToDefault(PGL::QuantisedFunction {lvalue})

isDecreasing()

isDecreasing( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :

C++ signature :

bool isDecreasing(PGL::QuantisedFunction {lvalue} [,bool])

isIncreasing()

isIncreasing( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :

C++ signature :

bool isIncreasing(PGL::QuantisedFunction {lvalue} [,bool])

isMonotonous()

isMonotonous( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :

C++ signature :

bool isMonotonous(PGL::QuantisedFunction {lvalue} [,bool])

isValid()

isValid( (QuantisedFunction)arg1) -> bool :

C++ signature :

bool isValid(PGL::QuantisedFunction {lvalue})

lastx

sampling

class RealArray

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

RealArray(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

IndexArray([a,b,...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

append( (RealArray)arg1, (float)arg2) -> None :

C++ signature :

void append(TOOLS::RealArray*,double)

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

C++ signature :

void append(TOOLS::RealArray*,TOOLS::RealArray*)

clear()

clear( (RealArray)arg1) -> None :

C++ signature :

void clear(TOOLS::RealArray {lvalue})

getId()

getId( (RealArray)arg1) -> int :

C++ signature :

unsigned long getId(TOOLS::RealArray*)

getPglId()

getPglId( (RealArray)arg1) -> int :

C++ signature :

unsigned long getPglId(TOOLS::RealArray {lvalue})

getPglReferenceCount()

getPglReferenceCount( (RealArray)arg1) -> int :

C++ signature :

unsigned long getPglReferenceCount(TOOLS::RealArray {lvalue})

insert()

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

C++ signature :

void insert(TOOLS::RealArray*,int,double)

pop()

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

C++ signature :

double pop(TOOLS::RealArray* [,int])

prepend()

prepend( (RealArray)arg1, (float)arg2) -> None :

C++ signature :

void prepend(TOOLS::RealArray*,double)

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

C++ signature :

void prepend(TOOLS::RealArray*,TOOLS::RealArray*)

reverse()

reverse( (RealArray)arg1) -> None :

C++ signature :

void reverse(TOOLS::RealArray {lvalue})

class RealArray2

__init__( (object)arg1, (int)rows, (int)cols) -> None :

RealArray2(int rows, int cols)

C++ signature :

void __init__(_object*,unsigned long,unsigned long)

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

RealArray2([[a,b,c],[d,e,f]])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

clear()

clear( (RealArray2)arg1) -> None :

C++ signature :

void clear(TOOLS::RealArray2 {lvalue})

empty()

empty( (RealArray2)arg1) -> bool :

C++ signature :

bool empty(TOOLS::RealArray2 {lvalue})

getColumn()

getColumn( (RealArray2)arg1, (int)arg2) -> object :

C++ signature :

boost::python::api::object getColumn(TOOLS::RealArray2*,unsigned long)

getColumnNb()

getColumnNb( (RealArray2)arg1) -> int :

C++ signature :

unsigned long getColumnNb(TOOLS::RealArray2*)

getDiagonal()

getDiagonal( (RealArray2)arg1) -> object :

C++ signature :

boost::python::api::object getDiagonal(TOOLS::RealArray2*)

getRow()

getRow( (RealArray2)arg1, (int)arg2) -> object :

C++ signature :

boost::python::api::object getRow(TOOLS::RealArray2*,unsigned long)

getRowNb()

getRowNb( (RealArray2)arg1) -> int :

C++ signature :

unsigned long getRowNb(TOOLS::RealArray2*)

insertColumn()

insertColumn( (RealArray2)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

void insertColumn(TOOLS::RealArray2*,unsigned long,boost::python::api::object)

insertRow()

insertRow( (RealArray2)arg1, (int)arg2, (object)arg3) -> None :

C++ signature :

void insertRow(TOOLS::RealArray2*,unsigned long,boost::python::api::object)

inverse()

inverse( (RealArray2)arg1) -> RealArray2 :

C++ signature :

TOOLS::RefCountPtr<TOOLS::RealArray2> inverse(TOOLS::RealArray2*)

isUnique()

isUnique( (RealArray2)arg1) -> bool :

C++ signature :

bool isUnique(TOOLS::RealArray2 {lvalue})

pushColumn()

pushColumn( (RealArray2)arg1, (object)arg2) -> None :

C++ signature :

void pushColumn(TOOLS::RealArray2*,boost::python::api::object)

pushRow()

pushRow( (RealArray2)arg1, (object)arg2) -> None :

C++ signature :

void pushRow(TOOLS::RealArray2*,boost::python::api::object)

submatrix()

submatrix( (RealArray2)arg1, (int)row, (int)col, (int)nbrow, (int)nbcol) -> RealArray2 :

C++ signature :

TOOLS::RefCountPtr<TOOLS::RealArray2> submatrix(TOOLS::RealArray2*,unsigned int,unsigned int,unsigned int,unsigned int)

svd()

svd( (RealArray2)arg1) -> object :

C++ signature :

boost::python::api::object svd(TOOLS::RealArray2*)

transpose()

transpose( (RealArray2)arg1) -> RealArray2 :

C++ signature :

TOOLS::RefCountPtr<TOOLS::RealArray2> transpose(TOOLS::RealArray2*)

class Revolution

Revolution describes a general surface of revolution generated by the rotation of a planar curve about the z -axis. The number of points within the generatrice curve determines the number of subdivisions along the z -axis when discretizing the object. slice determine the number of evaluated vertical sections.

__init__( (object)arg1, (Curve2D)profile [, (int)slices=8]) -> None :

Revolution(profile [, slices])

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2D> [,unsigned char=8])

deepcopy()

deepcopy( (Revolution)arg1) -> Revolution :

C++ signature :

TOOLS::RefCountPtr<PGL::Revolution> deepcopy(PGL::Revolution {lvalue})

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

C++ signature :

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

profile

recast()

recast( (Revolution)arg1) -> Revolution :

C++ signature :

TOOLS::RefCountPtr<PGL::Revolution> recast(PGL::Revolution*)

class SOR

Abstract base class for 3D objects of type of surface of revolution.

Raises an exception This class cannot be instantiated from Python

isSlicesToDefault()

isSlicesToDefault( (SOR)arg1) -> bool :

C++ signature :

bool isSlicesToDefault(PGL::SOR {lvalue})

slices

class SOR2D

Abstract base class for 2D objects of type of surface of revolution.

Raises an exception This class cannot be instantiated from Python

isSlicesToDefault()

isSlicesToDefault( (SOR2D)arg1) -> bool :

C++ signature :

bool isSlicesToDefault(PGL::SOR2D {lvalue})

slices

class Scaled

The Scaled describes an object to which an anisotropic scaling has been applied. The scaling transformation is given by the matrix: |sx 0 0| |0 sy 0| |0 0 sz| where (sx, sy, sz) denotes the scaling factors along the x, y and z-axis.

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

Scaled(scale,geometry)

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

deepcopy()

deepcopy( (Scaled)arg1) -> Scaled :

C++ signature :

TOOLS::RefCountPtr<PGL::Scaled> deepcopy(PGL::Scaled {lvalue})

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

C++ signature :

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

isScaleToDefault()

isScaleToDefault( (Scaled)arg1) -> bool :

C++ signature :

bool isScaleToDefault(PGL::Scaled {lvalue})

recast()

recast( (Scaled)arg1) -> Scaled :

C++ signature :

TOOLS::RefCountPtr<PGL::Scaled> recast(PGL::Scaled*)

scale

class Scaling

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

C++ signature :

void __init__(_object*,TOOLS::Vector3)

class Scene

A 3D Scene defined as a list of objects of type of Shape.

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

Read a scene from file.

C++ signature :

void __init__(_object*,std::string)

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

Create a scene with n empty elements.

C++ signature :

void __init__(_object* [,unsigned int])

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

Create an empty scene.

C++ signature :

void __init__(_object*,PGL::Scene)

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::list)

class Pool

The scene pool. Allow you to access all scene in memory using their id.

Raises an exception This class cannot be instantiated from Python

get()

get( (Pool)arg1, (int)arg2) -> Scene :

get scene from id.

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> get(PGL::Scene::Pool {lvalue},unsigned long)

getScenes()

getScenes( (Pool)arg1) -> object :

get all scene.

C++ signature :

boost::python::api::object getScenes(PGL::Scene::Pool*)

Scene.add()

add( (Scene)arg1, (Shape)arg2) -> None :

C++ signature :

void add(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Shape>)

add( (Scene)arg1, (Shape3D)arg2) -> None :

C++ signature :

void add(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Shape3D>)

add( (Scene)arg1, (Geometry)arg2) -> None :

C++ signature :

void add(PGL::Scene*,TOOLS::RefCountPtr<PGL::Geometry>)

add( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :

void add(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)

Scene.apply()

apply( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :

bool apply(PGL::Scene {lvalue},PGL::Action {lvalue})

Scene.applyAppearanceFirst()

applyAppearanceFirst( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :

bool applyAppearanceFirst(PGL::Scene {lvalue},PGL::Action {lvalue})

Scene.applyAppearanceOnly()

applyAppearanceOnly( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :

bool applyAppearanceOnly(PGL::Scene {lvalue},PGL::Action {lvalue})

Scene.applyGeometryFirst()

applyGeometryFirst( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :

bool applyGeometryFirst(PGL::Scene {lvalue},PGL::Action {lvalue})

Scene.applyGeometryOnly()

applyGeometryOnly( (Scene)arg1, (Action)arg2) -> bool :

C++ signature :

bool applyGeometryOnly(PGL::Scene {lvalue},PGL::Action {lvalue})

Scene.clear()

clear( (Scene)arg1) -> None :

C++ signature :

void clear(PGL::Scene {lvalue})

Scene.deepcopy()

deepcopy( (Scene)arg1) -> Scene :

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> deepcopy(PGL::Scene {lvalue})

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

C++ signature :

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

Scene.find()

find( (Scene)arg1, (int)arg2) -> Shape :

C++ signature :

TOOLS::RefCountPtr<PGL::Shape> find(PGL::Scene*,unsigned long)

Scene.findSceneObject()

findSceneObject( (Scene)arg1, (int)arg2) -> Shape3D :

C++ signature :

TOOLS::RefCountPtr<PGL::Shape3D> findSceneObject(PGL::Scene*,unsigned long)

Scene.getId()

getId( (Scene)arg1) -> int :

C++ signature :

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

Scene.getPglReferenceCount()

getPglReferenceCount( (Scene)arg1) -> int :

C++ signature :

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

Scene.index()

index( (Scene)arg1, (Shape3D)arg2) -> int :

C++ signature :

unsigned int index(PGL::Scene*,TOOLS::RefCountPtr<PGL::Shape3D>)

Scene.isValid()

isValid( (Scene)arg1) -> bool :

C++ signature :

bool isValid(PGL::Scene {lvalue})

Scene.merge()

merge( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :

void merge(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)

merge( (Scene)arg1, (Scene)arg2) -> None :

C++ signature :

void merge(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)

Scene.pool()

pool() -> Pool :

Scene pool singleton access

C++ signature :

PGL::Scene::Pool {lvalue} pool()

Scene.read()

read( (Scene)arg1, (str)arg2) -> None :

C++ signature :

void read(PGL::Scene*,std::string)

read( (Scene)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :

void read(PGL::Scene*,std::string,std::string)

Scene.remove()

remove( (Scene)arg1, (Shape3D)arg2) -> None :

C++ signature :

void remove(PGL::Scene*,TOOLS::RefCountPtr<PGL::Shape3D>)

Scene.save()

save( (Scene)arg1, (str)arg2) -> None :

C++ signature :

void save(PGL::Scene*,std::string)

save( (Scene)arg1, (str)arg2, (str)arg3) -> None :

C++ signature :

void save(PGL::Scene*,std::string,std::string)

Scene.sort()

sort( (Scene)arg1) -> None :

C++ signature :

void sort(PGL::Scene {lvalue})

class SceneCodec

Coder/Decoder of a scene description.

__init__( (object)arg1 [, (str)name [, (Mode)mode]]) -> None :

SceneCodec([name,mode])

C++ signature :

void __init__(_object* [,std::string [,PGL::SceneCodec::Mode]])

class Mode

Enum representing coding and decoding capabilities of a codec.

SceneCodec.formats()

formats( (SceneCodec)arg1) -> SceneFormatList :

C++ signature :

std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > formats(PGL::SceneCodec {lvalue})

formats( (SceneCodec)arg1) -> None :

C++ signature :

void formats(TOOLS::RefCountPtr<PySceneCodec> {lvalue})

SceneCodec.mode

SceneCodec.name

SceneCodec.read()

read( (SceneCodec)arg1, (str)arg2) -> Scene :

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> read(PGL::SceneCodec {lvalue},std::string)

read( (SceneCodec)arg1, (str)arg2) -> Scene :

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> read(PySceneCodec {lvalue},std::string)

SceneCodec.test()

test( (SceneCodec)arg1, (str)arg2, (Mode)arg3) -> bool :

C++ signature :

bool test(PGL::SceneCodec {lvalue},std::string,PGL::SceneCodec::Mode)

test( (SceneCodec)arg1, (str)arg2, (Mode)arg3) -> bool :

C++ signature :

bool test(PySceneCodec {lvalue},std::string,PGL::SceneCodec::Mode)

SceneCodec.write()

write( (SceneCodec)arg1, (str)arg2, (Scene)arg3) -> None :

C++ signature :

void write(PGL::SceneCodec {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>)

write( (SceneCodec)arg1, (str)arg2, (Scene)arg3) -> None :

C++ signature :

void write(PySceneCodec {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>)

class SceneFactory

A factory of Scene that register and use SceneCodec to read scene from files.

Raises an exception This class cannot be instantiated from Python

formats()

formats( (SceneFactory)arg1, (Mode)arg2) -> SceneFormatList :

C++ signature :

std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > formats(PGL::SceneFactory {lvalue},PGL::SceneCodec::Mode)

formats( (SceneFactory)arg1) -> SceneFormatList :

C++ signature :

std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > formats(PGL::SceneFactory*)

get()

get() -> SceneFactory :

C++ signature :

PGL::SceneFactory {lvalue} get()

isReadable()

isReadable( (SceneFactory)arg1, (str)arg2) -> bool :

C++ signature :

bool isReadable(PGL::SceneFactory {lvalue},std::string)

isWritable()

isWritable( (SceneFactory)arg1, (str)arg2) -> bool :

C++ signature :

bool isWritable(PGL::SceneFactory {lvalue},std::string)

read()

read( (SceneFactory)arg1, (str)arg2) -> Scene :

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> read(PGL::SceneFactory {lvalue},std::string)

read( (SceneFactory)arg1, (str)arg2, (str)arg3) -> Scene :

C++ signature :

TOOLS::RefCountPtr<PGL::Scene> read(PGL::SceneFactory {lvalue},std::string,std::string)

registerCodec()

registerCodec( (SceneFactory)arg1, (SceneCodec)arg2) -> None :

C++ signature :

void registerCodec(PGL::SceneFactory {lvalue},TOOLS::RefCountPtr<PGL::SceneCodec>)

unregisterCodec()

unregisterCodec( (SceneFactory)arg1, (SceneCodec)arg2) -> None :

C++ signature :

void unregisterCodec(PGL::SceneFactory {lvalue},TOOLS::RefCountPtr<PGL::SceneCodec>)

write()

write( (SceneFactory)arg1, (str)arg2, (Scene)arg3) -> None :

C++ signature :

void write(PGL::SceneFactory {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>)

write( (SceneFactory)arg1, (str)arg2, (Scene)arg3, (str)arg4) -> None :

C++ signature :

void write(PGL::SceneFactory {lvalue},std::string,TOOLS::RefCountPtr<PGL::Scene>,std::string)

class SceneFormat

A scene description format.

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

C++ signature :

void* __init__(boost::python::api::object,std::string,boost::python::list,std::string)

comment

name

suffixes

class SceneFormatList

A list of scene description format.

__init__( (object)arg1) -> None :

C++ signature :

void __init__(_object*)

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

C++ signature :

void* __init__(boost::python::api::object,boost::python::list)

append()

append( (SceneFormatList)arg1, (object)arg2) -> None :

C++ signature :

void append(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)

extend()

extend( (SceneFormatList)arg1, (object)arg2) -> None :

C++ signature :

void extend(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)

class SceneObject

Abstract base class for all objects of the scenegraph. It is named, has unique id and support reference counting. It can support Action application.

Raises an exception This class cannot be instantiated from Python

apply()

apply( (SceneObject)arg1, (Action)arg2) -> bool :

C++ signature :

bool apply(PGL::SceneObject {lvalue},PGL::Action {lvalue})

getId()

getId( (SceneObject)arg1) -> int :

C++ signature :

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

getName()

getName( (SceneObject)arg1) -> str :

C++ signature :

std::string getName(PGL::SceneObject {lvalue})

getPglReferenceCount()

getPglReferenceCount( (SceneObject)arg1) -> int :

C++ signature :

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

isNamed()

isNamed( (SceneObject)arg1) -> bool :

C++ signature :

bool isNamed(PGL::SceneObject {lvalue})

isValid()

isValid( (SceneObject)arg1) -> bool :

C++ signature :

bool isValid(PGL::SceneObject {lvalue})

name

setName()

setName( (SceneObject)arg1, (str)arg2) -> None :

C++ signature :

void setName(PGL::SceneObject {lvalue},std::string)

class Shape

A Shape is composed of a Geometry object and an Appearance object. There is an optional id to identy the shape and parent id to store shape relationship.

__init__( (object)arg1 [, (Geometry)geometry=None [, (Appearance)appearance=Material(name=’DEFAULT_MATERIAL’,) [, (int)id=4294967295 [, (int)parentId=4294967295]]]]) -> None :

Shape( geometry, appearance, id, parentId )

C++ signature :

void __init__(_object* [,TOOLS::RefCountPtr<PGL::Geometry>=None [,TOOLS::RefCountPtr<PGL::Appearance>=Material(name=’DEFAULT_MATERIAL’,) [,unsigned int=4294967295 [,unsigned int=4294967295]]]])

__init__( (object)arg1 [, (Geometry)geometry [, (ImageTexture)appearance [, (int)id=4294967295 [, (int)parentId=4294967295]]]]) -> None :

Shape( geometry, appearance, id, parentId )

C++ signature :

void __init__(_object* [,TOOLS::RefCountPtr<PGL::Geometry> [,TOOLS::RefCountPtr<PGL::ImageTexture> [,unsigned int=4294967295 [,unsigned int=4294967295]]]])

appearance

deepcopy()

deepcopy( (Shape)arg1) -> Shape :

C++ signature :

TOOLS::RefCountPtr<PGL::Shape> deepcopy(PGL::Shape {lvalue})

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

C++ signature :

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

geometry

getSceneObjectId()

getSceneObjectId( (Shape)arg1) -> int :

C++ signature :

unsigned int getSceneObjectId(PGL::Shape const*)

id

parentId

recast()

recast( (Shape)arg1) -> Shape :

C++ signature :

TOOLS::RefCountPtr<PGL::Shape> recast(PGL::Shape*)

setComputedName()

setComputedName( (Shape)arg1) -> None :

C++ signature :

void setComputedName(PGL::Shape {lvalue})

class Shape3D

Abstract base class for shape that can be stored into a scene.

Raises an exception This class cannot be instantiated from Python

class Spectrum

Abstract base class for all spectrum objects.

Raises an exception This class cannot be instantiated from Python

class Sphere

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

Sphere(radius [,slices, stacks])

C++ signature :

void __init__(_object* [,double=0.5 [,unsigned char=8 [,unsigned char=8]]])

deepcopy()

deepcopy( (Sphere)arg1) -> Sphere :

C++ signature :

TOOLS::RefCountPtr<PGL::Sphere> deepcopy(PGL::Sphere {lvalue})

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

C++ signature :

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

isRadiusToDefault()

isRadiusToDefault( (Sphere)arg1) -> bool :

C++ signature :

bool isRadiusToDefault(PGL::Sphere {lvalue})

isStacksToDefault()

isStacksToDefault( (Sphere)arg1) -> bool :

C++ signature :

bool isStacksToDefault(PGL::Sphere {lvalue})

radius

recast()

recast( (Sphere)arg1) -> Sphere :

C++ signature :

TOOLS::RefCountPtr<PGL::Sphere> recast(PGL::Sphere*)

stacks

class Swung

A surface defined by the revolution and interpolation of several 2D profiles along Z axis.

__init__( (object)arg1, (Curve2DArray)profileList, (RealArray)angleList [, (int)slices=8 [, (bool)ccw=True [, (int)degree=3 [, (int)stride=0]]]]) -> None :

Swung(profileList,angleList,slices,ccw,degree,stride)

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::Curve2DArray>,TOOLS::RefCountPtr<TOOLS::RealArray> [,unsigned char=8 [,bool=True [,unsigned int=3 [,unsigned int=0]]]])

angleList

ccw

deepcopy()

deepcopy( (Swung)arg1) -> Swung :

C++ signature :

TOOLS::RefCountPtr<PGL::Swung> deepcopy(PGL::Swung {lvalue})

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

C++ signature :

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

degree

interpolator

isCCWToDefault()

isCCWToDefault( (Swung)arg1) -> bool :

C++ signature :

bool isCCWToDefault(PGL::Swung {lvalue})

isDegreeToDefault()

isDegreeToDefault( (Swung)arg1) -> bool :

C++ signature :

bool isDegreeToDefault(PGL::Swung {lvalue})

isStrideToDefault()

isStrideToDefault( (Swung)arg1) -> bool :

C++ signature :

bool isStrideToDefault(PGL::Swung {lvalue})

profileList

recast()

recast( (Swung)arg1) -> Swung :

C++ signature :

TOOLS::RefCountPtr<PGL::Swung> recast(PGL::Swung*)

stride

class Taper

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

C++ signature :

void __init__(_object*,double,double)

getBaseRadius()

getBaseRadius( (Taper)arg1) -> float :

C++ signature :

double getBaseRadius(PGL::Taper {lvalue})

getTopRadius()

getTopRadius( (Taper)arg1) -> float :

C++ signature :

double getTopRadius(PGL::Taper {lvalue})

class Tapered

Tapered describes an object to which it has been applied a Taper deformation. A Taper deforms an object in order to be able to bound the object within a cone frustum of a specified base radius and top radius. For each point composing an object, a Taper scale the polar coordinates according the zcoordinate. The amplitude of the scale is given by the radii.

__init__( (object)arg1 [, (float)baseRadius=0.5 [, (float)topRadius=0.5 [, (Primitive)primitive=None]]]) -> None :

Tapered(baseRadius, topRadius, primitive)

C++ signature :

void __init__(_object* [,double=0.5 [,double=0.5 [,TOOLS::RefCountPtr<PGL::Primitive>=None]]])

baseRadius

deepcopy()

deepcopy( (Tapered)arg1) -> Tapered :

C++ signature :

TOOLS::RefCountPtr<PGL::Tapered> deepcopy(PGL::Tapered {lvalue})

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

C++ signature :

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

isBaseRadiusToDefault()

isBaseRadiusToDefault( (Tapered)arg1) -> bool :

C++ signature :

bool isBaseRadiusToDefault(PGL::Tapered {lvalue})

isTopRadiusToDefault()

isTopRadiusToDefault( (Tapered)arg1) -> bool :

C++ signature :

bool isTopRadiusToDefault(PGL::Tapered {lvalue})

primitive

recast()

recast( (Tapered)arg1) -> Tapered :

C++ signature :

TOOLS::RefCountPtr<PGL::Tapered> recast(PGL::Tapered*)

topRadius

class Text

Text with font. It support display in screen or world coordinates.

__init__( (object)arg1, (str)string [, (Vector3)position=Vector3(0,0,0) [, (bool)screencoordinates=False [, (Font)fontstyle=None]]]) -> None :

Text(str string[, Vector3 position, bool screencoordinates, Font fontstyle])

C++ signature :

void __init__(_object*,std::string [,TOOLS::Vector3=Vector3(0,0,0) [,bool=False [,TOOLS::RefCountPtr<PGL::Font>=None]]])

deepcopy()

deepcopy( (Text)arg1) -> Text :

C++ signature :

TOOLS::RefCountPtr<PGL::Text> deepcopy(PGL::Text {lvalue})

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

C++ signature :

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

fontstyle

isFontStyleToDefault()

isFontStyleToDefault( (Text)arg1) -> bool :

C++ signature :

bool isFontStyleToDefault(PGL::Text {lvalue})

isPositionToDefault()

isPositionToDefault( (Text)arg1) -> bool :

C++ signature :

bool isPositionToDefault(PGL::Text {lvalue})

isScreenCoordinatesToDefault()

isScreenCoordinatesToDefault( (Text)arg1) -> bool :

C++ signature :

bool isScreenCoordinatesToDefault(PGL::Text {lvalue})

position

recast()

recast( (Text)arg1) -> Text :

C++ signature :

TOOLS::RefCountPtr<PGL::Text> recast(PGL::Text*)

screencoordinates

string

class Texture2D

The material of a textured object.

__init__( (object)arg1, (ImageTexture)image [, (Texture2DTransformation)transformation]) -> None :

Texture2D(image [,transformation])

C++ signature :

void __init__(_object*,TOOLS::RefCountPtr<PGL::ImageTexture> [,TOOLS::RefCountPtr<PGL::Texture2DTransformation>])

__init__( (object)arg1, (str)name, (ImageTexture)image [, (Texture2DTransformation)transformation]) -> None :

Texture2D(name, image [,transformation])

C++ signature :

void __init__(_object*,std::string,TOOLS::RefCountPtr<PGL::ImageTexture> [,TOOLS::RefCountPtr<PGL::Texture2DTransformation>])

image

isTransformationToDefault()

isTransformationToDefault( (Texture2D)arg1) -> bool :

C++ signature :

bool isTransformationToDefault(PGL::Texture2D {lvalue})

transformation

class Texture2DTransformation

The transformation of a texture 2D.

__init__( (object)arg1 [, (str)name [, (Vector2)scale=Vector2(1,1) [, (Vector2)translation=Vector2(0,0) [, (Vector2)rotationCenter=Vector2(0.5,0.5) [, (float)rotationAngle=0.0]]]]]) -> None :

Texture2D([name,scale,translation,rotationCenter,rotationAngle])

C++ signature :

void __init__(_object* [,std::string [,TOOLS::Vector2=Vector2(1,1) [,TOOLS::Vector2=Vector2(0,0) [,TOOLS::Vector2=Vector2(0.5,0.5) [,double=0.0]]]]])

isRotationAngleToDefault()

isRotationAngleToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :

bool isRotationAngleToDefault(PGL::Texture2DTransformation {lvalue})

isRotationCenterToDefault()

isRotationCenterToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :

bool isRotationCenterToDefault(PGL::Texture2DTransformation {lvalue})

isScaleToDefault()

isScaleToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :

bool isScaleToDefault(PGL::Texture2DTransformation {lvalue})

isTranslationToDefault()

isTranslationToDefault( (Texture2DTransformation)arg1) -> bool :

C++ signature :

bool isTranslationToDefault(PGL::Texture2DTransformation {lvalue})

rotationAngle

rotationCenter

scale

transform()

transform( (Texture2DTransformation)arg1, (Point3Array)points3) -> Point3Array :

C++ signature :

TOOLS::RefCountPtr<PGL::Point3Array> transform(PGL::Texture2DTransformation {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)

transform( (Texture2DTransformation)arg1, (Point2Array)points2) -> Point2Array :

C++ signature :

TOOLS::RefCountPtr<PGL::Point2Array> transform(PGL::Texture2DTransformation {lvalue},TOOLS::RefCountPtr<PGL::Point2Array>)

transform( (Texture2DTransformation)arg1, (Vector2)point) -> Vector2 :

C++ signature :

TOOLS::Vector2 transform(PGL::Texture2DTransformation {lvalue},TOOLS::Vector2)

translation

class Transform4

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

C++ signature :

void __init__(_object*,TOOLS::Matrix4)

__init__( (object)arg1) -> object :

C++ signature :

void* __init__(boost::python::api::object)

getTransformation()

getTransformation( (Transform4)arg1) -> tuple :

Return scale, rotate and translate corresponding values.

C++ signature :

boost::python::tuple getTransformation(PGL::Transform4*)

getVolume()

getVolume( (Transform4)arg1) -> float :

compute the Matrix3 determinant of the transformation

C++ signature :

double getVolume(PGL::Transform4 {lvalue})

isValid()

isValid( (Transform4)arg1) -> bool :

C++ signature :

bool isValid(PGL::Transform4 {lvalue})

rotate()

rotate( (Transform4)arg1, (Matrix3)arg2) -> None :

Add a rotation at the transformation

C++ signature :

void rotate(PGL::Transform4 {lvalue},TOOLS::Matrix3)

scale()

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

Add a scaling at the transformation

C++ signature :

void scale(PGL::Transform4 {lvalue},TOOLS::Vector3)

transform()

transform( (Transform4)arg1, (Point3Array)arg2) -> Point3Array :

transform a set of points

C++ signature :

TOOLS::RefCountPtr<PGL::Point3Array> transform(PGL::Transform4*,TOOLS::RefCountPtr<PGL::Point3Array>)

translate()

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

Add a translation at the transformation

C++ signature :

void translate(PGL::Transform4 {lvalue},TOOLS::Vector3)

class Transform4Array

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

Transform4Array(int size)

C++ signature :

void __init__(_object*,unsigned long)

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

Transform4Array([Transform4(...),...])

C++ signature :

void* __init__(boost::python::api::object,boost::python::api::object)

append()

append( (Transform4Array)arg1, (Transform4)arg2) -> None :

C++ signature :

void append(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,TOOLS::RefCountPtr<PGL::Transform4>)

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

C++ signature :

void append(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)

clear()

clear( (Transform4Array)arg1) -> None :

C++ signature :

void clear(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})

getId()

getId( (Transform4Array)arg1) -> int :

C++ signature :

unsigned long getId(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)

getPglId()

getPglId( (Transform4Array)arg1) -> int :

C++ signature :

unsigned long getPglId(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})

getPglReferenceCount()

getPglReferenceCount( (Transform4Array)arg1) -> int :

C++ signature :

unsigned long getPglReferenceCount(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})

insert()

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

C++ signature :

void insert(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,int,TOOLS::RefCountPtr<PGL::Transform4>)

pop()

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

C++ signature :

TOOLS::RefCountPtr<PGL::Transform4> pop(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >* [,int])

prepend()

prepend( (Transform4Array)arg1, (Transform4)arg2) -> None :

C++ signature :

void prepend(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,TOOLS::RefCountPtr<PGL::Transform4>)

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

C++ signature :

void prepend(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)

reverse()

reverse( (Transform4Array)arg1) -> None :

C++ signature :

void reverse(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})

class Transformation

Raises an exception This class cannot be instantiated from Python

class Transformation2D

Raises an exception This class cannot be instantiated from Python

transform()

transform( (Transformation2D)arg1, (Point2Array)arg2) -> Point2Array :

C++ signature :

TOOLS::RefCountPtr<PGL::Point2Array> transform(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point2Array>)

transformP2Matrix()

transformP2Matrix( (Transformation2D)arg1, (Point2Matrix)arg2) -> Point2Matrix :

C++ signature :

TOOLS::RefCountPtr<PGL::Point2Matrix> transformP2Matrix(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point2Matrix>)

transformP3List()

transformP3List( (Transformation2D)arg1, (Point3Array)arg2) -> Point3Array :

C++ signature :

TOOLS::RefCountPtr<PGL::Point3Array> transformP3List(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)

transformP3Matrix()

transformP3Matrix( (Transformation2D)arg1, (Point3Matrix)arg2) -> Point3Matrix :

C++ signature :

TOOLS::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point3Matrix>)

class Transformation3D

Raises an exception This class cannot be instantiated from Python

transform()

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

C++ signature :

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

transformP3Matrix()

transformP3Matrix( (Transformation3D)arg1, (Point3Matrix)arg2) -> Point3Matrix :

C++ signature :

TOOLS::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point3Matrix>)

transformP4List()

transformP4List( (Transformation3D)arg1, (Point4Array)arg2) -> Point4Array :

C++ signature :

TOOLS::RefCountPtr<PGL::Point4Array> transformP4List(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point4Array>)

transformP4Matrix()

transformP4Matrix( (Transformation3D)arg1, (Point4Matrix)arg2) -> Point4Matrix :

C++ signature :

TOOLS::RefCountPtr<PGL::Point4Matrix> transformP4Matrix(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point4Matrix>)

class Transformed

Abstract base class for trasnformed node. It suppose to contain object on which the transformation is applied.

Raises an exception This class cannot be instantiated from Python

transformation()

transformation( (Transformed)arg1) -> Transformation3D :

C++ signature :

TOOLS::RefCountPtr<PGL::Transformation3D> transformation(PGL::Transformed {lvalue})

class Translated

A Translated describes an object to which a translation of a specified vector is applied. The translation is given by the homogeneous matrix: |1 0 0 tx| |0 1 0 ty| |0 0 1 tz| |0 0 0 1 | where (tx, ty, tz) denotes the translation vector.

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

Translated(translation,geometry)

C++ signature :

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

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

C++ signature :

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

deepcopy()

deepcopy( (Translated)arg1) -> Translated :

C++ signature :

TOOLS::RefCountPtr<PGL::Translated> deepcopy(PGL::Translated {lvalue})

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

C++ signature :

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

isTranslationToDefault()

isTranslationToDefault( (Translated)arg1) -> bool :

C++ signature :

bool isTranslationToDefault(PGL::Translated {lvalue})

recast()

recast( (Translated)arg1) -> Translated :

C++ signature :

TOOLS::RefCountPtr<PGL::Translated> recast(PGL::Translated*)

translation

class Translation

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

C++ signature :

void __init__(_object*,TOOLS::Vector3)

class TriangleSet

A TriangleSet describes a surface formed by a set of connected triangles, i.e. three sided polygons. Triangles are specified using set of tuples of 3 indices (Index3) pointing to a list of points.

__init__( (object)arg1 [, (Point3Array)pointList=None [, (Index3Array)indexList=None [, (Point3Array)normalList=None [, (Index3Array)normalIndexList=None [, (Color4Array)colorList=None [, (Index3Array)colorIndexList=None [, (Point2Array)texCoordList=None [, (Index3Array)texCoordIndexList=None [, (bool)normalPerVertex=True [, (bool)colorPerVertex=True [, (bool)ccw=True [, (bool)solid=False [, (Polyline)skeleton=None]]]]]]]]]]]]]) -> None :

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

C++ signature :

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

colorAt()

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

C++ signature :

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

colorIndexAt()

colorIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :

TOOLS::Tuple3<unsigned int> colorIndexAt(PGL::TriangleSet {lvalue},unsigned int)

colorIndexList

deepcopy()

deepcopy( (TriangleSet)arg1) -> TriangleSet :

C++ signature :

TOOLS::RefCountPtr<PGL::TriangleSet> deepcopy(PGL::TriangleSet {lvalue})

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

C++ signature :

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

faceColorAt()

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

C++ signature :

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

faceNormalAt()

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

C++ signature :

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

faceTexCoordAt()

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

C++ signature :

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

indexAt()

indexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :

TOOLS::Tuple3<unsigned int> indexAt(PGL::TriangleSet {lvalue},unsigned int)

indexList

isColorIndexListToDefault()

isColorIndexListToDefault( (TriangleSet)arg1) -> bool :

C++ signature :

bool isColorIndexListToDefault(PGL::TriangleSet {lvalue})

isNormalIndexListToDefault()

isNormalIndexListToDefault( (TriangleSet)arg1) -> bool :

C++ signature :

bool isNormalIndexListToDefault(PGL::TriangleSet {lvalue})

isTexCoordIndexListToDefault()

isTexCoordIndexListToDefault( (TriangleSet)arg1) -> bool :

C++ signature :

bool isTexCoordIndexListToDefault(PGL::TriangleSet {lvalue})

normalAt()

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

C++ signature :

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

normalIndexAt()

normalIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :

TOOLS::Tuple3<unsigned int> normalIndexAt(PGL::TriangleSet {lvalue},unsigned int)

normalIndexList

recast()

recast( (TriangleSet)arg1) -> TriangleSet :

C++ signature :

TOOLS::RefCountPtr<PGL::TriangleSet> recast(PGL::TriangleSet*)

texCoordAt()

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

C++ signature :

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

texCoordIndexAt()

texCoordIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :

C++ signature :

TOOLS::Tuple3<unsigned int> texCoordIndexAt(PGL::TriangleSet {lvalue},unsigned int)

texCoordIndexList

closestPointToSegment()

closestPointToSegment( (Vector3)point, (Vector3)segA, (Vector3)segB) -> object :

C++ signature :

boost::python::api::object closestPointToSegment(TOOLS::Vector3,TOOLS::Vector3,TOOLS::Vector3)

closestPointToSegment( (Vector2)point, (Vector2)segA, (Vector2)segB) -> object :

C++ signature :

boost::python::api::object closestPointToSegment(TOOLS::Vector2,TOOLS::Vector2,TOOLS::Vector2)

getPGLVersion()

getPGLVersion() -> float :

C++ signature :

float getPGLVersion()

get_pgl_python_error_style()

get_pgl_python_error_style() -> bool :

C++ signature :

bool get_pgl_python_error_style()

get_pgl_supported_extensions()

get_pgl_supported_extensions() -> object :

Gives all extensions supported by current version of PlantGL.

C++ signature :

boost::python::api::object get_pgl_supported_extensions()

pgl_support_extension()

pgl_support_extension( (str)ext) -> bool :

Tell wether PlantGL support a given extension

C++ signature :

bool pgl_support_extension(std::string)

set_pgl_python_error_style()

set_pgl_python_error_style( (bool)arg1) -> None :

C++ signature :

void set_pgl_python_error_style(bool)

2.3. openalea.plantgl.scenegraph.cspline module

Class Cardinal Spline. A cardinal spline is a spline passing through a set of points.

class CSpline(points, is_closed=False)

A CSpline interpolate a set of points.

Create a CSpline from a set of 2d or 3d points.

add_point(pt)

bezier_cp()

Compute bezier control points from the input points.

bezier_kv(is_linear=False)

Compute a nurbs knot vector from Bezier control points. bezier_kv(linear=False) -> knot_vector

Param :is_linear indicate if the parametrization is linear or

pseudo curvilinear abscisse.

curve(is_linear=False, stride_factor=10, distances=None)

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)

cspline(pts, is_closed=False, is_linear=False, distances=None)

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

norm()

norm( (object)v) -> object :

The norm of the vector. If v.__norm__() exists, call it.

C++ signature :

boost::python::api::object norm(boost::python::api::object)

norm( (float)arg1, (float)arg2 [, (float)arg3 [, (float)arg4 [, (float)arg5 [, (float)arg6 [, (float)arg7 [, (float)arg8 [, (float)arg9 [, (float)arg10 [, (float)arg11 [, (float)arg12 [, (float)arg13 [, (float)arg14 [, (float)arg15]]]]]]]]]]]]]) -> float :

C++ signature :

double norm(double,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double [,double]]]]]]]]]]]]])

2.4. openalea.plantgl.scenegraph.nurbspatch_nd module

class NurbsPatch3D(points, udeg=3, vdeg=3, wdeg=3, uknots=None, vknots=None, wknots=None, ustride=30, vstride=30, wstride=30)

getParametrization(p)

return (u,v,t)

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)

isValid()

Test whether self is valid or not