Contents
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: |
|
---|---|
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')
![]() ![]() |
AmapSymbol(filename)
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})
readFile( (AmapSymbol)arg1, (str)arg2) -> bool :
- C++ signature :
- bool readFile(PGL::AmapSymbol {lvalue},std::string)
recast( (AmapSymbol)arg1) -> AmapSymbol :
- C++ signature :
- TOOLS::RefCountPtr<PGL::AmapSymbol> recast(PGL::AmapSymbol*)
Abstract base class for all appearance objects.
Raises an exception This class cannot be instantiated from Python
Tell wether self is of type texture
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.
AsymmetricHull([negXRadius,posXRadius,negYRadius,posYRadius,negXHeight,posXHeight,negYHeight,posYHeight,bottom, top, bottomShape, topShape, slices, stacks])
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( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isBottomShapeToDefault(PGL::AsymmetricHull {lvalue})
isBottomToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isBottomToDefault(PGL::AsymmetricHull {lvalue})
isNegXHeightToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isNegXHeightToDefault(PGL::AsymmetricHull {lvalue})
isNegXRadiusToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isNegXRadiusToDefault(PGL::AsymmetricHull {lvalue})
isNegYHeightToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isNegYHeightToDefault(PGL::AsymmetricHull {lvalue})
isNegYRadiusToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isNegYRadiusToDefault(PGL::AsymmetricHull {lvalue})
isPosXHeightToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isPosXHeightToDefault(PGL::AsymmetricHull {lvalue})
isPosXRadiusToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isPosXRadiusToDefault(PGL::AsymmetricHull {lvalue})
isPosYHeightToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isPosYHeightToDefault(PGL::AsymmetricHull {lvalue})
isPosYRadiusToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isPosYRadiusToDefault(PGL::AsymmetricHull {lvalue})
isSlicesToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isSlicesToDefault(PGL::AsymmetricHull {lvalue})
isStacksToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isStacksToDefault(PGL::AsymmetricHull {lvalue})
isTopShapeToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isTopShapeToDefault(PGL::AsymmetricHull {lvalue})
isTopToDefault( (AsymmetricHull)arg1) -> bool :
- C++ signature :
- bool isTopToDefault(PGL::AsymmetricHull {lvalue})
recast( (AsymmetricHull)arg1) -> AsymmetricHull :
- C++ signature :
- TOOLS::RefCountPtr<PGL::AsymmetricHull> recast(PGL::AsymmetricHull*)
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.
AxisRotated( Vector3 axis, radian angle, geometry)
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( (AxisRotated)arg1) -> bool :
- C++ signature :
- bool isAngleToDefault(PGL::AxisRotated {lvalue})
isAxisToDefault( (AxisRotated)arg1) -> bool :
- C++ signature :
- bool isAxisToDefault(PGL::AxisRotated {lvalue})
recast( (AxisRotated)arg1) -> AxisRotated :
- C++ signature :
- TOOLS::RefCountPtr<PGL::AxisRotated> recast(PGL::AxisRotated*)
__init__( (object)arg1, (Vector3)arg2, (float)arg3) -> None :
- C++ signature :
- void __init__(_object*,TOOLS::Vector3,double)
__init__( (object)arg1, (Vector3)arg2, (Vector3)arg3) -> None :
- C++ signature :
- void __init__(_object*,TOOLS::Vector3,TOOLS::Vector3)
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]])
Create a BezierCurve from a list of 3d points.
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.
[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.
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( (BezierCurve)arg1) -> bool :
- C++ signature :
- bool isStrideToDefault(PGL::BezierCurve {lvalue})
recast( (BezierCurve)arg1) -> BezierCurve :
- C++ signature :
- TOOLS::RefCountPtr<PGL::BezierCurve> recast(PGL::BezierCurve*)
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]])
Create a BezierCurve from a list of 3d points.
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( (BezierCurve2D)arg1) -> bool :
- C++ signature :
- bool isStrideToDefault(PGL::BezierCurve2D {lvalue})
recast( (BezierCurve2D)arg1) -> BezierCurve2D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::BezierCurve2D> recast(PGL::BezierCurve2D*)
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.
BezierPatch(Point4Matrix ctrlPointList [,ustride,vstride,ccw])
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( (BezierPatch)arg1, (float)arg2, (float)arg3) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getPointAt(PGL::BezierPatch {lvalue},double,double)
Compute a section line of the patch corresponding to a constant u value.
Compute a section line of the patch corresponding to a constant v value.
isUStrideToDefault( (BezierPatch)arg1) -> bool :
- C++ signature :
- bool isUStrideToDefault(PGL::BezierPatch {lvalue})
isVStrideToDefault( (BezierPatch)arg1) -> bool :
- C++ signature :
- bool isVStrideToDefault(PGL::BezierPatch {lvalue})
recast( (BezierPatch)arg1) -> BezierPatch :
- C++ signature :
- TOOLS::RefCountPtr<PGL::BezierPatch> recast(PGL::BezierPatch*)
An axis aligned box represented by 2 opposite corners.
BoundingBox(Vector3 lowerLeft, Vector3 upperRight) Constructs a BoundingBox with the 2 opposing corners lowerLeft and upperRight.
BoundingBox(geometry|scene) Constructs a BoundingBox from some geometries.
change(center)
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( (BoundingBox)arg1) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getCenter(PGL::BoundingBox {lvalue})
getId( (BoundingBox)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::BoundingBox {lvalue})
size of the half diagonal of self along the x-axis, y-axis and z-axis.
getXMax( (BoundingBox)arg1) -> float :
- C++ signature :
- double getXMax(PGL::BoundingBox {lvalue})
getXMin( (BoundingBox)arg1) -> float :
- C++ signature :
- double getXMin(PGL::BoundingBox {lvalue})
getXRange( (BoundingBox)arg1) -> float :
- C++ signature :
- double getXRange(PGL::BoundingBox {lvalue})
getYMax( (BoundingBox)arg1) -> float :
- C++ signature :
- double getYMax(PGL::BoundingBox {lvalue})
getYMin( (BoundingBox)arg1) -> float :
- C++ signature :
- double getYMin(PGL::BoundingBox {lvalue})
getYRange( (BoundingBox)arg1) -> float :
- C++ signature :
- double getYRange(PGL::BoundingBox {lvalue})
getZMax( (BoundingBox)arg1) -> float :
- C++ signature :
- double getZMax(PGL::BoundingBox {lvalue})
getZMin( (BoundingBox)arg1) -> float :
- C++ signature :
- double getZMin(PGL::BoundingBox {lvalue})
getZRange( (BoundingBox)arg1) -> float :
- C++ signature :
- double getZRange(PGL::BoundingBox {lvalue})
scale( (BoundingBox)arg1, (Vector3)arg2) -> None :
- C++ signature :
- void scale(PGL::BoundingBox {lvalue},TOOLS::Vector3)
set(lowerLeft,upperRight)
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( (BoundingBox)arg1, (Vector3)arg2) -> None :
- C++ signature :
- void translate(PGL::BoundingBox {lvalue},TOOLS::Vector3)
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.
Box(Vector3(x,y,z))
__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( (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( (Box)arg1) -> bool :
- C++ signature :
- bool isSizeToDefault(PGL::Box {lvalue})
recast( (Box)arg1) -> Box :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Box> recast(PGL::Box*)
A 3 components color expressed in red, green and blue.
__init__( (object)arg1, (Color3)other) -> None :
- C++ signature :
- void __init__(_object*,PGL::Color3)
Color3(red,green,blue)
__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)
clampedBlue( (Color3)arg1) -> float :
- C++ signature :
- double clampedBlue(PGL::Color3*)
clampedGreen( (Color3)arg1) -> float :
- C++ signature :
- double clampedGreen(PGL::Color3*)
clampedRed( (Color3)arg1) -> float :
- C++ signature :
- double clampedRed(PGL::Color3*)
fromUint( (int)arg1) -> Color3 :
- C++ signature :
- PGL::Color3 fromUint(unsigned int)
getAverage( (Color3)arg1) -> float :
- C++ signature :
- double getAverage(PGL::Color3 {lvalue})
getAverageClamped( (Color3)arg1) -> float :
- C++ signature :
- double getAverageClamped(PGL::Color3 {lvalue})
setClampedBlue( (Color3)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedBlue(PGL::Color3*,double)
setClampedGreen( (Color3)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedGreen(PGL::Color3*,double)
setClampedRed( (Color3)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedRed(PGL::Color3*,double)
toUint( (Color3)arg1) -> int :
- C++ signature :
- unsigned int toUint(PGL::Color3 {lvalue})
Color3Array(int size)
Color3Array([Index3(i,j,k),...])
append( (Color3Array)arg1, (Color3)arg2) -> None :
- C++ signature :
- void append(PGL::Color3Array*,PGL::Color3)
append( (Color3Array)arg1, (Color3Array)arg2) -> None :
- C++ signature :
- void append(PGL::Color3Array*,PGL::Color3Array*)
clear( (Color3Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Color3Array {lvalue})
getId( (Color3Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Color3Array*)
getPglId( (Color3Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Color3Array {lvalue})
getPglReferenceCount( (Color3Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Color3Array {lvalue})
insert( (Color3Array)arg1, (int)arg2, (Color3)arg3) -> None :
- C++ signature :
- void insert(PGL::Color3Array*,int,PGL::Color3)
pop( (Color3Array)arg1 [, (int)arg2]) -> Color3 :
- C++ signature :
- PGL::Color3 pop(PGL::Color3Array* [,int])
prepend( (Color3Array)arg1, (Color3)arg2) -> None :
- C++ signature :
- void prepend(PGL::Color3Array*,PGL::Color3)
prepend( (Color3Array)arg1, (Color3Array)arg2) -> None :
- C++ signature :
- void prepend(PGL::Color3Array*,PGL::Color3Array*)
reverse( (Color3Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Color3Array {lvalue})
A 4 component color expressed in red, green, blue and alpha.
__init__( (object)arg1, (Color4)other) -> None :
- C++ signature :
- void __init__(_object*,PGL::Color4)
Color4(red,green,blue,alpha)
__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]])
clampedAlpha( (Color4)arg1) -> float :
- C++ signature :
- double clampedAlpha(PGL::Color4*)
clampedBlue( (Color4)arg1) -> float :
- C++ signature :
- double clampedBlue(PGL::Color4*)
clampedGreen( (Color4)arg1) -> float :
- C++ signature :
- double clampedGreen(PGL::Color4*)
clampedRed( (Color4)arg1) -> float :
- C++ signature :
- double clampedRed(PGL::Color4*)
fromUint( (int)arg1) -> Color4 :
- C++ signature :
- PGL::Color4 fromUint(unsigned int)
getAverage( (Color4)arg1) -> float :
- C++ signature :
- double getAverage(PGL::Color4 {lvalue})
getAverageClamped( (Color4)arg1) -> float :
- C++ signature :
- double getAverageClamped(PGL::Color4 {lvalue})
getRGBAverage( (Color4)arg1) -> float :
- C++ signature :
- double getRGBAverage(PGL::Color4 {lvalue})
getRGBAverageClamped( (Color4)arg1) -> float :
- C++ signature :
- double getRGBAverageClamped(PGL::Color4 {lvalue})
setClampedAlpha( (Color4)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedAlpha(PGL::Color4*,double)
setClampedBlue( (Color4)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedBlue(PGL::Color4*,double)
setClampedGreen( (Color4)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedGreen(PGL::Color4*,double)
setClampedRed( (Color4)arg1, (float)arg2) -> None :
- C++ signature :
- void setClampedRed(PGL::Color4*,double)
toUint( (Color4)arg1) -> int :
- C++ signature :
- unsigned int toUint(PGL::Color4 {lvalue})
Color4Array(int size)
Color4Array([Index4(i,j,k,l),...])
append( (Color4Array)arg1, (Color4)arg2) -> None :
- C++ signature :
- void append(PGL::Color4Array*,PGL::Color4)
append( (Color4Array)arg1, (Color4Array)arg2) -> None :
- C++ signature :
- void append(PGL::Color4Array*,PGL::Color4Array*)
clear( (Color4Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Color4Array {lvalue})
getId( (Color4Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Color4Array*)
getPglId( (Color4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Color4Array {lvalue})
getPglReferenceCount( (Color4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Color4Array {lvalue})
insert( (Color4Array)arg1, (int)arg2, (Color4)arg3) -> None :
- C++ signature :
- void insert(PGL::Color4Array*,int,PGL::Color4)
pop( (Color4Array)arg1 [, (int)arg2]) -> Color4 :
- C++ signature :
- PGL::Color4 pop(PGL::Color4Array* [,int])
prepend( (Color4Array)arg1, (Color4)arg2) -> None :
- C++ signature :
- void prepend(PGL::Color4Array*,PGL::Color4)
prepend( (Color4Array)arg1, (Color4Array)arg2) -> None :
- C++ signature :
- void prepend(PGL::Color4Array*,PGL::Color4Array*)
reverse( (Color4Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Color4Array {lvalue})
A cone structure defined by a radius and a height. Its base is centered at origin.
Cone(radius, height [, solid, slices])
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})
isHeightToDefault( (Cone)arg1) -> bool :
- C++ signature :
- bool isHeightToDefault(PGL::Cone {lvalue})
isRadiusToDefault( (Cone)arg1) -> bool :
- C++ signature :
- bool isRadiusToDefault(PGL::Cone {lvalue})
isSolidToDefault( (Cone)arg1) -> bool :
- C++ signature :
- bool isSolidToDefault(PGL::Cone {lvalue})
recast( (Cone)arg1) -> Cone :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Cone> recast(PGL::Cone*)
Abstract base class for objects of type of 2D parametric curve.
Raises an exception This class cannot be instantiated from Python
findClosest(point) : return closestpoint, u
getArcLengthToUMapping() : Return a function that gives for each arc length the u parametrization of the curve.
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([begin,end]) : Return length of the curve from u = begin to u = end.
getNormalAt( (Curve2D)arg1, (float)u) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getNormalAt(PGL::Curve2D const*,double)
getPointAt( (Curve2D)arg1, (float)u) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getPointAt(PGL::Curve2D const*,double)
getTangentAt( (Curve2D)arg1, (float)u) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getTangentAt(PGL::Curve2D const*,double)
getUToArcLengthMapping() : Return a function that gives for each u the arc length parametrization of the curve.
isWidthToDefault( (Curve2D)arg1) -> bool :
- C++ signature :
- bool isWidthToDefault(PGL::Curve2D {lvalue})
Curve2DArray(int size)
Curve2DArray([Curve2D,...])
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( (Curve2DArray)arg1) -> None :
- C++ signature :
- void clear(PGL::Curve2DArray {lvalue})
getId( (Curve2DArray)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Curve2DArray*)
getPglId( (Curve2DArray)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Curve2DArray {lvalue})
getPglReferenceCount( (Curve2DArray)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Curve2DArray {lvalue})
insert( (Curve2DArray)arg1, (int)arg2, (Curve2D)arg3) -> None :
- C++ signature :
- void insert(PGL::Curve2DArray*,int,TOOLS::RefCountPtr<PGL::Curve2D>)
pop( (Curve2DArray)arg1 [, (int)arg2]) -> Curve2D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Curve2D> pop(PGL::Curve2DArray* [,int])
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( (Curve2DArray)arg1) -> None :
- C++ signature :
- void reverse(PGL::Curve2DArray {lvalue})
CurveArray(int size)
CurveArray([Curve,...])
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( (CurveArray)arg1) -> None :
- C++ signature :
- void clear(PGL::CurveArray {lvalue})
getId( (CurveArray)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::CurveArray*)
getPglId( (CurveArray)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::CurveArray {lvalue})
getPglReferenceCount( (CurveArray)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::CurveArray {lvalue})
insert( (CurveArray)arg1, (int)arg2, (LineicModel)arg3) -> None :
- C++ signature :
- void insert(PGL::CurveArray*,int,TOOLS::RefCountPtr<PGL::LineicModel>)
pop( (CurveArray)arg1 [, (int)arg2]) -> LineicModel :
- C++ signature :
- TOOLS::RefCountPtr<PGL::LineicModel> pop(PGL::CurveArray* [,int])
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( (CurveArray)arg1) -> None :
- C++ signature :
- void reverse(PGL::CurveArray {lvalue})
A cylinder structure defined by a radius and a height. Its base is centered at origin.
Cylinder([radius, height, solid, slices])
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( (Cylinder)arg1) -> Cylinder :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Cylinder> recast(PGL::Cylinder*)
Base class for recursive deep copy of a scene.
DeepCopier
clear( (DeepCopier)arg1) -> None :
- C++ signature :
- void clear(PGL::DeepCopier {lvalue})
Raises an exception This class cannot be instantiated from Python
A 2D disc structure centered on origin and defined by a radius.
Disc(radius, slices)
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( (Disc)arg1) -> bool :
- C++ signature :
- bool isRadiusToDefault(PGL::Disc {lvalue})
recast( (Disc)arg1) -> Disc :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Disc> recast(PGL::Disc*)
A regular grid of elevations.
ElevationGrid(heightList [,xspacing,yspacing,ccw])
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( (ElevationGrid)arg1, (int)arg2, (int)arg3) -> float :
- C++ signature :
- double getHeightAt(PGL::ElevationGrid*,unsigned int,unsigned int)
getPointAt( (ElevationGrid)arg1, (int)arg2, (int)arg3) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getPointAt(PGL::ElevationGrid {lvalue},unsigned int,unsigned int)
getXDim( (ElevationGrid)arg1) -> int :
- C++ signature :
- unsigned int getXDim(PGL::ElevationGrid {lvalue})
getXSize( (ElevationGrid)arg1) -> float :
- C++ signature :
- double getXSize(PGL::ElevationGrid {lvalue})
getYDim( (ElevationGrid)arg1) -> int :
- C++ signature :
- unsigned int getYDim(PGL::ElevationGrid {lvalue})
getYSize( (ElevationGrid)arg1) -> float :
- C++ signature :
- double getYSize(PGL::ElevationGrid {lvalue})
isXSpacingToDefault( (ElevationGrid)arg1) -> bool :
- C++ signature :
- bool isXSpacingToDefault(PGL::ElevationGrid {lvalue})
isYSpacingToDefault( (ElevationGrid)arg1) -> bool :
- C++ signature :
- bool isYSpacingToDefault(PGL::ElevationGrid {lvalue})
recast( (ElevationGrid)arg1) -> ElevationGrid :
- C++ signature :
- TOOLS::RefCountPtr<PGL::ElevationGrid> recast(PGL::ElevationGrid*)
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).
EulerRotated(azimuth,elevation,roll,geometry)
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})
isAzimuthToDefault( (EulerRotated)arg1) -> bool :
- C++ signature :
- bool isAzimuthToDefault(PGL::EulerRotated {lvalue})
isElevationToDefault( (EulerRotated)arg1) -> bool :
- C++ signature :
- bool isElevationToDefault(PGL::EulerRotated {lvalue})
isRollToDefault( (EulerRotated)arg1) -> bool :
- C++ signature :
- bool isRollToDefault(PGL::EulerRotated {lvalue})
recast( (EulerRotated)arg1) -> EulerRotated :
- C++ signature :
- TOOLS::RefCountPtr<PGL::EulerRotated> recast(PGL::EulerRotated*)
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :
- C++ signature :
- void __init__(_object*,double,double,double)
Explicit geometric representation based on a set of 3D points.
Raises an exception This class cannot be instantiated from Python
isColorListToDefault( (ExplicitModel)arg1) -> bool :
- C++ signature :
- bool isColorListToDefault(PGL::ExplicitModel {lvalue})
transform( (ExplicitModel)arg1, (Transformation3D)arg2) -> ExplicitModel :
- C++ signature :
- TOOLS::RefCountPtr<PGL::ExplicitModel> transform(PGL::ExplicitModel {lvalue},TOOLS::RefCountPtr<PGL::Transformation3D>)
A hull extruded by a vertical and an horizontal profiles.
ExtrudedHull(vertical,horizontal) : Constructs a ExtrudedHull with the profiles ‘vertical’ and ‘horizontal’.
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})
isCCWToDefault( (ExtrudedHull)arg1) -> bool :
- C++ signature :
- bool isCCWToDefault(PGL::ExtrudedHull {lvalue})
recast( (ExtrudedHull)arg1) -> ExtrudedHull :
- C++ signature :
- TOOLS::RefCountPtr<PGL::ExtrudedHull> recast(PGL::ExtrudedHull*)
An Extrusion represented by an axis, a cross section and a tranformation function.
Extrusion (LineicModel axis, Curve2D crossSection,[Point2Array scale, RealArray orientation, RealArray knotList, bool solid, bool ccw, Vector3 initialVector])
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( (Extrusion)arg1) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getInitialNormalValue(PGL::Extrusion {lvalue})
isCCWToDefault( (Extrusion)arg1) -> bool :
- C++ signature :
- bool isCCWToDefault(PGL::Extrusion {lvalue})
isInitialNormalToDefault( (Extrusion)arg1) -> bool :
- C++ signature :
- bool isInitialNormalToDefault(PGL::Extrusion {lvalue})
isOrientationToDefault( (Extrusion)arg1) -> bool :
- C++ signature :
- bool isOrientationToDefault(PGL::Extrusion {lvalue})
isScaleToDefault( (Extrusion)arg1) -> bool :
- C++ signature :
- bool isScaleToDefault(PGL::Extrusion {lvalue})
isSolidToDefault( (Extrusion)arg1) -> bool :
- C++ signature :
- bool isSolidToDefault(PGL::Extrusion {lvalue})
recast( (Extrusion)arg1) -> Extrusion :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Extrusion> recast(PGL::Extrusion*)
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.
Construct from TriangleSet
Construct from QuadSet
__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])
colorAt( (FaceSet)arg1, (int)arg2) -> Color4 :
- C++ signature :
- PGL::Color4 colorAt(PGL::FaceSet {lvalue},unsigned int)
colorIndexAt( (FaceSet)arg1, (int)arg2) -> Index :
- C++ signature :
- TOOLS::PglVector<unsigned int> colorIndexAt(PGL::FaceSet {lvalue},unsigned int)
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( (FaceSet)arg1, (int)arg2, (int)arg3) -> Color4 :
- C++ signature :
- PGL::Color4 faceColorAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)
faceNormalAt( (FaceSet)arg1, (int)arg2, (int)arg3) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 faceNormalAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)
faceTexCoordAt( (FaceSet)arg1, (int)arg2, (int)arg3) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 faceTexCoordAt(PGL::FaceSet {lvalue},unsigned int,unsigned int)
indexAt( (FaceSet)arg1, (int)arg2) -> Index :
- C++ signature :
- TOOLS::PglVector<unsigned int> indexAt(PGL::FaceSet {lvalue},unsigned int)
isColorIndexListToDefault( (FaceSet)arg1) -> bool :
- C++ signature :
- bool isColorIndexListToDefault(PGL::FaceSet {lvalue})
isNormalIndexListToDefault( (FaceSet)arg1) -> bool :
- C++ signature :
- bool isNormalIndexListToDefault(PGL::FaceSet {lvalue})
isTexCoordIndexListToDefault( (FaceSet)arg1) -> bool :
- C++ signature :
- bool isTexCoordIndexListToDefault(PGL::FaceSet {lvalue})
normalAt( (FaceSet)arg1, (int)arg2) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 normalAt(PGL::FaceSet {lvalue},unsigned int)
normalIndexAt( (FaceSet)arg1, (int)arg2) -> Index :
- C++ signature :
- TOOLS::PglVector<unsigned int> normalIndexAt(PGL::FaceSet {lvalue},unsigned int)
recast( (FaceSet)arg1) -> FaceSet :
- C++ signature :
- TOOLS::RefCountPtr<PGL::FaceSet> recast(PGL::FaceSet*)
texCoordAt( (FaceSet)arg1, (int)arg2) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 texCoordAt(PGL::FaceSet {lvalue},unsigned int)
texCoordIndexAt( (FaceSet)arg1, (int)arg2) -> Index :
- C++ signature :
- TOOLS::PglVector<unsigned int> texCoordIndexAt(PGL::FaceSet {lvalue},unsigned int)
Font describes how text is displayed.
Font([family,size,bold,italic])
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})
isBoldToDefault( (Font)arg1) -> bool :
- C++ signature :
- bool isBoldToDefault(PGL::Font {lvalue})
isItalicToDefault( (Font)arg1) -> bool :
- C++ signature :
- bool isItalicToDefault(PGL::Font {lvalue})
isSizeToDefault( (Font)arg1) -> bool :
- C++ signature :
- bool isSizeToDefault(PGL::Font {lvalue})
recast( (Font)arg1) -> Font :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Font> recast(PGL::Font*)
A frustum structure defined by a base radius, a height and a taper factor. Its base is centered at origin.
Frustum([radius, height, taper, solid, slices])
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( (Frustum)arg1) -> bool :
- C++ signature :
- bool isTaperToDefault(PGL::Frustum {lvalue})
recast( (Frustum)arg1) -> Frustum :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Frustum> recast(PGL::Frustum*)
Abstract base class for all geometrical structure.
Raises an exception This class cannot be instantiated from Python
isACurve( (Geometry)arg1) -> bool :
- C++ signature :
- bool isACurve(PGL::Geometry {lvalue})
isASurface( (Geometry)arg1) -> bool :
- C++ signature :
- bool isASurface(PGL::Geometry {lvalue})
isAVolume( (Geometry)arg1) -> bool :
- C++ signature :
- bool isAVolume(PGL::Geometry {lvalue})
isExplicit( (Geometry)arg1) -> bool :
- C++ signature :
- bool isExplicit(PGL::Geometry {lvalue})
GeometryArray(int size)
GeometryArray([Geometry,...])
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( (GeometryArray)arg1) -> None :
- C++ signature :
- void clear(PGL::GeometryArray {lvalue})
getId( (GeometryArray)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::GeometryArray*)
getPglId( (GeometryArray)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::GeometryArray {lvalue})
getPglReferenceCount( (GeometryArray)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::GeometryArray {lvalue})
insert( (GeometryArray)arg1, (int)arg2, (Geometry)arg3) -> None :
- C++ signature :
- void insert(PGL::GeometryArray*,int,TOOLS::RefCountPtr<PGL::Geometry>)
pop( (GeometryArray)arg1 [, (int)arg2]) -> Geometry :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Geometry> pop(PGL::GeometryArray* [,int])
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( (GeometryArray)arg1) -> None :
- C++ signature :
- void reverse(PGL::GeometryArray {lvalue})
A Group of Geometry
Group(list geometryList [,Polyline skeleton])
__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( (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})
isSkeletonToDefault( (Group)arg1) -> bool :
- C++ signature :
- bool isSkeletonToDefault(PGL::Group {lvalue})
recast( (Group)arg1) -> Group :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Group> recast(PGL::Group*)
Abstract base class for objects of type of 3D envelope.
Raises an exception This class cannot be instantiated from Python
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.
IFS(depth, transfoList, geometry)
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})
getAllTransformations( (IFS)arg1) -> Matrix4Array :
- C++ signature :
- TOOLS::RefCountPtr<TOOLS::Array1<TOOLS::Matrix4> > getAllTransformations(PGL::IFS*)
isDepthToDefault( (IFS)arg1) -> bool :
- C++ signature :
- bool isDepthToDefault(PGL::IFS {lvalue})
recast( (IFS)arg1) -> IFS :
- C++ signature :
- TOOLS::RefCountPtr<PGL::IFS> recast(PGL::IFS*)
The image of a textured object.
ImageTexture(filename [, transparency, repeatS, repeatT, mipmaping])
ImageTexture(name, filename [, transparency, repeatS, repeatT, mipmaping])
isMipmapingToDefault( (ImageTexture)arg1) -> bool :
- C++ signature :
- bool isMipmapingToDefault(PGL::ImageTexture {lvalue})
isRepeatSToDefault( (ImageTexture)arg1) -> bool :
- C++ signature :
- bool isRepeatSToDefault(PGL::ImageTexture {lvalue})
isRepeatTToDefault( (ImageTexture)arg1) -> bool :
- C++ signature :
- bool isRepeatTToDefault(PGL::ImageTexture {lvalue})
isTransparencyToDefault( (ImageTexture)arg1) -> bool :
- C++ signature :
- bool isTransparencyToDefault(PGL::ImageTexture {lvalue})
A set of indices
Index(int size)
Index([int i, int j, int k, ...])
Index(int i, int j, int k)
Index(int i, int j, int k, int l)
Index(int i, int j, int k, int l, int m)
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( (Index)arg1) -> None :
- C++ signature :
- void clear(TOOLS::PglVector<unsigned int> {lvalue})
getId( (Index)arg1) -> int :
- C++ signature :
- unsigned long getId(TOOLS::PglVector<unsigned int>*)
insert( (Index)arg1, (int)arg2, (int)arg3) -> None :
- C++ signature :
- void insert(TOOLS::PglVector<unsigned int>*,int,unsigned int)
pop( (Index)arg1 [, (int)arg2]) -> int :
- C++ signature :
- unsigned int pop(TOOLS::PglVector<unsigned int>* [,int])
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( (Index)arg1) -> None :
- C++ signature :
- void reverse(TOOLS::PglVector<unsigned int> {lvalue})
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]]])
Index3Array(int size)
Index3Array([Index3(i,j,k),...])
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( (Index3Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Index3Array {lvalue})
getId( (Index3Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Index3Array*)
getPglId( (Index3Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Index3Array {lvalue})
getPglReferenceCount( (Index3Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Index3Array {lvalue})
insert( (Index3Array)arg1, (int)arg2, (Index3)arg3) -> None :
- C++ signature :
- void insert(PGL::Index3Array*,int,TOOLS::Tuple3<unsigned int>)
pop( (Index3Array)arg1 [, (int)arg2]) -> Index3 :
- C++ signature :
- TOOLS::Tuple3<unsigned int> pop(PGL::Index3Array* [,int])
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( (Index3Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Index3Array {lvalue})
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]]]])
Index4Array(int size)
Index4Array([Index4(i,j,k,l),...])
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( (Index4Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Index4Array {lvalue})
getId( (Index4Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Index4Array*)
getPglId( (Index4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Index4Array {lvalue})
getPglReferenceCount( (Index4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Index4Array {lvalue})
insert( (Index4Array)arg1, (int)arg2, (Index4)arg3) -> None :
- C++ signature :
- void insert(PGL::Index4Array*,int,TOOLS::Tuple4<unsigned int>)
pop( (Index4Array)arg1 [, (int)arg2]) -> Index4 :
- C++ signature :
- TOOLS::Tuple4<unsigned int> pop(PGL::Index4Array* [,int])
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( (Index4Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Index4Array {lvalue})
triangulate( (Index4Array)arg1) -> Index3Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Index3Array> triangulate(PGL::Index4Array {lvalue})
IndexArray(int size)
IndexArray([Index([i,j,..]),...])
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( (IndexArray)arg1) -> None :
- C++ signature :
- void clear(PGL::IndexArray {lvalue})
getId( (IndexArray)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::IndexArray*)
getPglId( (IndexArray)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::IndexArray {lvalue})
getPglReferenceCount( (IndexArray)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::IndexArray {lvalue})
insert( (IndexArray)arg1, (int)arg2, (Index)arg3) -> None :
- C++ signature :
- void insert(PGL::IndexArray*,int,TOOLS::PglVector<unsigned int>)
pop( (IndexArray)arg1 [, (int)arg2]) -> Index :
- C++ signature :
- TOOLS::PglVector<unsigned int> pop(PGL::IndexArray* [,int])
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( (IndexArray)arg1) -> None :
- C++ signature :
- void reverse(PGL::IndexArray {lvalue})
triangulate( (IndexArray)arg1) -> Index3Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Index3Array> triangulate(PGL::IndexArray {lvalue})
Abstract base class for all lineic model.
Raises an exception This class cannot be instantiated from Python
findClosest(point) : return closestpoint, u
getArcLengthToUMapping() : Return a function that gives for each arc length the u parametrization of the curve.
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([begin,end]) : Return length of the curve from u = begin to u = end.
getNormalAt( (LineicModel)arg1, (float)u) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getNormalAt(PGL::LineicModel const*,double)
getPointAt( (LineicModel)arg1, (float)u) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getPointAt(PGL::LineicModel const*,double)
getTangentAt( (LineicModel)arg1, (float)u) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getTangentAt(PGL::LineicModel const*,double)
getUToArcLengthMapping() : Return a function that gives for each u the arc length parametrization of the curve.
isWidthToDefault( (LineicModel)arg1) -> bool :
- C++ signature :
- bool isWidthToDefault(PGL::LineicModel {lvalue})
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)
Material( ambient=(160,160,160),diffuse=1,specular=(40,40,40),emission=(0,0,0),shininess=1,transparency=0)
Material( name, ambient=(160,160,160), diffuse=1, specular=(40,40,40), emission=(0,0,0), shininess=1, transparency=0)
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})
isAmbientToDefault( (Material)arg1) -> bool :
- C++ signature :
- bool isAmbientToDefault(PGL::Material {lvalue})
isDiffuseToDefault( (Material)arg1) -> bool :
- C++ signature :
- bool isDiffuseToDefault(PGL::Material {lvalue})
isEmissionToDefault( (Material)arg1) -> bool :
- C++ signature :
- bool isEmissionToDefault(PGL::Material {lvalue})
isShininessToDefault( (Material)arg1) -> bool :
- C++ signature :
- bool isShininessToDefault(PGL::Material {lvalue})
isSimilar( (Material)arg1, (Material)arg2) -> bool :
- C++ signature :
- bool isSimilar(PGL::Material {lvalue},PGL::Material)
isSpecularToDefault( (Material)arg1) -> bool :
- C++ signature :
- bool isSpecularToDefault(PGL::Material {lvalue})
isTransparencyToDefault( (Material)arg1) -> bool :
- C++ signature :
- bool isTransparencyToDefault(PGL::Material {lvalue})
recast( (Material)arg1) -> Material :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Material> recast(PGL::Material*)
Raises an exception This class cannot be instantiated from Python
Matrix4Array(int size)
Matrix4Array([Matrix4(...),...])
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( (Matrix4Array)arg1) -> None :
- C++ signature :
- void clear(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
getId( (Matrix4Array)arg1) -> int :
- C++ signature :
- unsigned long getId(TOOLS::Array1<TOOLS::Matrix4>*)
getPglId( (Matrix4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
getPglReferenceCount( (Matrix4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
insert( (Matrix4Array)arg1, (int)arg2, (Matrix4)arg3) -> None :
- C++ signature :
- void insert(TOOLS::Array1<TOOLS::Matrix4>*,int,TOOLS::Matrix4)
pop( (Matrix4Array)arg1 [, (int)arg2]) -> Matrix4 :
- C++ signature :
- TOOLS::Matrix4 pop(TOOLS::Array1<TOOLS::Matrix4>* [,int])
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( (Matrix4Array)arg1) -> None :
- C++ signature :
- void reverse(TOOLS::Array1<TOOLS::Matrix4> {lvalue})
Raises an exception This class cannot be instantiated from Python
getMatrix( (Matrix4Transformation)arg1) -> Matrix4 :
- C++ signature :
- TOOLS::Matrix4 getMatrix(PGL::Matrix4Transformation {lvalue})
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
Abstract base class for objects of type of mesh.
Raises an exception This class cannot be instantiated from Python
computeNormalList( (Mesh)arg1) -> None :
- C++ signature :
- void computeNormalList(PGL::Mesh {lvalue})
faceCenter( (Mesh)arg1, (int)arg2) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 faceCenter(PGL::Mesh {lvalue},unsigned int)
faceSize( (Mesh)arg1, (int)arg2) -> int :
- C++ signature :
- unsigned int faceSize(PGL::Mesh {lvalue},unsigned int)
indexListSize( (Mesh)arg1) -> int :
- C++ signature :
- unsigned int indexListSize(PGL::Mesh {lvalue})
isCCWToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isCCWToDefault(PGL::Mesh {lvalue})
isColorPerVertexToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isColorPerVertexToDefault(PGL::Mesh {lvalue})
isNormalListToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isNormalListToDefault(PGL::Mesh {lvalue})
isNormalPerVertexToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isNormalPerVertexToDefault(PGL::Mesh {lvalue})
isSkeletonToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isSkeletonToDefault(PGL::Mesh {lvalue})
isSolidToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isSolidToDefault(PGL::Mesh {lvalue})
isTexCoordListToDefault( (Mesh)arg1) -> bool :
- C++ signature :
- bool isTexCoordListToDefault(PGL::Mesh {lvalue})
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)
Mono spectral appearance property of an object.
MonoSpectral([ reflectance, transmittance ])
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( (MonoSpectral)arg1) -> MonoSpectral :
- C++ signature :
- TOOLS::RefCountPtr<PGL::MonoSpectral> recast(PGL::MonoSpectral*)
Multi spectral appearance property of an object.
MultiSpectral(reflectance= RealArray, transmittance= RealArray [, filter= index3])
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( (MultiSpectral)arg1) -> MultiSpectral :
- C++ signature :
- TOOLS::RefCountPtr<PGL::MultiSpectral> recast(PGL::MultiSpectral*)
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.
NurbsCurve(ctrlPointList[,degree,knotList,stride])
__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]]])
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 : |
|
---|---|
Returns Type: | :class:NurbsCurve |
Build a nurbs curve by interpolate (C1) the points pts. The resulting curve can be closed.
[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.
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})
Compute a default knot list for a curve of n control points and a degree d
Test whether knots corresponds to a default knot list for a curve of n control points and a degree d
[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.
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
fit(points [, int degree, int nbctrlpoints])
getDerivativeAt( (NurbsCurve)arg1, (float)u, (int)d) -> Vector4 :
- C++ signature :
- TOOLS::Vector4 getDerivativeAt(PGL::NurbsCurve {lvalue},double,int)
getDerivativesAt( (NurbsCurve)arg1, (float)u) -> Point4Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point4Array> getDerivativesAt(PGL::NurbsCurve {lvalue},double)
isDegreeToDefault( (NurbsCurve)arg1) -> bool :
- C++ signature :
- bool isDegreeToDefault(PGL::NurbsCurve {lvalue})
isKnotListToDefault( (NurbsCurve)arg1) -> bool :
- C++ signature :
- bool isKnotListToDefault(PGL::NurbsCurve {lvalue})
recast( (NurbsCurve)arg1) -> NurbsCurve :
- C++ signature :
- TOOLS::RefCountPtr<PGL::NurbsCurve> recast(PGL::NurbsCurve*)
setKnotListToDefault( (NurbsCurve)arg1) -> bool :
- C++ signature :
- bool setKnotListToDefault(PGL::NurbsCurve {lvalue})
A 2D NURBS Curve represented by an array of control Points, a knots list and a degree. See NurbsCurve.
NurbsCurve2D(ctrlPointList[,degree,knotList,stride])
__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]]])
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 : |
|
---|---|
Returns Type: | :class:NurbsCurve2D |
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})
fit( (Point2Array)points) -> object :
- C++ signature :
- boost::python::api::object fit(TOOLS::RefCountPtr<PGL::Point2Array>)
fit(points [, int degree, int nbctrlpoints])
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( (NurbsCurve2D)arg1) -> bool :
- C++ signature :
- bool isDegreeToDefault(PGL::NurbsCurve2D {lvalue})
isKnotListToDefault( (NurbsCurve2D)arg1) -> bool :
- C++ signature :
- bool isKnotListToDefault(PGL::NurbsCurve2D {lvalue})
recast( (NurbsCurve2D)arg1) -> NurbsCurve2D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::NurbsCurve2D> recast(PGL::NurbsCurve2D*)
setKnotListToDefault( (NurbsCurve2D)arg1) -> bool :
- C++ signature :
- bool setKnotListToDefault(PGL::NurbsCurve2D {lvalue})
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.
NurbsPatch(Point4Matrix ctrlPointList, RealArray uKnotList,RealArray vKnotList [,uDeg, vDeg,ustride,vstride,ccw])
NurbsPatch(Point4Matrix ctrlPointList, udegree, vdegree,uknotList, vknotList [,ustride,vstride,ccw])
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( (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)
Return the derivative at u and v. du and dv specify how many time you want to derive with respect to u and v.
getDerivativesAt( (NurbsPatch)arg1, (float)u, (float)v) -> Point4Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point4Matrix> getDerivativesAt(PGL::NurbsPatch {lvalue},double,double)
getNormalAt( (NurbsPatch)arg1, (float)u, (float)v) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getNormalAt(PGL::NurbsPatch {lvalue},double,double)
getUTangentAt( (NurbsPatch)arg1, (float)u, (float)v) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getUTangentAt(PGL::NurbsPatch {lvalue},double,double)
getVTangentAt( (NurbsPatch)arg1, (float)u, (float)v) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getVTangentAt(PGL::NurbsPatch {lvalue},double,double)
isUDegreeToDefault( (NurbsPatch)arg1) -> bool :
- C++ signature :
- bool isUDegreeToDefault(PGL::NurbsPatch {lvalue})
isUKnotListToDefault( (NurbsPatch)arg1) -> bool :
- C++ signature :
- bool isUKnotListToDefault(PGL::NurbsPatch {lvalue})
isVDegreeToDefault( (NurbsPatch)arg1) -> int :
- C++ signature :
- unsigned int isVDegreeToDefault(PGL::NurbsPatch {lvalue})
isVKnotListToDefault( (NurbsPatch)arg1) -> bool :
- C++ signature :
- bool isVKnotListToDefault(PGL::NurbsPatch {lvalue})
recast( (NurbsPatch)arg1) -> NurbsPatch :
- C++ signature :
- TOOLS::RefCountPtr<PGL::NurbsPatch> recast(PGL::NurbsPatch*)
setUKnotListToDefault( (NurbsPatch)arg1) -> bool :
- C++ signature :
- bool setUKnotListToDefault(PGL::NurbsPatch {lvalue})
setVKnotListToDefault( (NurbsPatch)arg1) -> bool :
- C++ signature :
- bool setVKnotListToDefault(PGL::NurbsPatch {lvalue})
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.
Oriented(primary,secondary,geometry) with primary,secondary: Vector3
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( (Oriented)arg1) -> bool :
- C++ signature :
- bool isPrimaryToDefault(PGL::Oriented {lvalue})
isSecondaryToDefault( (Oriented)arg1) -> bool :
- C++ signature :
- bool isSecondaryToDefault(PGL::Oriented {lvalue})
recast( (Oriented)arg1) -> Oriented :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Oriented> recast(PGL::Oriented*)
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
__init__( (object)arg1, (Matrix3)arg2) -> None :
- C++ signature :
- void __init__(_object*,TOOLS::Matrix3)
getMatrix( (OrthonormalBasis3D)arg1) -> Matrix4 :
- C++ signature :
- TOOLS::Matrix4 getMatrix(PGL::OrthonormalBasis3D {lvalue})
getMatrix3( (OrthonormalBasis3D)arg1) -> Matrix3 :
- C++ signature :
- TOOLS::Matrix3 getMatrix3(PGL::OrthonormalBasis3D {lvalue})
A paraboloid structure defined by a base radius, a height and a shape factor. Its base is centered at origin.
Paraboloid([radius, height, shape , solid, slices, stacks])
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( (Paraboloid)arg1) -> bool :
- C++ signature :
- bool isShapeToDefault(PGL::Paraboloid {lvalue})
isStacksToDefault( (Paraboloid)arg1) -> bool :
- C++ signature :
- bool isStacksToDefault(PGL::Paraboloid {lvalue})
recast( (Paraboloid)arg1) -> Paraboloid :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Paraboloid> recast(PGL::Paraboloid*)
Abstract base class for all parametric primitives
Raises an exception This class cannot be instantiated from Python
Abstract base class for patches.
Raises an exception This class cannot be instantiated from Python
isCCWToDefault( (Patch)arg1) -> bool :
- C++ signature :
- bool isCCWToDefault(PGL::Patch {lvalue})
Raises an exception This class cannot be instantiated from Python
Point2Array(int size)
Point2Array([Vector2(x,y),...])
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( (Point2Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Point2Array {lvalue})
Find closest point in the PointArray2 from arg
getBounds( (Point2Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getBounds(PGL::Point2Array const*)
getCenter( (Point2Array)arg1) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getCenter(PGL::Point2Array {lvalue})
getExtent( (Point2Array)arg1) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getExtent(PGL::Point2Array {lvalue})
getId( (Point2Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Point2Array*)
getLength( (Point2Array)arg1) -> float :
- C++ signature :
- double getLength(PGL::Point2Array {lvalue})
getPglId( (Point2Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Point2Array {lvalue})
getPglReferenceCount( (Point2Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Point2Array {lvalue})
getXMaxIndex( (Point2Array)arg1) -> int :
- C++ signature :
- int getXMaxIndex(PGL::Point2Array const*)
getXMinAndMaxIndex( (Point2Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getXMinAndMaxIndex(PGL::Point2Array const*)
getXMinIndex( (Point2Array)arg1) -> int :
- C++ signature :
- int getXMinIndex(PGL::Point2Array const*)
getYMaxIndex( (Point2Array)arg1) -> int :
- C++ signature :
- int getYMaxIndex(PGL::Point2Array const*)
getYMinAndMaxIndex( (Point2Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getYMinAndMaxIndex(PGL::Point2Array const*)
getYMinIndex( (Point2Array)arg1) -> int :
- C++ signature :
- int getYMinIndex(PGL::Point2Array const*)
hausdorff_distance( (Point2Array)arg1, (Point2Array)arg2) -> float :
- C++ signature :
- double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point2Array>,TOOLS::RefCountPtr<PGL::Point2Array>)
insert( (Point2Array)arg1, (int)arg2, (Vector2)arg3) -> None :
- C++ signature :
- void insert(PGL::Point2Array*,int,TOOLS::Vector2)
normalize( (Point2Array)arg1) -> None :
- C++ signature :
- void normalize(PGL::Point2Array {lvalue})
partition( (Point2Array)arg1, (object)arg2) -> list :
- C++ signature :
- boost::python::list partition(PGL::Point2Array*,boost::python::api::object)
pop( (Point2Array)arg1 [, (int)arg2]) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 pop(PGL::Point2Array* [,int])
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( (Point2Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Point2Array {lvalue})
sort( (Point2Array)arg1, (object)arg2) -> None :
- C++ signature :
- void sort(PGL::Point2Array*,boost::python::api::object)
sortX( (Point2Array)arg1) -> None :
- C++ signature :
- void sortX(PGL::Point2Array*)
sortY( (Point2Array)arg1) -> None :
- C++ signature :
- void sortY(PGL::Point2Array*)
transform( (Point2Array)arg1, (Matrix2)arg2) -> None :
- C++ signature :
- void transform(PGL::Point2Array {lvalue},TOOLS::Matrix2)
Point2Matrix(int rows, int cols)
Point2Matrix([[a,b,c],[d,e,f]])
clear( (Point2Matrix)arg1) -> None :
- C++ signature :
- void clear(PGL::Point2Matrix {lvalue})
empty( (Point2Matrix)arg1) -> bool :
- C++ signature :
- bool empty(PGL::Point2Matrix {lvalue})
getColumn( (Point2Matrix)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getColumn(PGL::Point2Matrix*,unsigned long)
getColumnNb( (Point2Matrix)arg1) -> int :
- C++ signature :
- unsigned long getColumnNb(PGL::Point2Matrix*)
getDiagonal( (Point2Matrix)arg1) -> object :
- C++ signature :
- boost::python::api::object getDiagonal(PGL::Point2Matrix*)
getRow( (Point2Matrix)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getRow(PGL::Point2Matrix*,unsigned long)
getRowNb( (Point2Matrix)arg1) -> int :
- C++ signature :
- unsigned long getRowNb(PGL::Point2Matrix*)
insertColumn( (Point2Matrix)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertColumn(PGL::Point2Matrix*,unsigned long,boost::python::api::object)
insertRow( (Point2Matrix)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertRow(PGL::Point2Matrix*,unsigned long,boost::python::api::object)
isUnique( (Point2Matrix)arg1) -> bool :
- C++ signature :
- bool isUnique(PGL::Point2Matrix {lvalue})
pushColumn( (Point2Matrix)arg1, (object)arg2) -> None :
- C++ signature :
- void pushColumn(PGL::Point2Matrix*,boost::python::api::object)
pushRow( (Point2Matrix)arg1, (object)arg2) -> None :
- C++ signature :
- void pushRow(PGL::Point2Matrix*,boost::python::api::object)
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( (Point2Matrix)arg1) -> Point2Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point2Matrix> transpose(PGL::Point2Matrix*)
Point3Array(int size)
Point3Array([Vector3(x,y,z),...])
Point3Array(Point2Array a, z)
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( (Point3Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Point3Array {lvalue})
Find closest point in the PointArray3 from arg
getBounds( (Point3Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getBounds(PGL::Point3Array const*)
getCenter( (Point3Array)arg1) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getCenter(PGL::Point3Array {lvalue})
getExtent( (Point3Array)arg1) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 getExtent(PGL::Point3Array {lvalue})
getId( (Point3Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Point3Array*)
getLength( (Point3Array)arg1) -> float :
- C++ signature :
- double getLength(PGL::Point3Array {lvalue})
getPglId( (Point3Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Point3Array {lvalue})
getPglReferenceCount( (Point3Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Point3Array {lvalue})
getXMaxIndex( (Point3Array)arg1) -> int :
- C++ signature :
- int getXMaxIndex(PGL::Point3Array const*)
getXMinAndMaxIndex( (Point3Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getXMinAndMaxIndex(PGL::Point3Array const*)
getXMinIndex( (Point3Array)arg1) -> int :
- C++ signature :
- int getXMinIndex(PGL::Point3Array const*)
getYMaxIndex( (Point3Array)arg1) -> int :
- C++ signature :
- int getYMaxIndex(PGL::Point3Array const*)
getYMinAndMaxIndex( (Point3Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getYMinAndMaxIndex(PGL::Point3Array const*)
getYMinIndex( (Point3Array)arg1) -> int :
- C++ signature :
- int getYMinIndex(PGL::Point3Array const*)
getZMaxIndex( (Point3Array)arg1) -> int :
- C++ signature :
- int getZMaxIndex(PGL::Point3Array const*)
getZMinAndMaxIndex( (Point3Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getZMinAndMaxIndex(PGL::Point3Array const*)
getZMinIndex( (Point3Array)arg1) -> int :
- C++ signature :
- int getZMinIndex(PGL::Point3Array const*)
hausdorff_distance( (Point3Array)arg1, (Point3Array)arg2) -> float :
- C++ signature :
- double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point3Array>,TOOLS::RefCountPtr<PGL::Point3Array>)
insert( (Point3Array)arg1, (int)arg2, (Vector3)arg3) -> None :
- C++ signature :
- void insert(PGL::Point3Array*,int,TOOLS::Vector3)
normalize( (Point3Array)arg1) -> None :
- C++ signature :
- void normalize(PGL::Point3Array {lvalue})
partition( (Point3Array)arg1, (object)arg2) -> list :
- C++ signature :
- boost::python::list partition(PGL::Point3Array*,boost::python::api::object)
pop( (Point3Array)arg1 [, (int)arg2]) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 pop(PGL::Point3Array* [,int])
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( (Point3Array)arg1) -> Point2Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point2Array> project(PGL::Point3Array {lvalue})
reverse( (Point3Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Point3Array {lvalue})
sort( (Point3Array)arg1, (object)arg2) -> None :
- C++ signature :
- void sort(PGL::Point3Array*,boost::python::api::object)
sortX( (Point3Array)arg1) -> None :
- C++ signature :
- void sortX(PGL::Point3Array*)
sortY( (Point3Array)arg1) -> None :
- C++ signature :
- void sortY(PGL::Point3Array*)
sortZ( (Point3Array)arg1) -> None :
- C++ signature :
- void sortZ(PGL::Point3Array*)
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)
Point3Matrix(int rows, int cols)
Point3Matrix([[a,b,c],[d,e,f]])
clear( (Point3Matrix)arg1) -> None :
- C++ signature :
- void clear(PGL::Point3Matrix {lvalue})
empty( (Point3Matrix)arg1) -> bool :
- C++ signature :
- bool empty(PGL::Point3Matrix {lvalue})
getColumn( (Point3Matrix)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getColumn(PGL::Point3Matrix*,unsigned long)
getColumnNb( (Point3Matrix)arg1) -> int :
- C++ signature :
- unsigned long getColumnNb(PGL::Point3Matrix*)
getDiagonal( (Point3Matrix)arg1) -> object :
- C++ signature :
- boost::python::api::object getDiagonal(PGL::Point3Matrix*)
getRow( (Point3Matrix)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getRow(PGL::Point3Matrix*,unsigned long)
getRowNb( (Point3Matrix)arg1) -> int :
- C++ signature :
- unsigned long getRowNb(PGL::Point3Matrix*)
insertColumn( (Point3Matrix)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertColumn(PGL::Point3Matrix*,unsigned long,boost::python::api::object)
insertRow( (Point3Matrix)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertRow(PGL::Point3Matrix*,unsigned long,boost::python::api::object)
isUnique( (Point3Matrix)arg1) -> bool :
- C++ signature :
- bool isUnique(PGL::Point3Matrix {lvalue})
pushColumn( (Point3Matrix)arg1, (object)arg2) -> None :
- C++ signature :
- void pushColumn(PGL::Point3Matrix*,boost::python::api::object)
pushRow( (Point3Matrix)arg1, (object)arg2) -> None :
- C++ signature :
- void pushRow(PGL::Point3Matrix*,boost::python::api::object)
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( (Point3Matrix)arg1) -> Point3Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point3Matrix> transpose(PGL::Point3Matrix*)
Point4Array(int size)
Point4Array([Vector4(x,y,z,w),...])
Point4Array(Point2Array a, z, w)
Point4Array(Point3Array a, w)
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( (Point4Array)arg1) -> None :
- C++ signature :
- void clear(PGL::Point4Array {lvalue})
Find closest point in the PointArray4 from arg
getBounds( (Point4Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getBounds(PGL::Point4Array const*)
getCenter( (Point4Array)arg1) -> Vector4 :
- C++ signature :
- TOOLS::Vector4 getCenter(PGL::Point4Array {lvalue})
getExtent( (Point4Array)arg1) -> Vector4 :
- C++ signature :
- TOOLS::Vector4 getExtent(PGL::Point4Array {lvalue})
getId( (Point4Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Point4Array*)
getLength( (Point4Array)arg1) -> float :
- C++ signature :
- double getLength(PGL::Point4Array {lvalue})
getPglId( (Point4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::Point4Array {lvalue})
getPglReferenceCount( (Point4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Point4Array {lvalue})
getWMaxIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getWMaxIndex(PGL::Point4Array const*)
getWMinAndMaxIndex( (Point4Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getWMinAndMaxIndex(PGL::Point4Array const*)
getWMinIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getWMinIndex(PGL::Point4Array const*)
getXMaxIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getXMaxIndex(PGL::Point4Array const*)
getXMinAndMaxIndex( (Point4Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getXMinAndMaxIndex(PGL::Point4Array const*)
getXMinIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getXMinIndex(PGL::Point4Array const*)
getYMaxIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getYMaxIndex(PGL::Point4Array const*)
getYMinAndMaxIndex( (Point4Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getYMinAndMaxIndex(PGL::Point4Array const*)
getYMinIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getYMinIndex(PGL::Point4Array const*)
getZMaxIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getZMaxIndex(PGL::Point4Array const*)
getZMinAndMaxIndex( (Point4Array)arg1) -> object :
- C++ signature :
- boost::python::api::object getZMinAndMaxIndex(PGL::Point4Array const*)
getZMinIndex( (Point4Array)arg1) -> int :
- C++ signature :
- int getZMinIndex(PGL::Point4Array const*)
hausdorff_distance( (Point4Array)arg1, (Point4Array)arg2) -> float :
- C++ signature :
- double hausdorff_distance(TOOLS::RefCountPtr<PGL::Point4Array>,TOOLS::RefCountPtr<PGL::Point4Array>)
insert( (Point4Array)arg1, (int)arg2, (Vector4)arg3) -> None :
- C++ signature :
- void insert(PGL::Point4Array*,int,TOOLS::Vector4)
normalize( (Point4Array)arg1) -> None :
- C++ signature :
- void normalize(PGL::Point4Array {lvalue})
partition( (Point4Array)arg1, (object)arg2) -> list :
- C++ signature :
- boost::python::list partition(PGL::Point4Array*,boost::python::api::object)
pop( (Point4Array)arg1 [, (int)arg2]) -> Vector4 :
- C++ signature :
- TOOLS::Vector4 pop(PGL::Point4Array* [,int])
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( (Point4Array)arg1) -> Point3Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point3Array> project(PGL::Point4Array {lvalue})
reverse( (Point4Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::Point4Array {lvalue})
sort( (Point4Array)arg1, (object)arg2) -> None :
- C++ signature :
- void sort(PGL::Point4Array*,boost::python::api::object)
sortW( (Point4Array)arg1) -> None :
- C++ signature :
- void sortW(PGL::Point4Array*)
sortX( (Point4Array)arg1) -> None :
- C++ signature :
- void sortX(PGL::Point4Array*)
sortY( (Point4Array)arg1) -> None :
- C++ signature :
- void sortY(PGL::Point4Array*)
sortZ( (Point4Array)arg1) -> None :
- C++ signature :
- void sortZ(PGL::Point4Array*)
transform( (Point4Array)arg1, (Matrix4)arg2) -> None :
- C++ signature :
- void transform(PGL::Point4Array {lvalue},TOOLS::Matrix4)
Point4Matrix(int rows, int cols)
Point4Matrix([[a,b,c],[d,e,f]])
clear( (Point4Matrix)arg1) -> None :
- C++ signature :
- void clear(PGL::Point4Matrix {lvalue})
empty( (Point4Matrix)arg1) -> bool :
- C++ signature :
- bool empty(PGL::Point4Matrix {lvalue})
getColumn( (Point4Matrix)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getColumn(PGL::Point4Matrix*,unsigned long)
getColumnNb( (Point4Matrix)arg1) -> int :
- C++ signature :
- unsigned long getColumnNb(PGL::Point4Matrix*)
getDiagonal( (Point4Matrix)arg1) -> object :
- C++ signature :
- boost::python::api::object getDiagonal(PGL::Point4Matrix*)
getRow( (Point4Matrix)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getRow(PGL::Point4Matrix*,unsigned long)
getRowNb( (Point4Matrix)arg1) -> int :
- C++ signature :
- unsigned long getRowNb(PGL::Point4Matrix*)
insertColumn( (Point4Matrix)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertColumn(PGL::Point4Matrix*,unsigned long,boost::python::api::object)
insertRow( (Point4Matrix)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertRow(PGL::Point4Matrix*,unsigned long,boost::python::api::object)
isUnique( (Point4Matrix)arg1) -> bool :
- C++ signature :
- bool isUnique(PGL::Point4Matrix {lvalue})
pushColumn( (Point4Matrix)arg1, (object)arg2) -> None :
- C++ signature :
- void pushColumn(PGL::Point4Matrix*,boost::python::api::object)
pushRow( (Point4Matrix)arg1, (object)arg2) -> None :
- C++ signature :
- void pushRow(PGL::Point4Matrix*,boost::python::api::object)
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( (Point4Matrix)arg1) -> Point4Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point4Matrix> transpose(PGL::Point4Matrix*)
PointSet describes an explicit set of points
PointSet(Point3Array pointList, Color4Array colorList = None)
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( (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})
Find closest point in the PointSet from arg
isWidthToDefault( (PointSet)arg1) -> bool :
- C++ signature :
- bool isWidthToDefault(PGL::PointSet {lvalue})
recast( (PointSet)arg1) -> PointSet :
- C++ signature :
- TOOLS::RefCountPtr<PGL::PointSet> recast(PGL::PointSet*)
transform( (PointSet)arg1, (Transformation3D)arg2) -> ExplicitModel :
- C++ signature :
- TOOLS::RefCountPtr<PGL::ExplicitModel> transform(PGL::PointSet {lvalue},TOOLS::RefCountPtr<PGL::Transformation3D>)
PointSet2D describes an explicit set of 2D points. See PointSet.
PointSet2D(pointList[,width])
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})
Find closest point in the PointSet from arg
isWidthToDefault( (PointSet2D)arg1) -> bool :
- C++ signature :
- bool isWidthToDefault(PGL::PointSet2D {lvalue})
recast( (PointSet2D)arg1) -> PointSet2D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::PointSet2D> recast(PGL::PointSet2D*)
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.
Polyline(Point3Array pointList, Color4Array colorList = None)
Polyline(Point3Array pointList, Color4Array colorList = None, width = 1)
Polyline(Point3Array pointList, width = 1)
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( (Polyline)arg1) -> Polyline :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Polyline> recast(PGL::Polyline*)
split( (Polyline)arg1, (float)u) -> object :
- C++ signature :
- boost::python::api::object split(PGL::Polyline*,double)
A Polyline2D describes a curve formed by connected 2D segments. It is defined by a set of 2D points. See Polyline.
Polyline2D(pointList[,width])
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([ (float)radius=0.5 [, (int)slices=8]]) -> Polyline2D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Polyline2D> Circle([ double=0.5 [,unsigned char=8]])
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( (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( (Polyline2D)arg1, (float)u) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getNormalAt(PGL::Polyline2D {lvalue},double)
getTangentAt( (Polyline2D)arg1, (float)u) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 getTangentAt(PGL::Polyline2D {lvalue},double)
recast( (Polyline2D)arg1) -> Polyline2D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Polyline2D> recast(PGL::Polyline2D*)
split( (Polyline2D)arg1, (float)u) -> object :
- C++ signature :
- boost::python::api::object split(PGL::Polyline2D*,double)
Abstract base class for all predefined primitives.
Raises an exception This class cannot be instantiated from Python
ProfileInterpolation([Curve2D] profiles,[float] knotList,int degree,int stride
getSectionAt( (ProfileInterpolation)arg1, (float)arg2) -> object :
- C++ signature :
- boost::python::api::object getSectionAt(PGL::ProfileInterpolation*,double)
isDegreeToDefault( (ProfileInterpolation)arg1) -> bool :
- C++ signature :
- bool isDegreeToDefault(PGL::ProfileInterpolation {lvalue})
isStrideToDefault( (ProfileInterpolation)arg1) -> bool :
- C++ signature :
- bool isStrideToDefault(PGL::ProfileInterpolation {lvalue})
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__(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])
colorAt( (QuadSet)arg1, (int)arg2) -> Color4 :
- C++ signature :
- PGL::Color4 colorAt(PGL::QuadSet {lvalue},unsigned int)
colorIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :
- C++ signature :
- TOOLS::Tuple4<unsigned int> colorIndexAt(PGL::QuadSet {lvalue},unsigned int)
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( (QuadSet)arg1, (int)arg2, (int)arg3) -> Color4 :
- C++ signature :
- PGL::Color4 faceColorAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)
faceNormalAt( (QuadSet)arg1, (int)arg2, (int)arg3) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 faceNormalAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)
faceTexCoordAt( (QuadSet)arg1, (int)arg2, (int)arg3) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 faceTexCoordAt(PGL::QuadSet {lvalue},unsigned int,unsigned int)
indexAt( (QuadSet)arg1, (int)arg2) -> Index4 :
- C++ signature :
- TOOLS::Tuple4<unsigned int> indexAt(PGL::QuadSet {lvalue},unsigned int)
isColorIndexListToDefault( (QuadSet)arg1) -> bool :
- C++ signature :
- bool isColorIndexListToDefault(PGL::QuadSet {lvalue})
isNormalIndexListToDefault( (QuadSet)arg1) -> bool :
- C++ signature :
- bool isNormalIndexListToDefault(PGL::QuadSet {lvalue})
isTexCoordIndexListToDefault( (QuadSet)arg1) -> bool :
- C++ signature :
- bool isTexCoordIndexListToDefault(PGL::QuadSet {lvalue})
normalAt( (QuadSet)arg1, (int)arg2) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 normalAt(PGL::QuadSet {lvalue},unsigned int)
normalIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :
- C++ signature :
- TOOLS::Tuple4<unsigned int> normalIndexAt(PGL::QuadSet {lvalue},unsigned int)
recast( (QuadSet)arg1) -> QuadSet :
- C++ signature :
- TOOLS::RefCountPtr<PGL::QuadSet> recast(PGL::QuadSet*)
texCoordAt( (QuadSet)arg1, (int)arg2) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 texCoordAt(PGL::QuadSet {lvalue},unsigned int)
texCoordIndexAt( (QuadSet)arg1, (int)arg2) -> Index4 :
- C++ signature :
- TOOLS::Tuple4<unsigned int> texCoordIndexAt(PGL::QuadSet {lvalue},unsigned int)
A 2D quantised injective function (homomorphism) defined on the range [firstx,lastx].
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.
Function(points [,sampling])
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( (Curve2D)arg1) -> bool :
- C++ signature :
- bool checkQuantisableFunction(TOOLS::RefCountPtr<PGL::Curve2D>)
findX( (QuantisedFunction)arg1, (float)y) -> object :
- C++ signature :
- boost::python::api::object findX(PGL::QuantisedFunction*,double)
findX(y[,startingX]) : find the first x value such as f(x) = y.
getValue( (QuantisedFunction)arg1, (float)x) -> float :
- C++ signature :
- double getValue(PGL::QuantisedFunction*,double)
inverse( (QuantisedFunction)arg1) -> QuantisedFunction :
- C++ signature :
- TOOLS::RefCountPtr<PGL::QuantisedFunction> inverse(PGL::QuantisedFunction {lvalue})
isClampedToDefault( (QuantisedFunction)arg1) -> bool :
- C++ signature :
- bool isClampedToDefault(PGL::QuantisedFunction {lvalue})
isDecreasing( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :
- C++ signature :
- bool isDecreasing(PGL::QuantisedFunction {lvalue} [,bool])
isIncreasing( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :
- C++ signature :
- bool isIncreasing(PGL::QuantisedFunction {lvalue} [,bool])
isMonotonous( (QuantisedFunction)arg1 [, (bool)arg2]) -> bool :
- C++ signature :
- bool isMonotonous(PGL::QuantisedFunction {lvalue} [,bool])
isValid( (QuantisedFunction)arg1) -> bool :
- C++ signature :
- bool isValid(PGL::QuantisedFunction {lvalue})
RealArray(int size)
IndexArray([a,b,...])
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( (RealArray)arg1) -> None :
- C++ signature :
- void clear(TOOLS::RealArray {lvalue})
getId( (RealArray)arg1) -> int :
- C++ signature :
- unsigned long getId(TOOLS::RealArray*)
getPglId( (RealArray)arg1) -> int :
- C++ signature :
- unsigned long getPglId(TOOLS::RealArray {lvalue})
getPglReferenceCount( (RealArray)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(TOOLS::RealArray {lvalue})
insert( (RealArray)arg1, (int)arg2, (float)arg3) -> None :
- C++ signature :
- void insert(TOOLS::RealArray*,int,double)
pop( (RealArray)arg1 [, (int)arg2]) -> float :
- C++ signature :
- double pop(TOOLS::RealArray* [,int])
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( (RealArray)arg1) -> None :
- C++ signature :
- void reverse(TOOLS::RealArray {lvalue})
RealArray2(int rows, int cols)
RealArray2([[a,b,c],[d,e,f]])
clear( (RealArray2)arg1) -> None :
- C++ signature :
- void clear(TOOLS::RealArray2 {lvalue})
empty( (RealArray2)arg1) -> bool :
- C++ signature :
- bool empty(TOOLS::RealArray2 {lvalue})
getColumn( (RealArray2)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getColumn(TOOLS::RealArray2*,unsigned long)
getColumnNb( (RealArray2)arg1) -> int :
- C++ signature :
- unsigned long getColumnNb(TOOLS::RealArray2*)
getDiagonal( (RealArray2)arg1) -> object :
- C++ signature :
- boost::python::api::object getDiagonal(TOOLS::RealArray2*)
getRow( (RealArray2)arg1, (int)arg2) -> object :
- C++ signature :
- boost::python::api::object getRow(TOOLS::RealArray2*,unsigned long)
getRowNb( (RealArray2)arg1) -> int :
- C++ signature :
- unsigned long getRowNb(TOOLS::RealArray2*)
insertColumn( (RealArray2)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertColumn(TOOLS::RealArray2*,unsigned long,boost::python::api::object)
insertRow( (RealArray2)arg1, (int)arg2, (object)arg3) -> None :
- C++ signature :
- void insertRow(TOOLS::RealArray2*,unsigned long,boost::python::api::object)
inverse( (RealArray2)arg1) -> RealArray2 :
- C++ signature :
- TOOLS::RefCountPtr<TOOLS::RealArray2> inverse(TOOLS::RealArray2*)
isUnique( (RealArray2)arg1) -> bool :
- C++ signature :
- bool isUnique(TOOLS::RealArray2 {lvalue})
pushColumn( (RealArray2)arg1, (object)arg2) -> None :
- C++ signature :
- void pushColumn(TOOLS::RealArray2*,boost::python::api::object)
pushRow( (RealArray2)arg1, (object)arg2) -> None :
- C++ signature :
- void pushRow(TOOLS::RealArray2*,boost::python::api::object)
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( (RealArray2)arg1) -> object :
- C++ signature :
- boost::python::api::object svd(TOOLS::RealArray2*)
transpose( (RealArray2)arg1) -> RealArray2 :
- C++ signature :
- TOOLS::RefCountPtr<TOOLS::RealArray2> transpose(TOOLS::RealArray2*)
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.
Revolution(profile [, slices])
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})
recast( (Revolution)arg1) -> Revolution :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Revolution> recast(PGL::Revolution*)
Abstract base class for 3D objects of type of surface of revolution.
Raises an exception This class cannot be instantiated from Python
isSlicesToDefault( (SOR)arg1) -> bool :
- C++ signature :
- bool isSlicesToDefault(PGL::SOR {lvalue})
Abstract base class for 2D objects of type of surface of revolution.
Raises an exception This class cannot be instantiated from Python
isSlicesToDefault( (SOR2D)arg1) -> bool :
- C++ signature :
- bool isSlicesToDefault(PGL::SOR2D {lvalue})
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.
Scaled(scale,geometry)
__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( (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( (Scaled)arg1) -> bool :
- C++ signature :
- bool isScaleToDefault(PGL::Scaled {lvalue})
recast( (Scaled)arg1) -> Scaled :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Scaled> recast(PGL::Scaled*)
__init__( (object)arg1, (Vector3)arg2) -> None :
- C++ signature :
- void __init__(_object*,TOOLS::Vector3)
A 3D Scene defined as a list of objects of type of Shape.
Read a scene from file.
Create a scene with n empty elements.
Create an empty scene.
__init__( (object)arg1, (list)arg2) -> object :
- C++ signature :
- void* __init__(boost::python::api::object,boost::python::list)
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 scene from id.
get all scene.
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>)
apply( (Scene)arg1, (Action)arg2) -> bool :
- C++ signature :
- bool apply(PGL::Scene {lvalue},PGL::Action {lvalue})
applyAppearanceFirst( (Scene)arg1, (Action)arg2) -> bool :
- C++ signature :
- bool applyAppearanceFirst(PGL::Scene {lvalue},PGL::Action {lvalue})
applyAppearanceOnly( (Scene)arg1, (Action)arg2) -> bool :
- C++ signature :
- bool applyAppearanceOnly(PGL::Scene {lvalue},PGL::Action {lvalue})
applyGeometryFirst( (Scene)arg1, (Action)arg2) -> bool :
- C++ signature :
- bool applyGeometryFirst(PGL::Scene {lvalue},PGL::Action {lvalue})
applyGeometryOnly( (Scene)arg1, (Action)arg2) -> bool :
- C++ signature :
- bool applyGeometryOnly(PGL::Scene {lvalue},PGL::Action {lvalue})
clear( (Scene)arg1) -> None :
- C++ signature :
- void clear(PGL::Scene {lvalue})
deepcopy( (Scene)arg1) -> Scene :
- C++ signature :
- 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})
find( (Scene)arg1, (int)arg2) -> Shape :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Shape> find(PGL::Scene*,unsigned long)
findSceneObject( (Scene)arg1, (int)arg2) -> Shape3D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Shape3D> findSceneObject(PGL::Scene*,unsigned long)
getId( (Scene)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::Scene {lvalue})
getPglReferenceCount( (Scene)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::Scene {lvalue})
index( (Scene)arg1, (Shape3D)arg2) -> int :
- C++ signature :
- unsigned int index(PGL::Scene*,TOOLS::RefCountPtr<PGL::Shape3D>)
isValid( (Scene)arg1) -> bool :
- C++ signature :
- bool isValid(PGL::Scene {lvalue})
merge( (Scene)arg1, (Scene)arg2) -> None :
- C++ signature :
- void merge(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)
merge( (Scene)arg1, (Scene)arg2) -> None :
- C++ signature :
- void merge(PGL::Scene {lvalue},TOOLS::RefCountPtr<PGL::Scene>)
Scene pool singleton access
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)
remove( (Scene)arg1, (Shape3D)arg2) -> None :
- C++ signature :
- void remove(PGL::Scene*,TOOLS::RefCountPtr<PGL::Shape3D>)
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)
sort( (Scene)arg1) -> None :
- C++ signature :
- void sort(PGL::Scene {lvalue})
Coder/Decoder of a scene description.
SceneCodec([name,mode])
Enum representing coding and decoding capabilities of a codec.
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})
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)
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)
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>)
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( (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() -> SceneFactory :
- C++ signature :
- PGL::SceneFactory {lvalue} get()
isReadable( (SceneFactory)arg1, (str)arg2) -> bool :
- C++ signature :
- bool isReadable(PGL::SceneFactory {lvalue},std::string)
isWritable( (SceneFactory)arg1, (str)arg2) -> bool :
- C++ signature :
- bool isWritable(PGL::SceneFactory {lvalue},std::string)
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( (SceneFactory)arg1, (SceneCodec)arg2) -> None :
- C++ signature :
- void registerCodec(PGL::SceneFactory {lvalue},TOOLS::RefCountPtr<PGL::SceneCodec>)
unregisterCodec( (SceneFactory)arg1, (SceneCodec)arg2) -> None :
- C++ signature :
- void unregisterCodec(PGL::SceneFactory {lvalue},TOOLS::RefCountPtr<PGL::SceneCodec>)
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)
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)
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( (SceneFormatList)arg1, (object)arg2) -> None :
- C++ signature :
- void append(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)
extend( (SceneFormatList)arg1, (object)arg2) -> None :
- C++ signature :
- void extend(std::vector<PGL::SceneFormat, std::allocator<PGL::SceneFormat> > {lvalue},boost::python::api::object)
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( (SceneObject)arg1, (Action)arg2) -> bool :
- C++ signature :
- bool apply(PGL::SceneObject {lvalue},PGL::Action {lvalue})
getId( (SceneObject)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::SceneObject {lvalue})
getName( (SceneObject)arg1) -> str :
- C++ signature :
- std::string getName(PGL::SceneObject {lvalue})
getPglReferenceCount( (SceneObject)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::SceneObject {lvalue})
isNamed( (SceneObject)arg1) -> bool :
- C++ signature :
- bool isNamed(PGL::SceneObject {lvalue})
isValid( (SceneObject)arg1) -> bool :
- C++ signature :
- bool isValid(PGL::SceneObject {lvalue})
setName( (SceneObject)arg1, (str)arg2) -> None :
- C++ signature :
- void setName(PGL::SceneObject {lvalue},std::string)
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.
Shape( geometry, appearance, id, parentId )
Shape( geometry, appearance, id, parentId )
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})
getSceneObjectId( (Shape)arg1) -> int :
- C++ signature :
- unsigned int getSceneObjectId(PGL::Shape const*)
recast( (Shape)arg1) -> Shape :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Shape> recast(PGL::Shape*)
setComputedName( (Shape)arg1) -> None :
- C++ signature :
- void setComputedName(PGL::Shape {lvalue})
Abstract base class for shape that can be stored into a scene.
Raises an exception This class cannot be instantiated from Python
Abstract base class for all spectrum objects.
Raises an exception This class cannot be instantiated from Python
Sphere(radius [,slices, stacks])
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( (Sphere)arg1) -> bool :
- C++ signature :
- bool isRadiusToDefault(PGL::Sphere {lvalue})
isStacksToDefault( (Sphere)arg1) -> bool :
- C++ signature :
- bool isStacksToDefault(PGL::Sphere {lvalue})
recast( (Sphere)arg1) -> Sphere :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Sphere> recast(PGL::Sphere*)
A surface defined by the revolution and interpolation of several 2D profiles along Z axis.
Swung(profileList,angleList,slices,ccw,degree,stride)
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})
isCCWToDefault( (Swung)arg1) -> bool :
- C++ signature :
- bool isCCWToDefault(PGL::Swung {lvalue})
isDegreeToDefault( (Swung)arg1) -> bool :
- C++ signature :
- bool isDegreeToDefault(PGL::Swung {lvalue})
isStrideToDefault( (Swung)arg1) -> bool :
- C++ signature :
- bool isStrideToDefault(PGL::Swung {lvalue})
recast( (Swung)arg1) -> Swung :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Swung> recast(PGL::Swung*)
__init__( (object)arg1, (float)arg2, (float)arg3) -> None :
- C++ signature :
- void __init__(_object*,double,double)
getBaseRadius( (Taper)arg1) -> float :
- C++ signature :
- double getBaseRadius(PGL::Taper {lvalue})
getTopRadius( (Taper)arg1) -> float :
- C++ signature :
- double getTopRadius(PGL::Taper {lvalue})
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.
Tapered(baseRadius, topRadius, primitive)
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( (Tapered)arg1) -> bool :
- C++ signature :
- bool isBaseRadiusToDefault(PGL::Tapered {lvalue})
isTopRadiusToDefault( (Tapered)arg1) -> bool :
- C++ signature :
- bool isTopRadiusToDefault(PGL::Tapered {lvalue})
recast( (Tapered)arg1) -> Tapered :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Tapered> recast(PGL::Tapered*)
Text with font. It support display in screen or world coordinates.
Text(str string[, Vector3 position, bool screencoordinates, Font fontstyle])
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})
isFontStyleToDefault( (Text)arg1) -> bool :
- C++ signature :
- bool isFontStyleToDefault(PGL::Text {lvalue})
isPositionToDefault( (Text)arg1) -> bool :
- C++ signature :
- bool isPositionToDefault(PGL::Text {lvalue})
isScreenCoordinatesToDefault( (Text)arg1) -> bool :
- C++ signature :
- bool isScreenCoordinatesToDefault(PGL::Text {lvalue})
recast( (Text)arg1) -> Text :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Text> recast(PGL::Text*)
The material of a textured object.
Texture2D(image [,transformation])
Texture2D(name, image [,transformation])
isTransformationToDefault( (Texture2D)arg1) -> bool :
- C++ signature :
- bool isTransformationToDefault(PGL::Texture2D {lvalue})
The transformation of a texture 2D.
Texture2D([name,scale,translation,rotationCenter,rotationAngle])
isRotationAngleToDefault( (Texture2DTransformation)arg1) -> bool :
- C++ signature :
- bool isRotationAngleToDefault(PGL::Texture2DTransformation {lvalue})
isRotationCenterToDefault( (Texture2DTransformation)arg1) -> bool :
- C++ signature :
- bool isRotationCenterToDefault(PGL::Texture2DTransformation {lvalue})
isScaleToDefault( (Texture2DTransformation)arg1) -> bool :
- C++ signature :
- bool isScaleToDefault(PGL::Texture2DTransformation {lvalue})
isTranslationToDefault( (Texture2DTransformation)arg1) -> bool :
- C++ signature :
- bool isTranslationToDefault(PGL::Texture2DTransformation {lvalue})
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)
__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)
Return scale, rotate and translate corresponding values.
compute the Matrix3 determinant of the transformation
isValid( (Transform4)arg1) -> bool :
- C++ signature :
- bool isValid(PGL::Transform4 {lvalue})
Add a rotation at the transformation
Add a scaling at the transformation
transform a set of points
Add a translation at the transformation
Transform4Array(int size)
Transform4Array([Transform4(...),...])
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( (Transform4Array)arg1) -> None :
- C++ signature :
- void clear(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
getId( (Transform4Array)arg1) -> int :
- C++ signature :
- unsigned long getId(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*)
getPglId( (Transform4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglId(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
getPglReferenceCount( (Transform4Array)arg1) -> int :
- C++ signature :
- unsigned long getPglReferenceCount(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
insert( (Transform4Array)arg1, (int)arg2, (Transform4)arg3) -> None :
- C++ signature :
- void insert(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >*,int,TOOLS::RefCountPtr<PGL::Transform4>)
pop( (Transform4Array)arg1 [, (int)arg2]) -> Transform4 :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Transform4> pop(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> >* [,int])
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( (Transform4Array)arg1) -> None :
- C++ signature :
- void reverse(PGL::ObjectArray<TOOLS::RefCountPtr<PGL::Transform4> > {lvalue})
Raises an exception This class cannot be instantiated from Python
Raises an exception This class cannot be instantiated from Python
transform( (Transformation2D)arg1, (Point2Array)arg2) -> Point2Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point2Array> transform(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point2Array>)
transformP2Matrix( (Transformation2D)arg1, (Point2Matrix)arg2) -> Point2Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point2Matrix> transformP2Matrix(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point2Matrix>)
transformP3List( (Transformation2D)arg1, (Point3Array)arg2) -> Point3Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point3Array> transformP3List(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)
transformP3Matrix( (Transformation2D)arg1, (Point3Matrix)arg2) -> Point3Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation2D {lvalue},TOOLS::RefCountPtr<PGL::Point3Matrix>)
Raises an exception This class cannot be instantiated from Python
transform( (Transformation3D)arg1, (Point3Array)arg2) -> Point3Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point3Array> transform(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point3Array>)
transformP3Matrix( (Transformation3D)arg1, (Point3Matrix)arg2) -> Point3Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point3Matrix> transformP3Matrix(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point3Matrix>)
transformP4List( (Transformation3D)arg1, (Point4Array)arg2) -> Point4Array :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point4Array> transformP4List(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point4Array>)
transformP4Matrix( (Transformation3D)arg1, (Point4Matrix)arg2) -> Point4Matrix :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Point4Matrix> transformP4Matrix(PGL::Transformation3D {lvalue},TOOLS::RefCountPtr<PGL::Point4Matrix>)
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( (Transformed)arg1) -> Transformation3D :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Transformation3D> transformation(PGL::Transformed {lvalue})
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.
Translated(translation,geometry)
__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( (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( (Translated)arg1) -> bool :
- C++ signature :
- bool isTranslationToDefault(PGL::Translated {lvalue})
recast( (Translated)arg1) -> Translated :
- C++ signature :
- TOOLS::RefCountPtr<PGL::Translated> recast(PGL::Translated*)
__init__( (object)arg1, (Vector3)arg2) -> None :
- C++ signature :
- void __init__(_object*,TOOLS::Vector3)
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__(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])
colorAt( (TriangleSet)arg1, (int)arg2) -> Color4 :
- C++ signature :
- PGL::Color4 colorAt(PGL::TriangleSet {lvalue},unsigned int)
colorIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :
- C++ signature :
- TOOLS::Tuple3<unsigned int> colorIndexAt(PGL::TriangleSet {lvalue},unsigned int)
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( (TriangleSet)arg1, (int)arg2, (int)arg3) -> Color4 :
- C++ signature :
- PGL::Color4 faceColorAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)
faceNormalAt( (TriangleSet)arg1, (int)arg2, (int)arg3) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 faceNormalAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)
faceTexCoordAt( (TriangleSet)arg1, (int)arg2, (int)arg3) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 faceTexCoordAt(PGL::TriangleSet {lvalue},unsigned int,unsigned int)
indexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :
- C++ signature :
- TOOLS::Tuple3<unsigned int> indexAt(PGL::TriangleSet {lvalue},unsigned int)
isColorIndexListToDefault( (TriangleSet)arg1) -> bool :
- C++ signature :
- bool isColorIndexListToDefault(PGL::TriangleSet {lvalue})
isNormalIndexListToDefault( (TriangleSet)arg1) -> bool :
- C++ signature :
- bool isNormalIndexListToDefault(PGL::TriangleSet {lvalue})
isTexCoordIndexListToDefault( (TriangleSet)arg1) -> bool :
- C++ signature :
- bool isTexCoordIndexListToDefault(PGL::TriangleSet {lvalue})
normalAt( (TriangleSet)arg1, (int)arg2) -> Vector3 :
- C++ signature :
- TOOLS::Vector3 normalAt(PGL::TriangleSet {lvalue},unsigned int)
normalIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :
- C++ signature :
- TOOLS::Tuple3<unsigned int> normalIndexAt(PGL::TriangleSet {lvalue},unsigned int)
recast( (TriangleSet)arg1) -> TriangleSet :
- C++ signature :
- TOOLS::RefCountPtr<PGL::TriangleSet> recast(PGL::TriangleSet*)
texCoordAt( (TriangleSet)arg1, (int)arg2) -> Vector2 :
- C++ signature :
- TOOLS::Vector2 texCoordAt(PGL::TriangleSet {lvalue},unsigned int)
texCoordIndexAt( (TriangleSet)arg1, (int)arg2) -> Index3 :
- C++ signature :
- TOOLS::Tuple3<unsigned int> texCoordIndexAt(PGL::TriangleSet {lvalue},unsigned int)
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() -> float :
- C++ signature :
- float getPGLVersion()
get_pgl_python_error_style() -> bool :
- C++ signature :
- bool get_pgl_python_error_style()
Gives all extensions supported by current version of PlantGL.
Tell wether PlantGL support a given extension
set_pgl_python_error_style( (bool)arg1) -> None :
- C++ signature :
- void set_pgl_python_error_style(bool)
Class Cardinal Spline. A cardinal spline is a spline passing through a set of points.
A CSpline interpolate a set of points.
Create a CSpline from a set of 2d or 3d points.
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.
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.
Build a nurbs curve by interpolate (C1) the points pts. The resulting curve can be closed.
The norm of the vector. If v.__norm__() exists, call it.
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]]]]]]]]]]]]])