3. Algorithm library

3.1. Class Inheritance diagram

3.2. openalea.plantgl.algo module

class ANNKDTree2

class ANNKDTree3

class ANNKDTree4

class AbstractKDTree2

k_closest_points((AbstractKDTree2)arg1, (Vector2)point, (object)k[, (object)maxdist=1.7976931348623157e+308]) → Index :

Return the k closest points of point

C++ signature :

PGL::PglVector<unsigned int> k_closest_points(PGL::AbstractKDTree<PGL::Point2Array> {lvalue},PGL::Vector2,unsigned long [,double=1.7976931348623157e+308])

k_nearest_neighbors((AbstractKDTree2)arg1, (object)k) → IndexArray :

Return the k closest points for each point in the kdtree

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> k_nearest_neighbors(PGL::AbstractKDTree<PGL::Point2Array> {lvalue},unsigned long)

r_nearest_neighbors((AbstractKDTree2)arg1, (object)radius) → IndexArray :

Return points at a distance inf of radius for each point in the kdtree

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_nearest_neighbors(PGL::AbstractKDTree<PGL::Point2Array> {lvalue},double)

size((AbstractKDTree2)arg1) → int :

Return the number of point in the kdtree.

C++ signature :

unsigned long size(PGL::AbstractKDTree<PGL::Point2Array> {lvalue})

class AbstractKDTree3

k_closest_points((AbstractKDTree3)arg1, (Vector3)point, (object)k[, (object)maxdist=1.7976931348623157e+308]) → Index :

Return the k closest points of point

C++ signature :

PGL::PglVector<unsigned int> k_closest_points(PGL::AbstractKDTree<PGL::Point3Array> {lvalue},PGL::Vector3,unsigned long [,double=1.7976931348623157e+308])

k_nearest_neighbors((AbstractKDTree3)arg1, (object)k) → IndexArray :

Return the k closest points for each point in the kdtree

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> k_nearest_neighbors(PGL::AbstractKDTree<PGL::Point3Array> {lvalue},unsigned long)

r_nearest_neighbors((AbstractKDTree3)arg1, (object)radius) → IndexArray :

Return points at a distance inf of radius for each point in the kdtree

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_nearest_neighbors(PGL::AbstractKDTree<PGL::Point3Array> {lvalue},double)

size((AbstractKDTree3)arg1) → int :

Return the number of point in the kdtree.

C++ signature :

unsigned long size(PGL::AbstractKDTree<PGL::Point3Array> {lvalue})

class AbstractKDTree4

k_closest_points((AbstractKDTree4)arg1, (Vector4)point, (object)k[, (object)maxdist=1.7976931348623157e+308]) → Index :

Return the k closest points of point

C++ signature :

PGL::PglVector<unsigned int> k_closest_points(PGL::AbstractKDTree<PGL::Point4Array> {lvalue},PGL::Vector4,unsigned long [,double=1.7976931348623157e+308])

k_nearest_neighbors((AbstractKDTree4)arg1, (object)k) → IndexArray :

Return the k closest points for each point in the kdtree

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> k_nearest_neighbors(PGL::AbstractKDTree<PGL::Point4Array> {lvalue},unsigned long)

r_nearest_neighbors((AbstractKDTree4)arg1, (object)radius) → IndexArray :

Return points at a distance inf of radius for each point in the kdtree

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_nearest_neighbors(PGL::AbstractKDTree<PGL::Point4Array> {lvalue},double)

size((AbstractKDTree4)arg1) → int :

Return the number of point in the kdtree.

C++ signature :

unsigned long size(PGL::AbstractKDTree<PGL::Point4Array> {lvalue})

class Action

beginProcess((Action)arg1) → bool :

Called at the begining of the processing of a scene

C++ signature :

bool beginProcess(PGL::Action {lvalue})

endProcess((Action)arg1) → bool :

Called at the begining of the processing of a scene

C++ signature :

bool endProcess(PGL::Action {lvalue})

process((Action)arg1, (Shape)object) → bool :

Process object of type Shape

C++ signature :

bool process(PGL::Action {lvalue},PGL::Shape*)

process( (Action)arg1, (object)object) -> bool :

Process object of type Inline

C++ signature :

bool process(PGL::Action {lvalue},PGL::Inline*)

process( (Action)arg1, (Material)object) -> bool :

Process object of type Material

C++ signature :

bool process(PGL::Action {lvalue},PGL::Material*)

process( (Action)arg1, (MonoSpectral)object) -> bool :

Process object of type MonoSpectral

C++ signature :

bool process(PGL::Action {lvalue},PGL::MonoSpectral*)

process( (Action)arg1, (MultiSpectral)object) -> bool :

Process object of type MultiSpectral

C++ signature :

bool process(PGL::Action {lvalue},PGL::MultiSpectral*)

process( (Action)arg1, (ImageTexture)object) -> bool :

Process object of type ImageTexture

C++ signature :

bool process(PGL::Action {lvalue},PGL::ImageTexture*)

process( (Action)arg1, (AmapSymbol)object) -> bool :

Process object of type AmapSymbol

C++ signature :

bool process(PGL::Action {lvalue},PGL::AmapSymbol*)

process( (Action)arg1, (AsymmetricHull)object) -> bool :

Process object of type AsymmetricHull

C++ signature :

bool process(PGL::Action {lvalue},PGL::AsymmetricHull*)

process( (Action)arg1, (AxisRotated)object) -> bool :

Process object of type AxisRotated

C++ signature :

bool process(PGL::Action {lvalue},PGL::AxisRotated*)

process( (Action)arg1, (BezierCurve)object) -> bool :

Process object of type BezierCurve

C++ signature :

bool process(PGL::Action {lvalue},PGL::BezierCurve*)

process( (Action)arg1, (BezierPatch)object) -> bool :

Process object of type BezierPatch

C++ signature :

bool process(PGL::Action {lvalue},PGL::BezierPatch*)

process( (Action)arg1, (Box)object) -> bool :

Process object of type Box

C++ signature :

bool process(PGL::Action {lvalue},PGL::Box*)

process( (Action)arg1, (Cone)object) -> bool :

Process object of type Cone

C++ signature :

bool process(PGL::Action {lvalue},PGL::Cone*)

process( (Action)arg1, (Cylinder)object) -> bool :

Process object of type Cylinder

C++ signature :

bool process(PGL::Action {lvalue},PGL::Cylinder*)

process( (Action)arg1, (ElevationGrid)object) -> bool :

Process object of type ElevationGrid

C++ signature :

bool process(PGL::Action {lvalue},PGL::ElevationGrid*)

process( (Action)arg1, (EulerRotated)object) -> bool :

Process object of type EulerRotated

C++ signature :

bool process(PGL::Action {lvalue},PGL::EulerRotated*)

process( (Action)arg1, (ExtrudedHull)object) -> bool :

Process object of type ExtrudedHull

C++ signature :

bool process(PGL::Action {lvalue},PGL::ExtrudedHull*)

process( (Action)arg1, (FaceSet)object) -> bool :

Process object of type FaceSet

C++ signature :

bool process(PGL::Action {lvalue},PGL::FaceSet*)

process( (Action)arg1, (Frustum)object) -> bool :

Process object of type Frustum

C++ signature :

bool process(PGL::Action {lvalue},PGL::Frustum*)

process( (Action)arg1, (Extrusion)object) -> bool :

Process object of type Extrusion

C++ signature :

bool process(PGL::Action {lvalue},PGL::Extrusion*)

process( (Action)arg1, (Group)object) -> bool :

Process object of type Group

C++ signature :

bool process(PGL::Action {lvalue},PGL::Group*)

process( (Action)arg1, (IFS)object) -> bool :

Process object of type IFS

C++ signature :

bool process(PGL::Action {lvalue},PGL::IFS*)

process( (Action)arg1, (NurbsCurve)object) -> bool :

Process object of type NurbsCurve

C++ signature :

bool process(PGL::Action {lvalue},PGL::NurbsCurve*)

process( (Action)arg1, (NurbsPatch)object) -> bool :

Process object of type NurbsPatch

C++ signature :

bool process(PGL::Action {lvalue},PGL::NurbsPatch*)

process( (Action)arg1, (Oriented)object) -> bool :

Process object of type Oriented

C++ signature :

bool process(PGL::Action {lvalue},PGL::Oriented*)

process( (Action)arg1, (Paraboloid)object) -> bool :

Process object of type Paraboloid

C++ signature :

bool process(PGL::Action {lvalue},PGL::Paraboloid*)

process( (Action)arg1, (PointSet)object) -> bool :

Process object of type PointSet

C++ signature :

bool process(PGL::Action {lvalue},PGL::PointSet*)

process( (Action)arg1, (Polyline)object) -> bool :

Process object of type Polyline

C++ signature :

bool process(PGL::Action {lvalue},PGL::Polyline*)

process( (Action)arg1, (QuadSet)object) -> bool :

Process object of type QuadSet

C++ signature :

bool process(PGL::Action {lvalue},PGL::QuadSet*)

process( (Action)arg1, (Revolution)object) -> bool :

Process object of type Revolution

C++ signature :

bool process(PGL::Action {lvalue},PGL::Revolution*)

process( (Action)arg1, (Swung)object) -> bool :

Process object of type Swung

C++ signature :

bool process(PGL::Action {lvalue},PGL::Swung*)

process( (Action)arg1, (Scaled)object) -> bool :

Process object of type Scaled

C++ signature :

bool process(PGL::Action {lvalue},PGL::Scaled*)

process( (Action)arg1, (Sphere)object) -> bool :

Process object of type Sphere

C++ signature :

bool process(PGL::Action {lvalue},PGL::Sphere*)

process( (Action)arg1, (Tapered)object) -> bool :

Process object of type Tapered

C++ signature :

bool process(PGL::Action {lvalue},PGL::Tapered*)

process( (Action)arg1, (Translated)object) -> bool :

Process object of type Translated

C++ signature :

bool process(PGL::Action {lvalue},PGL::Translated*)

process( (Action)arg1, (TriangleSet)object) -> bool :

Process object of type TriangleSet

C++ signature :

bool process(PGL::Action {lvalue},PGL::TriangleSet*)

process( (Action)arg1, (BezierCurve2D)object) -> bool :

Process object of type BezierCurve2D

C++ signature :

bool process(PGL::Action {lvalue},PGL::BezierCurve2D*)

process( (Action)arg1, (Disc)object) -> bool :

Process object of type Disc

C++ signature :

bool process(PGL::Action {lvalue},PGL::Disc*)

process( (Action)arg1, (NurbsCurve2D)object) -> bool :

Process object of type NurbsCurve2D

C++ signature :

bool process(PGL::Action {lvalue},PGL::NurbsCurve2D*)

process( (Action)arg1, (PointSet2D)object) -> bool :

Process object of type PointSet2D

C++ signature :

bool process(PGL::Action {lvalue},PGL::PointSet2D*)

process( (Action)arg1, (Polyline2D)object) -> bool :

Process object of type Polyline2D

C++ signature :

bool process(PGL::Action {lvalue},PGL::Polyline2D*)

class AmapTranslator

isNormalized((AmapTranslator)arg1) → bool :

C++ signature :

bool isNormalized(PGL::AmapTranslator {lvalue})

property result

setNormalized((AmapTranslator)arg1, (object)arg2) → None :

C++ signature :

void setNormalized(PGL::AmapTranslator {lvalue},bool)

property symbol

class BBoxComputer

property boundingbox

Return the last computed Bounding Box.

clear((BBoxComputer)arg1) → None :

C++ signature :

void clear(PGL::BBoxComputer {lvalue})

process((BBoxComputer)arg1, (Scene)arg2) → bool :

C++ signature :

bool process(PGL::BBoxComputer*,PGL::RefCountPtr<PGL::Scene>)

property result

class CurveIntersection

static check((object)arg1) → bool :

check whether an interesection between polylines exists. Requires CGAL extension.

C++ signature :

bool check(boost::python::api::object)

static compute((object)arg1) → Point2Array :

compute the interesection between polylines. Requires CGAL extension.

C++ signature :

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

class DepthSortEngine

getProjectionResult((DepthSortEngine)arg1[, (eColor4Format)format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB[, (object)cameraCoordinates=True]]) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> getProjectionResult(PGL::DepthSortEngine {lvalue} [,PGL::Color4::eColor4Format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB [,bool=True]])

getResult((DepthSortEngine)arg1[, (eColor4Format)format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB[, (object)cameraCoordinates=True]]) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> getResult(PGL::DepthSortEngine {lvalue} [,PGL::Color4::eColor4Format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB [,bool=True]])

processTriangle((DepthSortEngine)arg1, (Vector3)arg2, (Vector3)arg3, (Vector3)arg4, (object)arg5) → None :

C++ signature :

void processTriangle(PGL::DepthSortEngine {lvalue},PGL::Vector3,PGL::Vector3,PGL::Vector3,unsigned int)

class Discretizer

clear((Discretizer)arg1) → None :

C++ signature :

void clear(PGL::Discretizer {lvalue})

property discretization

Return the last computed discretization.

property result

property texCoord

class FilePrinter

class FileVrmlPrinter

class Fit

aalignedbox((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> aalignedbox(PGL::Fit {lvalue})

abox((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> abox(PGL::Fit {lvalue})

acylinder((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> acylinder(PGL::Fit {lvalue})

aellipsoid((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> aellipsoid(PGL::Fit {lvalue})

alphashape((Fit)arg1[, (object)alpha=0]) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> alphashape(PGL::Fit {lvalue} [,double=0])

static areRadiusNeeded((str)arg1) → bool :

C++ signature :

bool areRadiusNeeded(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

asphere((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> asphere(PGL::Fit {lvalue})

asymmetricHull((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> asymmetricHull(PGL::Fit {lvalue})

static available((str)arg1) → bool :

C++ signature :

bool available(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

balignedbox((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> balignedbox(PGL::Fit {lvalue})

bbox((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> bbox(PGL::Fit {lvalue})

bcylinder((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> bcylinder(PGL::Fit {lvalue})

bellipsoid((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> bellipsoid(PGL::Fit {lvalue})

static boundingCircle((Point2Array)points) → object :

C++ signature :

boost::python::api::object boundingCircle(PGL::Point2Array*)

box((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> box(PGL::Fit {lvalue})

bsphere((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> bsphere(PGL::Fit {lvalue})

convexHull((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> convexHull(PGL::Fit {lvalue})

static convexPolyline((Point2Array)arg1) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> convexPolyline(PGL::RefCountPtr<PGL::Point2Array>)

cylinder((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> cylinder(PGL::Fit {lvalue})

ellipsoid((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> ellipsoid(PGL::Fit {lvalue})

ellipsoid2((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> ellipsoid2(PGL::Fit {lvalue})

extrudedHull((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> extrudedHull(PGL::Fit {lvalue})

static fitShapeFactor((object)x, (object)r, (object)y, (object)h) → float :

C++ signature :

double fitShapeFactor(double,double,double,double)

static getClassNames() → list :

C++ signature :

boost::python::list getClassNames()

static getVolumeClassNames() → list :

C++ signature :

boost::python::list getVolumeClassNames()

static inertiaAxis((Point3Array)points) → object :

C++ signature :

boost::python::api::object inertiaAxis(PGL::Point3Array*)

inertiaAxis( (Point2Array)points) -> object :

C++ signature :

boost::python::api::object inertiaAxis(PGL::Point2Array*)

static nurbsCurve((Point3Array)points, (object)degree, (object)nbctrlpoints) → LineicModel :

C++ signature :

PGL::RefCountPtr<PGL::LineicModel> nurbsCurve(PGL::RefCountPtr<PGL::Point3Array>,int,int)

static plane((Point3Array)points[, (Index)subset=Index()]) → object :

C++ signature :

boost::python::api::object plane(PGL::Point3Array* [,PGL::PglVector<unsigned int>=Index()])

property points

property radius

sphere((Fit)arg1) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> sphere(PGL::Fit {lvalue})

use((Fit)arg1, (str)arg2) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> use(PGL::Fit {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class GLBBoxRenderer

class GLCtrlPointRenderer

DEFAULT_APPEARANCE = Material(ambient=Color3(255,0,0),diffuse=1,)

class GLRenderer

Dynamic = openalea.plantgl.algo._pglalgo.RenderingMode.Dynamic

DynamicPrimitive = openalea.plantgl.algo._pglalgo.RenderingMode.DynamicPrimitive

DynamicScene = openalea.plantgl.algo._pglalgo.RenderingMode.DynamicScene

Normal = openalea.plantgl.algo._pglalgo.RenderingMode.Normal

PrimitiveId = openalea.plantgl.algo._pglalgo.SelectionId.PrimitiveId

class RenderingMode

Dynamic = openalea.plantgl.algo._pglalgo.RenderingMode.Dynamic

DynamicPrimitive = openalea.plantgl.algo._pglalgo.RenderingMode.DynamicPrimitive

DynamicScene = openalea.plantgl.algo._pglalgo.RenderingMode.DynamicScene

Normal = openalea.plantgl.algo._pglalgo.RenderingMode.Normal

Selection = openalea.plantgl.algo._pglalgo.RenderingMode.Selection

names = {'Dynamic': openalea.plantgl.algo._pglalgo.RenderingMode.Dynamic, 'DynamicPrimitive': openalea.plantgl.algo._pglalgo.RenderingMode.DynamicPrimitive, 'DynamicScene': openalea.plantgl.algo._pglalgo.RenderingMode.DynamicScene, 'Normal': openalea.plantgl.algo._pglalgo.RenderingMode.Normal, 'Selection': openalea.plantgl.algo._pglalgo.RenderingMode.Selection}

values = {1: openalea.plantgl.algo._pglalgo.RenderingMode.Normal, 2: openalea.plantgl.algo._pglalgo.RenderingMode.Selection, 4: openalea.plantgl.algo._pglalgo.RenderingMode.DynamicScene, 8: openalea.plantgl.algo._pglalgo.RenderingMode.DynamicPrimitive, 12: openalea.plantgl.algo._pglalgo.RenderingMode.Dynamic}

SceneObjectId = openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectId

SceneObjectNPrimitive = openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectNPrimitive

Selection = openalea.plantgl.algo._pglalgo.RenderingMode.Selection

class SelectionId

PrimitiveId = openalea.plantgl.algo._pglalgo.SelectionId.PrimitiveId

SceneObjectId = openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectId

SceneObjectNPrimitive = openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectNPrimitive

ShapeId = openalea.plantgl.algo._pglalgo.SelectionId.ShapeId

ShapeNPrimitiveIds = openalea.plantgl.algo._pglalgo.SelectionId.ShapeNPrimitiveIds

names = {'PrimitiveId': openalea.plantgl.algo._pglalgo.SelectionId.PrimitiveId, 'SceneObjectId': openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectId, 'SceneObjectNPrimitive': openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectNPrimitive, 'ShapeId': openalea.plantgl.algo._pglalgo.SelectionId.ShapeId, 'ShapeNPrimitiveIds': openalea.plantgl.algo._pglalgo.SelectionId.ShapeNPrimitiveIds}

values = {1: openalea.plantgl.algo._pglalgo.SelectionId.ShapeId, 2: openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectId, 4: openalea.plantgl.algo._pglalgo.SelectionId.PrimitiveId, 5: openalea.plantgl.algo._pglalgo.SelectionId.ShapeNPrimitiveIds, 6: openalea.plantgl.algo._pglalgo.SelectionId.SceneObjectNPrimitive}

ShapeId = openalea.plantgl.algo._pglalgo.SelectionId.ShapeId

ShapeNPrimitiveIds = openalea.plantgl.algo._pglalgo.SelectionId.ShapeNPrimitiveIds

beginSceneList((GLRenderer)arg1) → bool :

C++ signature :

bool beginSceneList(PGL::GLRenderer {lvalue})

clear((GLRenderer)arg1) → None :

C++ signature :

void clear(PGL::GLRenderer {lvalue})

clearSceneList((GLRenderer)arg1) → None :

C++ signature :

void clearSceneList(PGL::GLRenderer {lvalue})

endSceneList((GLRenderer)arg1) → None :

C++ signature :

void endSceneList(PGL::GLRenderer {lvalue})

getDiscretizer((GLRenderer)arg1) → Discretizer :

C++ signature :

PGL::Discretizer {lvalue} getDiscretizer(PGL::GLRenderer {lvalue})

init((GLRenderer)arg1) → None :

C++ signature :

void init(PGL::GLRenderer {lvalue})

property renderingMode

property selectionMode

setGLFrame((GLRenderer)arg1, (object)arg2) → None :

C++ signature :

void setGLFrame(PGL::GLRenderer*,boost::python::api::object)

setGLFrameFromId((GLRenderer)arg1, (int)arg2) → bool :

C++ signature :

bool setGLFrameFromId(PGL::GLRenderer {lvalue},unsigned long long)

class GLSkelRenderer

class GraphColonization

EndEach((GraphColonization)arg1) → None :

C++ signature :

void EndEach(PGL::GraphColonization {lvalue})

EndEach( (GraphColonization)arg1) -> None :

C++ signature :

void EndEach(PyGraphColonization {lvalue})

StartEach((GraphColonization)arg1) → None :

C++ signature :

void StartEach(PGL::GraphColonization {lvalue})

StartEach( (GraphColonization)arg1) -> None :

C++ signature :

void StartEach(PyGraphColonization {lvalue})

activate_all((GraphColonization)arg1) → None :

C++ signature :

void activate_all(PGL::GraphColonization {lvalue})

activate_leaves((GraphColonization)arg1) → None :

C++ signature :

void activate_leaves(PGL::GraphColonization {lvalue})

activate_node((GraphColonization)arg1, (object)arg2) → None :

C++ signature :

void activate_node(PGL::GraphColonization {lvalue},unsigned long)

active_nodes((GraphColonization)arg1) → Index :

C++ signature :

PGL::PglVector<unsigned int> active_nodes(PGL::GraphColonization {lvalue})

add_bud((GraphColonization)arg1, (object)pid, (Index)attractors, (object)level) → None :

C++ signature :

void add_bud(PyGraphColonization {lvalue},unsigned long,PGL::PglVector<unsigned int>,double)

add_node((GraphColonization)arg1, (Vector3)position, (object)level, (Index)components[, (object)parent=4294967295[, (object)active=True]]) → int :

C++ signature :

unsigned long add_node(PGL::GraphColonization {lvalue},PGL::Vector3,double,PGL::PglVector<unsigned int> [,unsigned long=4294967295 [,bool=True]])

property coneangle

desactivate_node((GraphColonization)arg1, (object)arg2) → None :

C++ signature :

void desactivate_node(PGL::GraphColonization {lvalue},unsigned long)

property distances_from_root

generate_all_buds((GraphColonization)arg1) → None :

C++ signature :

void generate_all_buds(PGL::GraphColonization {lvalue})

generate_buds((GraphColonization)arg1, (object)arg2) → None :

C++ signature :

void generate_buds(PGL::GraphColonization {lvalue},unsigned long)

generate_buds( (GraphColonization)arg1, (object)arg2) -> None :

C++ signature :

void generate_buds(PyGraphColonization {lvalue},unsigned long)

get_children((GraphColonization)arg1) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> get_children(PGL::GraphColonization {lvalue})

property graph

property grid

growth((GraphColonization)arg1) → None :

Growth the current bud

C++ signature :

void growth(PGL::GraphColonization {lvalue})

property insertion_angle

iterate((GraphColonization)arg1, (object)nbsteps) → None :

Apply a given number of steps.

C++ signature :

void iterate(PGL::GraphColonization {lvalue},unsigned long)

junction_components((GraphColonization)arg1, (object)nodeid1, (object)nodeid2) → Index :

C++ signature :

PGL::PglVector<unsigned int> junction_components(PGL::GraphColonization {lvalue},unsigned long,unsigned long)

junction_point((GraphColonization)arg1, (object)nodeid1, (object)nodeid2) → Vector3 :

C++ signature :

PGL::Vector3 junction_point(PGL::GraphColonization {lvalue},unsigned long,unsigned long)

property kill_radius

property min_nb_pt_per_bud

nbLatentBud((GraphColonization)arg1) → int :

C++ signature :

unsigned long nbLatentBud(PGL::GraphColonization {lvalue})

property nb_buds_per_whorl

node_buds_postprocess((GraphColonization)arg1, (object)arg2) → None :

C++ signature :

void node_buds_postprocess(PGL::GraphColonization {lvalue},unsigned long)

node_buds_postprocess( (GraphColonization)arg1, (object)arg2) -> None :

C++ signature :

void node_buds_postprocess(PyGraphColonization {lvalue},unsigned long)

node_buds_preprocess((GraphColonization)arg1, (object)arg2) → None :

C++ signature :

void node_buds_preprocess(PGL::GraphColonization {lvalue},unsigned long)

node_buds_preprocess( (GraphColonization)arg1, (object)arg2) -> None :

C++ signature :

void node_buds_preprocess(PyGraphColonization {lvalue},unsigned long)

node_components((GraphColonization)arg1, (object)pid) → Index :

C++ signature :

PGL::PglVector<unsigned int> node_components(PGL::GraphColonization {lvalue},unsigned long)

node_direction((GraphColonization)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 node_direction(PGL::GraphColonization {lvalue},unsigned long)

node_level((GraphColonization)arg1, (object)pid) → float :

C++ signature :

double node_level(PGL::GraphColonization {lvalue},unsigned long)

node_position((GraphColonization)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 node_position(PGL::GraphColonization {lvalue},unsigned long)

property nodecomponents

property nodelength

property nodelevels

property nodes

property parents

property perception_radius

property root

run((GraphColonization)arg1) → None :

Apply as many steps as it can

C++ signature :

void run(PGL::GraphColonization {lvalue})

setLengths((GraphColonization)arg1, (object)node_length[, (object)kill_radius_ratio=0.9[, (object)perception_radius_ratio=2.0]]) → None :

C++ signature :

void setLengths(PGL::GraphColonization {lvalue},double [,double=0.9 [,double=2.0]])

step((GraphColonization)arg1) → None :

First generate all buds, and then grow them

C++ signature :

void step(PGL::GraphColonization {lvalue})

try_to_set_bud((GraphColonization)arg1, (object)arg2, (Vector3)arg3) → bool :

C++ signature :

bool try_to_set_bud(PGL::GraphColonization {lvalue},unsigned long,PGL::Vector3)

property use_jonction_points

class Grid2

cellId((Grid2)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

cellIdFromPoint((Grid2)arg1, (Vector2)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},PGL::Vector2)

dimensions((Grid2)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

getCorners((Grid2)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

getGridSize((Grid2)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getGridSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getLowerCorner((Grid2)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getLowerCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getMaxDistanceToBorder((Grid2)arg1, (Vector2)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},PGL::Vector2)

getMaxIndexDistanceToBorder((Grid2)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getOrigin((Grid2)arg1) → Vector2 :

Return the origin of the grid.

C++ signature :

PGL::Vector2 getOrigin(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getUpperCorner((Grid2)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getUpperCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getVoxelCenter((Grid2)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelCenter(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelCenterFromId((Grid2)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelCenterFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelCorners((Grid2)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelCornersFromId((Grid2)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelLowerPoint((Grid2)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelLowerPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelLowerPointFromId((Grid2)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelLowerPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelSize((Grid2)arg1) → Vector2 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector2 getVoxelSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getVoxelUpperPoint((Grid2)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelUpperPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelUpperPointFromId((Grid2)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelUpperPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

index((Grid2)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

indexFromCoord((Grid2)arg1, (Vector2)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector2,unsigned long)

indexFromCoord( (Grid2)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,double,unsigned long)

indexFromPoint((Grid2)arg1, (Vector2)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector2)

isValidId((Grid2)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},unsigned long)

isValidIndex((Grid2)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

nbDimensions((Grid2)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

query_voxels_around_point((Grid2)arg1, (Vector2)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector2,double)

query_voxels_in_box((Grid2)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Tuple<unsigned long, 2>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Grid2)arg1, (Vector2)origin, (Vector2)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector2,PGL::Vector2,double,double)

size((Grid2)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

valuesize((Grid2)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector2, 2, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

class Grid3

cellId((Grid3)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

cellIdFromPoint((Grid3)arg1, (Vector3)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},PGL::Vector3)

dimensions((Grid3)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

getCorners((Grid3)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

getGridSize((Grid3)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getGridSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getLowerCorner((Grid3)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getLowerCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getMaxDistanceToBorder((Grid3)arg1, (Vector3)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},PGL::Vector3)

getMaxIndexDistanceToBorder((Grid3)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getOrigin((Grid3)arg1) → Vector3 :

Return the origin of the grid.

C++ signature :

PGL::Vector3 getOrigin(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getUpperCorner((Grid3)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getUpperCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getVoxelCenter((Grid3)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelCenter(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelCenterFromId((Grid3)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelCenterFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelCorners((Grid3)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelCornersFromId((Grid3)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelLowerPoint((Grid3)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelLowerPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelLowerPointFromId((Grid3)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelLowerPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelSize((Grid3)arg1) → Vector3 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector3 getVoxelSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getVoxelUpperPoint((Grid3)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelUpperPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelUpperPointFromId((Grid3)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelUpperPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

index((Grid3)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

indexFromCoord((Grid3)arg1, (Vector3)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector3,unsigned long)

indexFromCoord( (Grid3)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,double,unsigned long)

indexFromPoint((Grid3)arg1, (Vector3)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector3)

isValidId((Grid3)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},unsigned long)

isValidIndex((Grid3)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

nbDimensions((Grid3)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

query_voxels_around_point((Grid3)arg1, (Vector3)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector3,double)

query_voxels_in_box((Grid3)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Tuple<unsigned long, 3>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Grid3)arg1, (Vector3)origin, (Vector3)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector3,PGL::Vector3,double,double)

size((Grid3)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

valuesize((Grid3)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

class Grid3Indexing

cellId((Grid3Indexing)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

cellIdFromPoint((Grid3Indexing)arg1, (Vector3)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue},PGL::Vector3)

dimensions((Grid3Indexing)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*)

getCorners((Grid3Indexing)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*)

getGridSize((Grid3Indexing)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getGridSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

getLowerCorner((Grid3Indexing)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getLowerCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

getMaxDistanceToBorder((Grid3Indexing)arg1, (Vector3)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue},PGL::Vector3)

getMaxIndexDistanceToBorder((Grid3Indexing)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

getOrigin((Grid3Indexing)arg1) → Vector3 :

Return the origin of the grid.

C++ signature :

PGL::Vector3 getOrigin(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

getUpperCorner((Grid3Indexing)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getUpperCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

getVoxelCenter((Grid3Indexing)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelCenter(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

getVoxelCenterFromId((Grid3Indexing)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelCenterFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,unsigned long)

getVoxelCorners((Grid3Indexing)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

getVoxelCornersFromId((Grid3Indexing)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,unsigned long)

getVoxelLowerPoint((Grid3Indexing)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelLowerPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

getVoxelLowerPointFromId((Grid3Indexing)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelLowerPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,unsigned long)

getVoxelSize((Grid3Indexing)arg1) → Vector3 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector3 getVoxelSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

getVoxelUpperPoint((Grid3Indexing)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelUpperPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

getVoxelUpperPointFromId((Grid3Indexing)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelUpperPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,unsigned long)

index((Grid3Indexing)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,unsigned long)

indexFromCoord((Grid3Indexing)arg1, (Vector3)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,PGL::Vector3,unsigned long)

indexFromCoord( (Grid3Indexing)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,double,unsigned long)

indexFromPoint((Grid3Indexing)arg1, (Vector3)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,PGL::Vector3)

isValidId((Grid3Indexing)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue},unsigned long)

isValidIndex((Grid3Indexing)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,boost::python::api::object)

nbDimensions((Grid3Indexing)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*)

query_voxels_around_point((Grid3Indexing)arg1, (Vector3)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,PGL::Vector3,double)

query_voxels_in_box((Grid3Indexing)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,PGL::Tuple<unsigned long, 3>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Grid3Indexing)arg1, (Vector3)origin, (Vector3)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> >*,PGL::Vector3,PGL::Vector3,double,double)

size((Grid3Indexing)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

valuesize((Grid3Indexing)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector3, 3, NoneContainer<boost::python::api::object> > {lvalue})

class Grid4

cellId((Grid4)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

cellIdFromPoint((Grid4)arg1, (Vector4)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},PGL::Vector4)

dimensions((Grid4)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

getCorners((Grid4)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

getGridSize((Grid4)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getGridSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getLowerCorner((Grid4)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getLowerCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getMaxDistanceToBorder((Grid4)arg1, (Vector4)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},PGL::Vector4)

getMaxIndexDistanceToBorder((Grid4)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getOrigin((Grid4)arg1) → Vector4 :

Return the origin of the grid.

C++ signature :

PGL::Vector4 getOrigin(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getUpperCorner((Grid4)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getUpperCorner(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getVoxelCenter((Grid4)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelCenter(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelCenterFromId((Grid4)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelCenterFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelCorners((Grid4)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelCornersFromId((Grid4)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelLowerPoint((Grid4)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelLowerPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelLowerPointFromId((Grid4)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelLowerPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

getVoxelSize((Grid4)arg1) → Vector4 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector4 getVoxelSize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

getVoxelUpperPoint((Grid4)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelUpperPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

getVoxelUpperPointFromId((Grid4)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelUpperPointFromId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

index((Grid4)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,unsigned long)

indexFromCoord((Grid4)arg1, (Vector4)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector4,unsigned long)

indexFromCoord( (Grid4)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,double,unsigned long)

indexFromPoint((Grid4)arg1, (Vector4)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector4)

isValidId((Grid4)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue},unsigned long)

isValidIndex((Grid4)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,boost::python::api::object)

nbDimensions((Grid4)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*)

query_voxels_around_point((Grid4)arg1, (Vector4)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector4,double)

query_voxels_in_box((Grid4)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Tuple<unsigned long, 4>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Grid4)arg1, (Vector4)origin, (Vector4)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> >*,PGL::Vector4,PGL::Vector4,double,double)

size((Grid4)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

valuesize((Grid4)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::SpatialArrayN<boost::python::api::object, PGL::Vector4, 4, PGL::VectorContainer<boost::python::api::object, IsNone> > {lvalue})

KDTree2((Point2Array)points) → AbstractKDTree2 :

Construct a KD-Tree from a set of 2D points.

C++ signature :

PGL::RefCountPtr<PGL::AbstractKDTree<PGL::Point2Array> > KDTree2(PGL::RefCountPtr<PGL::Point2Array>)

KDTree3((Point3Array)points) → AbstractKDTree3 :

Construct a KD-Tree from a set of 3D points.

C++ signature :

PGL::RefCountPtr<PGL::AbstractKDTree<PGL::Point3Array> > KDTree3(PGL::RefCountPtr<PGL::Point3Array>)

KDTree4((Point4Array)points) → AbstractKDTree4 :

Construct a KD-Tree from a set of 4D points.

C++ signature :

PGL::RefCountPtr<PGL::AbstractKDTree<PGL::Point4Array> > KDTree4(PGL::RefCountPtr<PGL::Point4Array>)

class MatrixComputer

clear((MatrixComputer)arg1) → None :

C++ signature :

void clear(PGL::MatrixComputer {lvalue})

property result

class Merge

apply((Merge)arg1, (Geometry)arg2) → bool :

C++ signature :

bool apply(PGL::Merge {lvalue},PGL::RefCountPtr<PGL::Geometry> {lvalue})

apply( (Merge)arg1, (ExplicitModel)arg2) -> bool :

C++ signature :

bool apply(PGL::Merge {lvalue},PGL::RefCountPtr<PGL::ExplicitModel> {lvalue})

property model

property result

class Mvs

getName((Mvs)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > getName(PGL::Mvs {lvalue})

isNamed((Mvs)arg1) → bool :

C++ signature :

bool isNamed(PGL::Mvs {lvalue})

isValid((Mvs)arg1) → bool :

C++ signature :

bool isValid(PGL::Mvs {lvalue})

property name

property scene

setName((Mvs)arg1, (str)arg2) → None :

C++ signature :

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

class Octree

class ConstructionMethod

ShapeBased = openalea.plantgl.algo._pglalgo.ConstructionMethod.ShapeBased

TriangleBased = openalea.plantgl.algo._pglalgo.ConstructionMethod.TriangleBased

names = {'ShapeBased': openalea.plantgl.algo._pglalgo.ConstructionMethod.ShapeBased, 'TriangleBased': openalea.plantgl.algo._pglalgo.ConstructionMethod.TriangleBased}

values = {0: openalea.plantgl.algo._pglalgo.ConstructionMethod.TriangleBased, 1: openalea.plantgl.algo._pglalgo.ConstructionMethod.ShapeBased}

ShapeBased = openalea.plantgl.algo._pglalgo.ConstructionMethod.ShapeBased

TriangleBased = openalea.plantgl.algo._pglalgo.ConstructionMethod.TriangleBased

property center

contains((Octree)arg1, (Vector3)arg2) → bool :

C++ signature :

bool contains(PGL::Octree {lvalue},PGL::Vector3)

property depth

findFirstPoint((Octree)arg1, (Ray)arg2) → object :

C++ signature :

boost::python::api::object findFirstPoint(PGL::Octree*,PGL::Ray)

getDetails((Octree)arg1) → object :

C++ signature :

boost::python::api::object getDetails(PGL::Octree*)

getRepresentation((Octree)arg1) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> getRepresentation(PGL::Octree {lvalue})

getSizes((Octree)arg1) → object :

C++ signature :

boost::python::api::object getSizes(PGL::Octree*)

getVolume((Octree)arg1, (object)arg2) → float :

C++ signature :

double getVolume(PGL::Octree {lvalue},unsigned int)

intersection((Octree)arg1, (Ray)arg2) → object :

C++ signature :

boost::python::api::object intersection(PGL::Octree*,PGL::Ray)

property size

class OrthographicCamera

getBoundingBoxView((OrthographicCamera)arg1) → BoundingBox :

C++ signature :

PGL::RefCountPtr<PGL::BoundingBox> getBoundingBoxView(PGL::OrthographicCamera {lvalue})

class Overlay

static process((Polyline2D)arg1, (Polyline2D)arg2) → Geometry :

compute the overlay between 2 closed polylines. Requires CGAL extension.

C++ signature :

PGL::RefCountPtr<PGL::Geometry> process(PGL::RefCountPtr<PGL::Polyline2D>,PGL::RefCountPtr<PGL::Polyline2D>)

class PerspectiveCamera

getBoundingBoxView((PerspectiveCamera)arg1) → BoundingBox :

C++ signature :

PGL::RefCountPtr<PGL::BoundingBox> getBoundingBoxView(PGL::PerspectiveCamera {lvalue})

class PglBinaryPrinter

static getCanonicalFilename((str)filename) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > getCanonicalFilename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

print((PglBinaryPrinter)arg1, (Scene)arg2) → bool :

C++ signature :

bool print(PyFileBinaryPrinter*,PGL::RefCountPtr<PGL::Scene>)

class PglFilePrinter

class PglPrinter

clear((PglPrinter)arg1) → None :

C++ signature :

void clear(PGL::Printer {lvalue})

flush((PglPrinter)arg1) → None :

C++ signature :

void flush(PGL::Printer {lvalue})

header((PglPrinter)arg1) → None :

C++ signature :

void header(PGL::Printer*)

header( (PglPrinter)arg1, (str)arg2) -> None :

C++ signature :

void header(PGL::Printer*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

incrementIndentation((PglPrinter)arg1, (object)arg2) → None :

C++ signature :

void incrementIndentation(PGL::Printer {lvalue},unsigned int)

isPrinted((PglPrinter)arg1, (SceneObject)arg2) → bool :

C++ signature :

bool isPrinted(PGL::Printer {lvalue},PGL::RefCountPtr<PGL::SceneObject>)

class PglStrBinaryPrinter

clear((PglStrBinaryPrinter)arg1) → None :

C++ signature :

void clear(PyStrBinaryPrinter {lvalue})

print((PglStrBinaryPrinter)arg1, (Scene)arg2) → bool :

C++ signature :

bool print(PyStrBinaryPrinter*,PGL::RefCountPtr<PGL::Scene>)

property result

class PglStrPrinter

clear((PglStrPrinter)arg1) → None :

C++ signature :

void clear(PyStrPGLPrinter*)

class PglTurtle

add_parameter(name, value, copy=<function deepcopy>)

Add a parameter to the Turtle that will be push and pop. For this a copy function is asked

appendColor((PglTurtle)arg1, (object)arg2, (object)arg3, (object)arg4) → None :

C++ signature :

void appendColor(PGL::PglTurtle {lvalue},unsigned int,unsigned int,unsigned int)

appendColor( (PglTurtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> None :

C++ signature :

void appendColor(PGL::PglTurtle {lvalue},float,float,float)

appendColor( (PglTurtle)arg1, (Color3)arg2) -> None :

C++ signature :

void appendColor(PGL::PglTurtle {lvalue},PGL::Color3)

appendMaterial((PglTurtle)arg1, (Appearance)arg2) → None :

C++ signature :

void appendMaterial(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Appearance>)

appendMaterial( (PglTurtle)arg1, (ImageTexture)arg2) -> None :

C++ signature :

void appendMaterial(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::ImageTexture>)

clearColorList((PglTurtle)arg1) → None :

C++ signature :

void clearColorList(PGL::PglTurtle {lvalue})

clearSurfaceList((PglTurtle)arg1) → None :

C++ signature :

void clearSurfaceList(PGL::PglTurtle {lvalue})

clear_parameters()

Clear the python parameters of the Turtle.

customGeometry()

pglShape( (PglTurtle)arg1, (Geometry)geometry [, (object)scale=1]) -> PglTurtle :

Insert a custom plantgl primitive at the turtle position and orientation

C++ signature :

PGL::PglTurtle {lvalue} pglShape(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Geometry> [,double=1])

pglShape( (PglTurtle)arg1, (Shape)geometry [, (object)scale=1]) -> PglTurtle :

Insert a custom plantgl primitive at the turtle position and orientation

C++ signature :

PGL::PglTurtle {lvalue} pglShape(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Shape> [,double=1])

pglShape( (PglTurtle)arg1, (Scene)geometry [, (object)scale=1]) -> PglTurtle :

Insert a custom plantgl primitive at the turtle position and orientation

C++ signature :

PGL::PglTurtle {lvalue} pglShape(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Scene> [,double=1])

getColorList((PglTurtle)arg1) → object :

C++ signature :

boost::python::api::object getColorList(PGL::PglTurtle*)

getDrawer((PglTurtle)arg1) → TurtleDrawer :

C++ signature :

PGL::RefCountPtr<PGL::TurtleDrawer> getDrawer(PGL::PglTurtle {lvalue})

getMaterial((PglTurtle)arg1, (object)arg2) → Appearance :

C++ signature :

PGL::RefCountPtr<PGL::Appearance> getMaterial(PGL::PglTurtle {lvalue},unsigned long)

getSurfaceList((PglTurtle)arg1) → object :

C++ signature :

boost::python::api::object getSurfaceList(PGL::PglTurtle*)

insertMaterial((PglTurtle)arg1, (object)arg2, (Appearance)arg3) → None :

C++ signature :

void insertMaterial(PGL::PglTurtle {lvalue},unsigned long,PGL::RefCountPtr<PGL::Appearance>)

insertMaterial( (PglTurtle)arg1, (object)arg2, (ImageTexture)arg3) -> None :

C++ signature :

void insertMaterial(PGL::PglTurtle {lvalue},unsigned long,PGL::RefCountPtr<PGL::ImageTexture>)

partialView((PglTurtle)arg1) → Scene :

Return the current turtle construction.

C++ signature :

PGL::RefCountPtr<PGL::Scene> partialView(PGL::PglTurtle {lvalue})

pglShape((PglTurtle)arg1, (Geometry)geometry[, (object)scale=1]) → PglTurtle :

Insert a custom plantgl primitive at the turtle position and orientation

C++ signature :

PGL::PglTurtle {lvalue} pglShape(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Geometry> [,double=1])

pglShape( (PglTurtle)arg1, (Shape)geometry [, (object)scale=1]) -> PglTurtle :

Insert a custom plantgl primitive at the turtle position and orientation

C++ signature :

PGL::PglTurtle {lvalue} pglShape(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Shape> [,double=1])

pglShape( (PglTurtle)arg1, (Scene)geometry [, (object)scale=1]) -> PglTurtle :

Insert a custom plantgl primitive at the turtle position and orientation

C++ signature :

PGL::PglTurtle {lvalue} pglShape(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::Scene> [,double=1])

popEvent()

pushEvent()

removeColor((PglTurtle)arg1, (object)arg2) → None :

C++ signature :

void removeColor(PGL::PglTurtle {lvalue},unsigned long)

removeSurface((PglTurtle)arg1, (str)arg2) → None :

C++ signature :

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

setColorAt((PglTurtle)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) → None :

C++ signature :

void setColorAt(PGL::PglTurtle {lvalue},unsigned long,unsigned int,unsigned int,unsigned int)

setColorAt( (PglTurtle)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) -> None :

C++ signature :

void setColorAt(PGL::PglTurtle {lvalue},unsigned long,float,float,float)

setColorAt( (PglTurtle)arg1, (object)arg2, (Color3)arg3) -> None :

C++ signature :

void setColorAt(PGL::PglTurtle {lvalue},unsigned long,PGL::Color3)

setColorList((PglTurtle)arg1, (object)arg2) → None :

C++ signature :

void setColorList(PGL::PglTurtle*,boost::python::api::object)

setDrawer((PglTurtle)arg1, (TurtleDrawer)arg2) → PglTurtle :

C++ signature :

PGL::PglTurtle {lvalue} setDrawer(PGL::PglTurtle {lvalue},PGL::RefCountPtr<PGL::TurtleDrawer>)

setMaterial((PglTurtle)arg1, (object)arg2, (Appearance)arg3) → None :

C++ signature :

void setMaterial(PGL::PglTurtle {lvalue},unsigned long,PGL::RefCountPtr<PGL::Appearance>)

setMaterial( (PglTurtle)arg1, (object)arg2, (ImageTexture)arg3) -> None :

C++ signature :

void setMaterial(PGL::PglTurtle {lvalue},unsigned long,PGL::RefCountPtr<PGL::ImageTexture>)

setSurface((PglTurtle)arg1, (str)arg2, (Geometry)arg3) → None :

C++ signature :

void setSurface(PGL::PglTurtle {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::RefCountPtr<PGL::Geometry>)

class PglTurtleDrawer

getScene((PglTurtleDrawer)arg1) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> getScene(PGL::PglTurtleDrawer {lvalue})

class Point2Grid

add_point((Point2Grid)arg1, (Vector2)arg2) → int :

Add a point in the grid. Should be contained in the voxels.

C++ signature :

unsigned long add_point(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},PGL::Vector2)

cellId((Point2Grid)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

cellIdFromPoint((Point2Grid)arg1, (Vector2)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},PGL::Vector2)

closest_point((Point2Grid)arg1, (Vector2)point[, (object)maxdist=1.7976931348623157e+308]) → object :

C++ signature :

boost::python::api::object closest_point(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2 [,double=1.7976931348623157e+308])

dimensions((Point2Grid)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*)

disable_point((Point2Grid)arg1, (object)arg2) → bool :

C++ signature :

bool disable_point(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},unsigned long)

disable_points((Point2Grid)arg1, (object)arg2) → None :

C++ signature :

void disable_points(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

enable_point((Point2Grid)arg1, (object)arg2) → bool :

C++ signature :

bool enable_point(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},unsigned long)

enable_points((Point2Grid)arg1, (object)arg2) → None :

C++ signature :

void enable_points(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

filter_disabled((Point2Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object filter_disabled(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

filter_enabled((Point2Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object filter_enabled(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getCorners((Point2Grid)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*)

getGridSize((Point2Grid)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getGridSize(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

getLowerCorner((Point2Grid)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getLowerCorner(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

getMaxDistanceToBorder((Point2Grid)arg1, (Vector2)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},PGL::Vector2)

getMaxIndexDistanceToBorder((Point2Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getOrigin((Point2Grid)arg1) → Vector2 :

Return the origin of the grid.

C++ signature :

PGL::Vector2 getOrigin(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

getUpperCorner((Point2Grid)arg1) → Vector2 :

C++ signature :

PGL::Vector2 getUpperCorner(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

getVoxelCenter((Point2Grid)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelCenter(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getVoxelCenterFromId((Point2Grid)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelCenterFromId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

getVoxelCorners((Point2Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getVoxelCornersFromId((Point2Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

getVoxelLowerPoint((Point2Grid)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelLowerPoint(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getVoxelLowerPointFromId((Point2Grid)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelLowerPointFromId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

getVoxelPointIndices((Point2Grid)arg1, (object)cellindex) → object :

Return the enabled points contained in the voxel

C++ signature :

boost::python::api::object getVoxelPointIndices(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getVoxelPointIndicesFromId((Point2Grid)arg1, (object)cellid) → object :

Return the enabled points contained in the voxel

C++ signature :

boost::python::api::object getVoxelPointIndicesFromId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

getVoxelSize((Point2Grid)arg1) → Vector2 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector2 getVoxelSize(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

getVoxelUpperPoint((Point2Grid)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelUpperPoint(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

getVoxelUpperPointFromId((Point2Grid)arg1, (object)arg2) → Vector2 :

C++ signature :

PGL::Vector2 getVoxelUpperPointFromId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

get_disabled_point_indices((Point2Grid)arg1) → object :

C++ signature :

boost::python::api::object get_disabled_point_indices(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*)

get_disabled_points((Point2Grid)arg1) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> get_disabled_points(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

get_enabled_point_indices((Point2Grid)arg1) → object :

C++ signature :

boost::python::api::object get_enabled_point_indices(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*)

get_enabled_points((Point2Grid)arg1) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> get_enabled_points(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

index((Point2Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

indexFromCoord((Point2Grid)arg1, (Vector2)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2,unsigned long)

indexFromCoord( (Point2Grid)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,double,unsigned long)

indexFromPoint((Point2Grid)arg1, (Vector2)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2)

isValidId((Point2Grid)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},unsigned long)

isValidIndex((Point2Grid)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

is_point_enabled((Point2Grid)arg1, (object)arg2) → bool :

C++ signature :

bool is_point_enabled(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue},unsigned long)

nbDimensions((Point2Grid)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*)

nbFilledVoxels((Point2Grid)arg1) → int :

C++ signature :

unsigned long nbFilledVoxels(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

nbPointInVoxel((Point2Grid)arg1, (object)cellindex) → int :

Return the number of enabled points contained in the voxel

C++ signature :

unsigned long nbPointInVoxel(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,boost::python::api::object)

nbPointInVoxelFromId((Point2Grid)arg1, (object)cellid) → int :

Return the number of enabled points contained in the voxel

C++ signature :

unsigned long nbPointInVoxelFromId(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,unsigned long)

query_ball_point((Point2Grid)arg1, (Vector2)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_ball_point(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2,double)

query_points_in_cone((Point2Grid)arg1, (Vector2)origin, (Vector2)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_points_in_cone(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2,PGL::Vector2,double,double)

query_voxels_around_point((Point2Grid)arg1, (Vector2)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2,double)

query_voxels_in_box((Point2Grid)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Tuple<unsigned long, 2>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Point2Grid)arg1, (Vector2)origin, (Vector2)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2>*,PGL::Vector2,PGL::Vector2,double,double)

size((Point2Grid)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

valuesize((Point2Grid)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::PointGrid<PGL::Point2Array, PGL::LocalContainerPolicy<PGL::Point2Array>, 2> {lvalue})

class Point3Grid

add_point((Point3Grid)arg1, (Vector3)arg2) → int :

Add a point in the grid. Should be contained in the voxels.

C++ signature :

unsigned long add_point(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},PGL::Vector3)

cellId((Point3Grid)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

cellIdFromPoint((Point3Grid)arg1, (Vector3)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},PGL::Vector3)

closest_point((Point3Grid)arg1, (Vector3)point[, (object)maxdist=1.7976931348623157e+308]) → object :

C++ signature :

boost::python::api::object closest_point(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3 [,double=1.7976931348623157e+308])

dimensions((Point3Grid)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*)

disable_point((Point3Grid)arg1, (object)arg2) → bool :

C++ signature :

bool disable_point(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},unsigned long)

disable_points((Point3Grid)arg1, (object)arg2) → None :

C++ signature :

void disable_points(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

enable_point((Point3Grid)arg1, (object)arg2) → bool :

C++ signature :

bool enable_point(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},unsigned long)

enable_points((Point3Grid)arg1, (object)arg2) → None :

C++ signature :

void enable_points(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

filter_disabled((Point3Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object filter_disabled(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

filter_enabled((Point3Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object filter_enabled(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getCorners((Point3Grid)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*)

getGridSize((Point3Grid)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getGridSize(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

getLowerCorner((Point3Grid)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getLowerCorner(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

getMaxDistanceToBorder((Point3Grid)arg1, (Vector3)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},PGL::Vector3)

getMaxIndexDistanceToBorder((Point3Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getOrigin((Point3Grid)arg1) → Vector3 :

Return the origin of the grid.

C++ signature :

PGL::Vector3 getOrigin(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

getUpperCorner((Point3Grid)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getUpperCorner(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

getVoxelCenter((Point3Grid)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelCenter(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getVoxelCenterFromId((Point3Grid)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelCenterFromId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

getVoxelCorners((Point3Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getVoxelCornersFromId((Point3Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

getVoxelLowerPoint((Point3Grid)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelLowerPoint(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getVoxelLowerPointFromId((Point3Grid)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelLowerPointFromId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

getVoxelPointIndices((Point3Grid)arg1, (object)cellindex) → object :

Return the enabled points contained in the voxel

C++ signature :

boost::python::api::object getVoxelPointIndices(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getVoxelPointIndicesFromId((Point3Grid)arg1, (object)cellid) → object :

Return the enabled points contained in the voxel

C++ signature :

boost::python::api::object getVoxelPointIndicesFromId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

getVoxelSize((Point3Grid)arg1) → Vector3 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector3 getVoxelSize(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

getVoxelUpperPoint((Point3Grid)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelUpperPoint(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

getVoxelUpperPointFromId((Point3Grid)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 getVoxelUpperPointFromId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

get_disabled_point_indices((Point3Grid)arg1) → object :

C++ signature :

boost::python::api::object get_disabled_point_indices(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*)

get_disabled_points((Point3Grid)arg1) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> get_disabled_points(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

get_enabled_point_indices((Point3Grid)arg1) → object :

C++ signature :

boost::python::api::object get_enabled_point_indices(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*)

get_enabled_points((Point3Grid)arg1) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> get_enabled_points(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

index((Point3Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

indexFromCoord((Point3Grid)arg1, (Vector3)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3,unsigned long)

indexFromCoord( (Point3Grid)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,double,unsigned long)

indexFromPoint((Point3Grid)arg1, (Vector3)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3)

isValidId((Point3Grid)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},unsigned long)

isValidIndex((Point3Grid)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

is_point_enabled((Point3Grid)arg1, (object)arg2) → bool :

C++ signature :

bool is_point_enabled(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue},unsigned long)

nbDimensions((Point3Grid)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*)

nbFilledVoxels((Point3Grid)arg1) → int :

C++ signature :

unsigned long nbFilledVoxels(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

nbPointInVoxel((Point3Grid)arg1, (object)cellindex) → int :

Return the number of enabled points contained in the voxel

C++ signature :

unsigned long nbPointInVoxel(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,boost::python::api::object)

nbPointInVoxelFromId((Point3Grid)arg1, (object)cellid) → int :

Return the number of enabled points contained in the voxel

C++ signature :

unsigned long nbPointInVoxelFromId(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,unsigned long)

query_ball_point((Point3Grid)arg1, (Vector3)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_ball_point(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3,double)

query_points_in_cone((Point3Grid)arg1, (Vector3)origin, (Vector3)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_points_in_cone(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3,PGL::Vector3,double,double)

query_voxels_around_point((Point3Grid)arg1, (Vector3)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3,double)

query_voxels_in_box((Point3Grid)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Tuple<unsigned long, 3>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Point3Grid)arg1, (Vector3)origin, (Vector3)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3>*,PGL::Vector3,PGL::Vector3,double,double)

size((Point3Grid)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

valuesize((Point3Grid)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::PointGrid<PGL::Point3Array, PGL::LocalContainerPolicy<PGL::Point3Array>, 3> {lvalue})

class Point4Grid

add_point((Point4Grid)arg1, (Vector4)arg2) → int :

Add a point in the grid. Should be contained in the voxels.

C++ signature :

unsigned long add_point(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},PGL::Vector4)

cellId((Point4Grid)arg1, (object)arg2) → int :

C++ signature :

unsigned long cellId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

cellIdFromPoint((Point4Grid)arg1, (Vector4)arg2) → int :

C++ signature :

unsigned long cellIdFromPoint(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},PGL::Vector4)

closest_point((Point4Grid)arg1, (Vector4)point[, (object)maxdist=1.7976931348623157e+308]) → object :

C++ signature :

boost::python::api::object closest_point(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4 [,double=1.7976931348623157e+308])

dimensions((Point4Grid)arg1) → object :

Return the dimensions of the grid in each axis

C++ signature :

boost::python::api::object dimensions(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*)

disable_point((Point4Grid)arg1, (object)arg2) → bool :

C++ signature :

bool disable_point(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},unsigned long)

disable_points((Point4Grid)arg1, (object)arg2) → None :

C++ signature :

void disable_points(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

enable_point((Point4Grid)arg1, (object)arg2) → bool :

C++ signature :

bool enable_point(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},unsigned long)

enable_points((Point4Grid)arg1, (object)arg2) → None :

C++ signature :

void enable_points(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

filter_disabled((Point4Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object filter_disabled(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

filter_enabled((Point4Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object filter_enabled(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getCorners((Point4Grid)arg1) → object :

C++ signature :

boost::python::api::object getCorners(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*)

getGridSize((Point4Grid)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getGridSize(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

getLowerCorner((Point4Grid)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getLowerCorner(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

getMaxDistanceToBorder((Point4Grid)arg1, (Vector4)arg2) → float :

C++ signature :

double getMaxDistanceToBorder(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},PGL::Vector4)

getMaxIndexDistanceToBorder((Point4Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getMaxIndexDistanceToBorder(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getOrigin((Point4Grid)arg1) → Vector4 :

Return the origin of the grid.

C++ signature :

PGL::Vector4 getOrigin(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

getUpperCorner((Point4Grid)arg1) → Vector4 :

C++ signature :

PGL::Vector4 getUpperCorner(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

getVoxelCenter((Point4Grid)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelCenter(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getVoxelCenterFromId((Point4Grid)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelCenterFromId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

getVoxelCorners((Point4Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCorners(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getVoxelCornersFromId((Point4Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getVoxelCornersFromId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

getVoxelLowerPoint((Point4Grid)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelLowerPoint(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getVoxelLowerPointFromId((Point4Grid)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelLowerPointFromId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

getVoxelPointIndices((Point4Grid)arg1, (object)cellindex) → object :

Return the enabled points contained in the voxel

C++ signature :

boost::python::api::object getVoxelPointIndices(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getVoxelPointIndicesFromId((Point4Grid)arg1, (object)cellid) → object :

Return the enabled points contained in the voxel

C++ signature :

boost::python::api::object getVoxelPointIndicesFromId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

getVoxelSize((Point4Grid)arg1) → Vector4 :

Return the size of the voxels of the grid.

C++ signature :

PGL::Vector4 getVoxelSize(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

getVoxelUpperPoint((Point4Grid)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelUpperPoint(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

getVoxelUpperPointFromId((Point4Grid)arg1, (object)arg2) → Vector4 :

C++ signature :

PGL::Vector4 getVoxelUpperPointFromId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

get_disabled_point_indices((Point4Grid)arg1) → object :

C++ signature :

boost::python::api::object get_disabled_point_indices(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*)

get_disabled_points((Point4Grid)arg1) → Point4Array :

C++ signature :

PGL::RefCountPtr<PGL::Point4Array> get_disabled_points(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

get_enabled_point_indices((Point4Grid)arg1) → object :

C++ signature :

boost::python::api::object get_enabled_point_indices(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*)

get_enabled_points((Point4Grid)arg1) → Point4Array :

C++ signature :

PGL::RefCountPtr<PGL::Point4Array> get_enabled_points(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

index((Point4Grid)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object index(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

indexFromCoord((Point4Grid)arg1, (Vector4)arg2, (object)arg3) → int :

C++ signature :

unsigned long indexFromCoord(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4,unsigned long)

indexFromCoord( (Point4Grid)arg1, (object)arg2, (object)arg3) -> int :

C++ signature :

unsigned long indexFromCoord(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,double,unsigned long)

indexFromPoint((Point4Grid)arg1, (Vector4)arg2) → object :

C++ signature :

boost::python::api::object indexFromPoint(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4)

isValidId((Point4Grid)arg1, (object)arg2) → bool :

C++ signature :

bool isValidId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},unsigned long)

isValidIndex((Point4Grid)arg1, (object)arg2) → bool :

C++ signature :

bool isValidIndex(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

is_point_enabled((Point4Grid)arg1, (object)arg2) → bool :

C++ signature :

bool is_point_enabled(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue},unsigned long)

nbDimensions((Point4Grid)arg1) → int :

Return the number of dimensions of the grid

C++ signature :

unsigned long nbDimensions(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*)

nbFilledVoxels((Point4Grid)arg1) → int :

C++ signature :

unsigned long nbFilledVoxels(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

nbPointInVoxel((Point4Grid)arg1, (object)cellindex) → int :

Return the number of enabled points contained in the voxel

C++ signature :

unsigned long nbPointInVoxel(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,boost::python::api::object)

nbPointInVoxelFromId((Point4Grid)arg1, (object)cellid) → int :

Return the number of enabled points contained in the voxel

C++ signature :

unsigned long nbPointInVoxelFromId(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,unsigned long)

query_ball_point((Point4Grid)arg1, (Vector4)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_ball_point(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4,double)

query_points_in_cone((Point4Grid)arg1, (Vector4)origin, (Vector4)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_points_in_cone(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4,PGL::Vector4,double,double)

query_voxels_around_point((Point4Grid)arg1, (Vector4)center, (object)radius) → object :

C++ signature :

boost::python::api::object query_voxels_around_point(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4,double)

query_voxels_in_box((Point4Grid)arg1, (object)center, (object)maxradius[, (object)minradius=None]) → object :

C++ signature :

boost::python::api::object query_voxels_in_box(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Tuple<unsigned long, 4>,boost::python::api::object [,boost::python::api::object=None])

query_voxels_in_cone((Point4Grid)arg1, (Vector4)origin, (Vector4)direction, (object)radius, (object)angle) → object :

C++ signature :

boost::python::api::object query_voxels_in_cone(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4>*,PGL::Vector4,PGL::Vector4,double,double)

size((Point4Grid)arg1) → int :

Return the number of element of the grid. Determined from its dimensions.

C++ signature :

unsigned long size(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

valuesize((Point4Grid)arg1) → int :

Return the size of the value container. Should be equal to size.

C++ signature :

unsigned long valuesize(PGL::PointGrid<PGL::Point4Array, PGL::LocalContainerPolicy<PGL::Point4Array>, 4> {lvalue})

class PovFilePrinter

class PovPrinter

setBackground((PovPrinter)arg1, (Color3)color) → bool :

setBackGround(Color3 color)

C++ signature :

bool setBackground(PGL::PovPrinter {lvalue},PGL::Color3)

setLight((PovPrinter)arg1, (Vector3)position, (Color3)color) → bool :

setLight(Vector3 position, Color3 color)

C++ signature :

bool setLight(PGL::PovPrinter {lvalue},PGL::Vector3,PGL::Color3)

class PovStrPrinter

clear((PovStrPrinter)arg1) → None :

C++ signature :

void clear(PyStrPovPrinter*)

class ProjectionCamera

NDCToCamera((ProjectionCamera)arg1, (Vector3)arg2) → Vector3 :

C++ signature :

PGL::Vector3 NDCToCamera(PGL::ProjectionCamera {lvalue},PGL::Vector3)

NDCToRaster((ProjectionCamera)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → Vector3 :

C++ signature :

PGL::Vector3 NDCToRaster(PGL::ProjectionCamera {lvalue},PGL::Vector3,unsigned short,unsigned short)

cameraToNDC((ProjectionCamera)arg1, (Vector3)arg2) → Vector3 :

C++ signature :

PGL::Vector3 cameraToNDC(PGL::ProjectionCamera {lvalue},PGL::Vector3)

cameraToRaster((ProjectionCamera)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → Vector3 :

C++ signature :

PGL::Vector3 cameraToRaster(PGL::ProjectionCamera {lvalue},PGL::Vector3,unsigned short,unsigned short)

cameraToWorld((ProjectionCamera)arg1, (Vector3)arg2) → Vector3 :

C++ signature :

PGL::Vector3 cameraToWorld(PGL::ProjectionCamera {lvalue},PGL::Vector3)

property far

getModelTransformationMatrix((ProjectionCamera)arg1) → Matrix4 :

C++ signature :

PGL::Matrix4 getModelTransformationMatrix(PGL::ProjectionCamera {lvalue})

getWorldToCameraMatrix((ProjectionCamera)arg1) → Matrix4 :

C++ signature :

PGL::Matrix4 getWorldToCameraMatrix(PGL::ProjectionCamera {lvalue})

isInZRange((ProjectionCamera)arg1, (object)arg2) → bool :

C++ signature :

bool isInZRange(PGL::ProjectionCamera {lvalue},double)

isInZRange( (ProjectionCamera)arg1, (object)arg2, (object)arg3) -> bool :

C++ signature :

bool isInZRange(PGL::ProjectionCamera {lvalue},double,double)

isValidPixel((ProjectionCamera)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) → bool :

C++ signature :

bool isValidPixel(PGL::ProjectionCamera {lvalue},unsigned short,unsigned short,unsigned short,unsigned short)

lookAt((ProjectionCamera)arg1, (Vector3)arg2, (Vector3)arg3, (Vector3)arg4) → None :

C++ signature :

void lookAt(PGL::ProjectionCamera {lvalue},PGL::Vector3,PGL::Vector3,PGL::Vector3)

methodType((ProjectionCamera)arg1) → eProjectionMethodType :

C++ signature :

PGL::ProjectionCamera::eProjectionMethodType methodType(PGL::ProjectionCamera {lvalue})

property near

popModelTransformation((ProjectionCamera)arg1) → None :

C++ signature :

void popModelTransformation(PGL::ProjectionCamera {lvalue})

position((ProjectionCamera)arg1) → Vector3 :

C++ signature :

PGL::Vector3 position(PGL::ProjectionCamera {lvalue})

projectedArea((ProjectionCamera)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5, (object)arg6) → float :

C++ signature :

double projectedArea(PGL::ProjectionCamera {lvalue},unsigned short,unsigned short,double,unsigned short,unsigned short)

pushModelTransformation((ProjectionCamera)arg1) → None :

C++ signature :

void pushModelTransformation(PGL::ProjectionCamera {lvalue})

rasterToCamera((ProjectionCamera)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → Vector3 :

C++ signature :

PGL::Vector3 rasterToCamera(PGL::ProjectionCamera {lvalue},PGL::Vector3,unsigned short,unsigned short)

rasterToCameraRay((ProjectionCamera)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) → Ray :

C++ signature :

PGL::Ray rasterToCameraRay(PGL::ProjectionCamera {lvalue},unsigned short,unsigned short,unsigned short,unsigned short)

rasterToNDC((ProjectionCamera)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → Vector3 :

C++ signature :

PGL::Vector3 rasterToNDC(PGL::ProjectionCamera {lvalue},PGL::Vector3,unsigned short,unsigned short)

rasterToWorld((ProjectionCamera)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → Vector3 :

C++ signature :

PGL::Vector3 rasterToWorld(PGL::ProjectionCamera {lvalue},PGL::Vector3,unsigned short,unsigned short)

rasterToWorldRay((ProjectionCamera)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) → Ray :

C++ signature :

PGL::Ray rasterToWorldRay(PGL::ProjectionCamera {lvalue},unsigned short,unsigned short,unsigned short,unsigned short)

scaleModel((ProjectionCamera)arg1, (Vector3)arg2) → None :

C++ signature :

void scaleModel(PGL::ProjectionCamera {lvalue},PGL::Vector3)

solidAngle((ProjectionCamera)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) → float :

C++ signature :

double solidAngle(PGL::ProjectionCamera {lvalue},unsigned short,unsigned short,unsigned short,unsigned short)

transformModel((ProjectionCamera)arg1, (Matrix4)arg2) → None :

C++ signature :

void transformModel(PGL::ProjectionCamera {lvalue},PGL::Matrix4)

transformModelIdentity((ProjectionCamera)arg1) → None :

C++ signature :

void transformModelIdentity(PGL::ProjectionCamera {lvalue})

translateModel((ProjectionCamera)arg1, (Vector3)arg2) → None :

C++ signature :

void translateModel(PGL::ProjectionCamera {lvalue},PGL::Vector3)

type((ProjectionCamera)arg1) → eProjectionType :

C++ signature :

PGL::ProjectionCamera::eProjectionType type(PGL::ProjectionCamera {lvalue})

worldToCamera((ProjectionCamera)arg1, (Vector3)arg2) → Vector3 :

C++ signature :

PGL::Vector3 worldToCamera(PGL::ProjectionCamera {lvalue},PGL::Vector3)

worldToRaster((ProjectionCamera)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → Vector3 :

C++ signature :

PGL::Vector3 worldToRaster(PGL::ProjectionCamera {lvalue},PGL::Vector3,unsigned short,unsigned short)

class ProjectionEngine

camera((ProjectionEngine)arg1) → ProjectionCamera :

C++ signature :

PGL::RefCountPtr<PGL::ProjectionCamera> camera(PGL::ProjectionEngine*)

lookAt((ProjectionEngine)arg1, (Vector3)eye_position, (Vector3)target, (Vector3)up) → None :

C++ signature :

void lookAt(PGL::ProjectionEngine {lvalue},PGL::Vector3,PGL::Vector3,PGL::Vector3)

process((ProjectionEngine)arg1, (TriangleSet)triangleset, (Appearance)appearance, (object)id) → None :

C++ signature :

void process(PGL::ProjectionEngine {lvalue},PGL::RefCountPtr<PGL::TriangleSet>,PGL::RefCountPtr<PGL::Appearance>,unsigned int)

process( (ProjectionEngine)arg1, (Polyline)polyline, (Material)appearance, (object)id) -> None :

C++ signature :

void process(PGL::ProjectionEngine {lvalue},PGL::RefCountPtr<PGL::Polyline>,PGL::RefCountPtr<PGL::Material>,unsigned int)

process( (ProjectionEngine)arg1, (PointSet)pointset, (Material)appearance, (object)id) -> None :

C++ signature :

void process(PGL::ProjectionEngine {lvalue},PGL::RefCountPtr<PGL::PointSet>,PGL::RefCountPtr<PGL::Material>,unsigned int)

process( (ProjectionEngine)arg1, (Scene)scene) -> None :

C++ signature :

void process(PGL::ProjectionEngine {lvalue},PGL::RefCountPtr<PGL::Scene>)

setFrustumCamera((ProjectionEngine)arg1, (object)left, (object)right, (object)bottom, (object)top, (object)near, (object)far) → None :

C++ signature :

void setFrustumCamera(PGL::ProjectionEngine {lvalue},double,double,double,double,double,double)

setOrthographicCamera((ProjectionEngine)arg1, (object)left, (object)right, (object)bottom, (object)top, (object)near, (object)far) → None :

C++ signature :

void setOrthographicCamera(PGL::ProjectionEngine {lvalue},double,double,double,double,double,double)

setPerspectiveCamera((ProjectionEngine)arg1, (object)verticalAngleOfView : degrees, (object)aspectRatio, (object)near, (object)far) → None :

C++ signature :

void setPerspectiveCamera(PGL::ProjectionEngine {lvalue},double,double,double,double)

class ProjectionRenderer

class PyFilePrinter

class PyPrinter

decrementIndentation((PyPrinter)arg1) → None :

C++ signature :

void decrementIndentation(PGL::PyPrinter {lvalue})

incrementIndentation((PyPrinter)arg1) → None :

C++ signature :

void incrementIndentation(PGL::PyPrinter {lvalue})

property indentation

property indentation_increment

property line_between_object

property pglnamespace

property reference_dir

class PyStrPrinter

clear((PyStrPrinter)arg1) → None :

C++ signature :

void clear(PyStrPyPrinter*)

class Ray

property direction

getAt((Ray)arg1, (object)t) → Vector3 :

C++ signature :

PGL::Vector3 getAt(PGL::Ray {lvalue},double)

intersect((Ray)arg1, (Vector3)point) → bool :

C++ signature :

bool intersect(PGL::Ray {lvalue},PGL::Vector3)

intersect( (Ray)arg1, (Vector2)point) -> bool :

C++ signature :

bool intersect(PGL::Ray {lvalue},PGL::Vector2)

intersect( (Ray)arg1, (Ray)ray) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::Ray)

intersect( (Ray)arg1, (Vector3)p1, (Vector3)p2) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::Vector3,PGL::Vector3)

intersect( (Ray)arg1, (Vector2)p1, (Vector2)p2) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::Vector2,PGL::Vector2)

intersect( (Ray)arg1, (Vector3)p1, (Vector3)p2, (Vector3)p3) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::Vector3,PGL::Vector3,PGL::Vector3)

intersect( (Ray)arg1, (Vector3)p1, (Vector3)p2, (Vector3)p3, (Vector3)p4) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

intersect( (Ray)arg1, (Vector3)center, (object)radius) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::Vector3,double)

intersect( (Ray)arg1, (BoundingBox)bbox) -> object :

C++ signature :

boost::python::api::object intersect(PGL::Ray*,PGL::BoundingBox)

isIntersecting((Ray)arg1, (object)bsphere) → bool :

C++ signature :

bool isIntersecting(PGL::Ray {lvalue},PGL::BoundingSphere)

isValid((Ray)arg1) → bool :

C++ signature :

bool isValid(PGL::Ray {lvalue})

property origin

class RayIntersection

property intersection

Return the list of result points

run((RayIntersection)arg1, (Geometry)arg2) → None :

run(geom) - Compute intersections between a ray and the geometry.

C++ signature :

void run(PGL::RayIntersection*,PGL::RefCountPtr<PGL::Geometry>)

setRay((RayIntersection)arg1, (Vector3)point, (Vector3)direction) → None :

setRay( Vector3 point, Vector3 direction)

C++ signature :

void setRay(PGL::RayIntersection*,PGL::Vector3*,PGL::Vector3*)

setRay( (RayIntersection)arg1, (Ray)ray) -> None :

setRay( Ray ray )

C++ signature :

void setRay(PGL::RayIntersection {lvalue},PGL::Ray)

class Sequencer

elapsedTime((Sequencer)arg1) → float :

C++ signature :

double elapsedTime(PGL::Sequencer {lvalue})

ok((Sequencer)arg1) → bool :

C++ signature :

bool ok(PGL::Sequencer {lvalue})

sleep((Sequencer)arg1, (object)arg2) → None :

C++ signature :

void sleep(PGL::Sequencer {lvalue},double)

property timeStep

touch((Sequencer)arg1) → None :

C++ signature :

void touch(PGL::Sequencer {lvalue})

touch( (Sequencer)arg1, (object)next_timestep) -> None :

C++ signature :

void touch(PGL::Sequencer {lvalue},double)

class Skeleton

Skeleton defines a static method to get the skeleton of a shape defined by a polyline with chordal axis transform. See prasad 97 for details on chordal axis transform

static getChordalAxisTransform((Polyline2D)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getChordalAxisTransform(PGL::RefCountPtr<PGL::Polyline2D>,double)

static getDelaunayConstrained2DTriangulation((Polyline2D)arg1) → TriangleSet :

C++ signature :

PGL::RefCountPtr<PGL::TriangleSet> getDelaunayConstrained2DTriangulation(PGL::RefCountPtr<PGL::Polyline2D>)

static getSkeletonInformation((Polyline2D)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object getSkeletonInformation(PGL::RefCountPtr<PGL::Polyline2D>,double)

static removeLoopsInShape((Polyline2D)arg1) → Polyline2D :

C++ signature :

PGL::RefCountPtr<PGL::Polyline2D> removeLoopsInShape(PGL::RefCountPtr<PGL::Polyline2D>)

class SpaceColonization

EndEach((SpaceColonization)arg1) → None :

C++ signature :

void EndEach(PGL::SpaceColonization {lvalue})

EndEach( (SpaceColonization)arg1) -> None :

C++ signature :

void EndEach(PySpaceColonization {lvalue})

StartEach((SpaceColonization)arg1) → None :

C++ signature :

void StartEach(PGL::SpaceColonization {lvalue})

StartEach( (SpaceColonization)arg1) -> None :

C++ signature :

void StartEach(PySpaceColonization {lvalue})

activate_all((SpaceColonization)arg1) → None :

C++ signature :

void activate_all(PGL::SpaceColonization {lvalue})

activate_leaves((SpaceColonization)arg1) → None :

C++ signature :

void activate_leaves(PGL::SpaceColonization {lvalue})

activate_node((SpaceColonization)arg1, (object)arg2) → None :

C++ signature :

void activate_node(PGL::SpaceColonization {lvalue},unsigned long)

active_nodes((SpaceColonization)arg1) → Index :

C++ signature :

PGL::PglVector<unsigned int> active_nodes(PGL::SpaceColonization {lvalue})

add_bud((SpaceColonization)arg1, (object)arg2, (Vector3)arg3, (Index)arg4) → None :

C++ signature :

void add_bud(PySpaceColonization {lvalue},unsigned long,PGL::Vector3,PGL::PglVector<unsigned int>)

add_node((SpaceColonization)arg1, (Vector3)arg2, (object)position[, (Index)parent=4294967295[, (object)active=True]]) → int :

C++ signature :

unsigned long add_node(PGL::SpaceColonization {lvalue},PGL::Vector3,unsigned long [,PGL::PglVector<unsigned int>=4294967295 [,bool=True]])

property coneangle

desactivate_node((SpaceColonization)arg1, (object)arg2) → None :

C++ signature :

void desactivate_node(PGL::SpaceColonization {lvalue},unsigned long)

generate_all_buds((SpaceColonization)arg1) → None :

C++ signature :

void generate_all_buds(PGL::SpaceColonization {lvalue})

generate_buds((SpaceColonization)arg1, (object)arg2) → None :

C++ signature :

void generate_buds(PGL::SpaceColonization {lvalue},unsigned long)

generate_buds( (SpaceColonization)arg1, (object)arg2) -> None :

C++ signature :

void generate_buds(PySpaceColonization {lvalue},unsigned long)

get_children((SpaceColonization)arg1) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> get_children(PGL::SpaceColonization {lvalue})

property grid

growth((SpaceColonization)arg1) → None :

Growth the current bud

C++ signature :

void growth(PGL::SpaceColonization {lvalue})

property insertion_angle

iterate((SpaceColonization)arg1, (object)nbsteps) → None :

Apply a given number of steps.

C++ signature :

void iterate(PGL::SpaceColonization {lvalue},unsigned long)

property kill_radius

lateral_directions((SpaceColonization)arg1, (Vector3)arg2, (object)arg3, (object)arg4) → object :

C++ signature :

boost::python::api::object lateral_directions(PySpaceColonization {lvalue},PGL::Vector3,double,int)

property min_nb_pt_per_bud

nbLatentBud((SpaceColonization)arg1) → int :

C++ signature :

unsigned long nbLatentBud(PGL::SpaceColonization {lvalue})

property nb_buds_per_whorl

node_attractors((SpaceColonization)arg1, (object)pid) → Index :

C++ signature :

PGL::PglVector<unsigned int> node_attractors(PGL::SpaceColonization {lvalue},unsigned long)

node_buds_postprocess((SpaceColonization)arg1, (object)arg2) → None :

C++ signature :

void node_buds_postprocess(PGL::SpaceColonization {lvalue},unsigned long)

node_buds_postprocess( (SpaceColonization)arg1, (object)arg2) -> None :

C++ signature :

void node_buds_postprocess(PySpaceColonization {lvalue},unsigned long)

node_buds_preprocess((SpaceColonization)arg1, (object)arg2) → None :

C++ signature :

void node_buds_preprocess(PGL::SpaceColonization {lvalue},unsigned long)

node_buds_preprocess( (SpaceColonization)arg1, (object)arg2) -> None :

C++ signature :

void node_buds_preprocess(PySpaceColonization {lvalue},unsigned long)

node_direction((SpaceColonization)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 node_direction(PGL::SpaceColonization {lvalue},unsigned long)

node_position((SpaceColonization)arg1, (object)arg2) → Vector3 :

C++ signature :

PGL::Vector3 node_position(PGL::SpaceColonization {lvalue},unsigned long)

property nodelength

property nodes

property parents

property perception_radius

run((SpaceColonization)arg1) → None :

Apply as many steps as it can

C++ signature :

void run(PGL::SpaceColonization {lvalue})

setLengths((SpaceColonization)arg1, (object)node_length[, (object)kill_radius_ratio=0.9[, (object)perception_radius_ratio=2.0]]) → None :

C++ signature :

void setLengths(PGL::SpaceColonization {lvalue},double [,double=0.9 [,double=2.0]])

step((SpaceColonization)arg1) → None :

First generate all buds, and then grow them

C++ signature :

void step(PGL::SpaceColonization {lvalue})

try_to_set_bud((SpaceColonization)arg1, (object)arg2, (Vector3)arg3) → bool :

C++ signature :

bool try_to_set_bud(PGL::SpaceColonization {lvalue},unsigned long,PGL::Vector3)

class SphericalCamera

NDCToSpherical((SphericalCamera)arg1, (Vector3)arg2) → Spherical :

C++ signature :

PGL::Vector3::Spherical NDCToSpherical(PGL::SphericalCamera {lvalue},PGL::Vector3)

SphericalToNDC((SphericalCamera)arg1, (Spherical)arg2) → Vector3 :

C++ signature :

PGL::Vector3 SphericalToNDC(PGL::SphericalCamera {lvalue},PGL::Vector3::Spherical)

solidAngle((SphericalCamera)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) → float :

C++ signature :

double solidAngle(PGL::SphericalCamera {lvalue},unsigned short,unsigned short,unsigned short,unsigned short)

class StrPrinter

property result

str((StrPrinter)arg1) → str :

str() : return string

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > str(PyStrPrinter {lvalue})

class StrVrmlPrinter

clear((StrVrmlPrinter)arg1) → None :

C++ signature :

void clear(PyStrVrmlPrinter*)

class SurfComputer

clear((SurfComputer)arg1) → None :

C++ signature :

void clear(PGL::SurfComputer {lvalue})

process((SurfComputer)arg1, (Scene)arg2) → bool :

C++ signature :

bool process(PGL::SurfComputer {lvalue},PGL::RefCountPtr<PGL::Scene>)

property result

property surface

Return the surface of the shape

class Tesselator

property result

property triangulation

Return the last computed triangulation.

class TriangulationMethod

eConvexTriangulation = openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation

eGreeneTriangulation = openalea.plantgl.algo._pglalgo.TriangulationMethod.eGreeneTriangulation

eOptimalTriangulation = openalea.plantgl.algo._pglalgo.TriangulationMethod.eOptimalTriangulation

eStarTriangulation = openalea.plantgl.algo._pglalgo.TriangulationMethod.eStarTriangulation

eYMonotonePartitioning = openalea.plantgl.algo._pglalgo.TriangulationMethod.eYMonotonePartitioning

names = {'eConvexTriangulation': openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation, 'eGreeneTriangulation': openalea.plantgl.algo._pglalgo.TriangulationMethod.eGreeneTriangulation, 'eOptimalTriangulation': openalea.plantgl.algo._pglalgo.TriangulationMethod.eOptimalTriangulation, 'eStarTriangulation': openalea.plantgl.algo._pglalgo.TriangulationMethod.eStarTriangulation, 'eYMonotonePartitioning': openalea.plantgl.algo._pglalgo.TriangulationMethod.eYMonotonePartitioning}

values = {0: openalea.plantgl.algo._pglalgo.TriangulationMethod.eStarTriangulation, 1: openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation, 2: openalea.plantgl.algo._pglalgo.TriangulationMethod.eGreeneTriangulation, 3: openalea.plantgl.algo._pglalgo.TriangulationMethod.eOptimalTriangulation, 4: openalea.plantgl.algo._pglalgo.TriangulationMethod.eYMonotonePartitioning}

class Turtle

F((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} F(PGL::Turtle {lvalue})

F( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} F(PGL::Turtle {lvalue},double)

F( (Turtle)arg1, (object)arg2, (object)arg3) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} F(PGL::Turtle {lvalue},double,double)

add_parameter(name, value, copy=<function deepcopy>)

Add a parameter to the Turtle that will be push and pop. For this a copy function is asked

arrow((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} arrow(PGL::Turtle {lvalue})

arrow( (Turtle)arg1, (object)heigth [, (object)cap_heigth_ratio=0.2 [, (object)cap_radius_ratio=2]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} arrow(PGL::Turtle {lvalue},double [,double=0.2 [,double=2]])

box((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} box(PGL::Turtle {lvalue})

box( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} box(PGL::Turtle {lvalue},double)

box( (Turtle)arg1, (object)arg2, (object)arg3) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} box(PGL::Turtle {lvalue},double,double)

circle((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} circle(PGL::Turtle {lvalue})

circle( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} circle(PGL::Turtle {lvalue},double)

clearGuide((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} clearGuide(PGL::Turtle {lvalue})

clear_parameters()

Clear the python parameters of the Turtle.

decColor((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} decColor(PGL::Turtle {lvalue})

decId((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} decId(PGL::Turtle {lvalue},unsigned int)

decWidth((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} decWidth(PGL::Turtle {lvalue})

defaultValue((Turtle)arg1) → None :

C++ signature :

void defaultValue(PGL::Turtle {lvalue})

divScale((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} divScale(PGL::Turtle {lvalue},PGL::Vector3)

divScale( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} divScale(PGL::Turtle {lvalue},double,double,double)

divScale( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} divScale(PGL::Turtle {lvalue},double)

down((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} down(PGL::Turtle {lvalue})

down( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} down(PGL::Turtle {lvalue},double)

dump((Turtle)arg1) → None :

C++ signature :

void dump(PGL::Turtle {lvalue})

property elasticity

emptyStack((Turtle)arg1) → bool :

C++ signature :

bool emptyStack(PGL::Turtle {lvalue})

eulerAngles((Turtle)arg1[, (object)azimuth=180[, (object)elevation=90[, (object)roll=0]]]) → Turtle :

Set the orientation of the turtle from the absolute euler angles.

C++ signature :

PGL::Turtle {lvalue} eulerAngles(PGL::Turtle {lvalue} [,double=180 [,double=90 [,double=0]]])

f((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} f(PGL::Turtle {lvalue})

f( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} f(PGL::Turtle {lvalue},double)

frame((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} frame(PGL::Turtle {lvalue})

frame( (Turtle)arg1, (object)heigth [, (object)cap_heigth_ratio=0.2 [, (object)cap_radius_ratio=2 [, (object)colorV=1.0 [, (object)transparency=0.0]]]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} frame(PGL::Turtle {lvalue},double [,double=0.2 [,double=2 [,double=1.0 [,double=0.0]]]])

getColor((Turtle)arg1) → int :

C++ signature :

int getColor(PGL::Turtle {lvalue})

getColorListSize((Turtle)arg1) → int :

C++ signature :

unsigned long getColorListSize(PGL::Turtle {lvalue})

getCurrentMaterial((Turtle)arg1) → Appearance :

C++ signature :

PGL::RefCountPtr<PGL::Appearance> getCurrentMaterial(PGL::Turtle {lvalue})

getDrawer((Turtle)arg1) → TurtleDrawer :

C++ signature :

PGL::RefCountPtr<PGL::TurtleDrawer> getDrawer(PGL::Turtle {lvalue})

getHeading((Turtle)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getHeading(PGL::Turtle {lvalue})

getLeft((Turtle)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getLeft(PGL::Turtle {lvalue})

getOrientationMatrix((Turtle)arg1) → Matrix3 :

C++ signature :

PGL::Matrix3 getOrientationMatrix(PGL::Turtle {lvalue})

getParameters((Turtle)arg1) → TurtleParam :

C++ signature :

PGL::TurtleParam getParameters(PGL::Turtle {lvalue})

getPosition((Turtle)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getPosition(PGL::Turtle {lvalue})

getScale((Turtle)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getScale(PGL::Turtle {lvalue})

getScene((Turtle)arg1) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> getScene(PGL::Turtle {lvalue})

getTransformationMatrix((Turtle)arg1) → Matrix4 :

C++ signature :

PGL::Matrix4 getTransformationMatrix(PGL::Turtle {lvalue})

getUp((Turtle)arg1) → Vector3 :

C++ signature :

PGL::Vector3 getUp(PGL::Turtle {lvalue})

getWidth((Turtle)arg1) → float :

C++ signature :

double getWidth(PGL::Turtle {lvalue})

iRollL((Turtle)arg1[, (object)arg2]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} iRollL(PGL::Turtle {lvalue} [,double])

iRollR((Turtle)arg1[, (object)arg2]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} iRollR(PGL::Turtle {lvalue} [,double])

incColor((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} incColor(PGL::Turtle {lvalue})

incId((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} incId(PGL::Turtle {lvalue},unsigned int)

incWidth((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} incWidth(PGL::Turtle {lvalue})

interpolateColors((Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) → Turtle :

C++ signature :

PGL::Turtle {lvalue} interpolateColors(PGL::Turtle {lvalue},int,int,double)

isValid((Turtle)arg1) → bool :

C++ signature :

bool isValid(PGL::Turtle {lvalue})

label((Turtle)arg1, (str)text[, (object)size=-1.0]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} label(PGL::Turtle {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,int=-1.0])

left((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} left(PGL::Turtle {lvalue})

left( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} left(PGL::Turtle {lvalue},double)

lineRel((Turtle)arg1[, (Vector3)position=Vector3(0, 0, 0)[, (object)topradius=-1.0]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} lineRel(PGL::Turtle {lvalue} [,PGL::Vector3=Vector3(0,0,0) [,double=-1.0]])

lineRel( (Turtle)arg1 [, (object)x=0.0 [, (object)y=0.0 [, (object)z=0.0 [, (object)topradius=-1.0]]]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} lineRel(PGL::Turtle {lvalue} [,double=0.0 [,double=0.0 [,double=0.0 [,double=-1.0]]]])

lineTo((Turtle)arg1[, (Vector3)position=Vector3(0, 0, 0)[, (object)topradius=-1.0]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} lineTo(PGL::Turtle {lvalue} [,PGL::Vector3=Vector3(0,0,0) [,double=-1.0]])

lineTo( (Turtle)arg1 [, (object)x=0.0 [, (object)y=0.0 [, (object)z=0.0 [, (object)topradius=-1.0]]]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} lineTo(PGL::Turtle {lvalue} [,double=0.0 [,double=0.0 [,double=0.0 [,double=-1.0]]]])

move((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} move(PGL::Turtle {lvalue},PGL::Vector3)

move( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} move(PGL::Turtle {lvalue},double,double,double)

multScale((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} multScale(PGL::Turtle {lvalue},PGL::Vector3)

multScale( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} multScale(PGL::Turtle {lvalue},double,double,double)

multScale( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} multScale(PGL::Turtle {lvalue},double)

nF((Turtle)arg1, (object)length, (object)dlength) → Turtle :

C++ signature :

PGL::Turtle {lvalue} nF(PGL::Turtle {lvalue},double,double)

nF( (Turtle)arg1, (object)length, (object)dlength [, (object)radius=1.0 [, (QuantisedFunction)radiusvariation=None]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} nF(PGL::Turtle {lvalue},double,double [,double=1.0 [,PGL::RefCountPtr<PGL::QuantisedFunction>=None]])

oLineRel((Turtle)arg1[, (Vector3)position=Vector3(0, 0, 0)[, (object)topradius=-1.0]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} oLineRel(PGL::Turtle {lvalue} [,PGL::Vector3=Vector3(0,0,0) [,double=-1.0]])

oLineRel( (Turtle)arg1 [, (object)x=0.0 [, (object)y=0.0 [, (object)z=0.0 [, (object)topradius=-1.0]]]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} oLineRel(PGL::Turtle {lvalue} [,double=0.0 [,double=0.0 [,double=0.0 [,double=-1.0]]]])

oLineTo((Turtle)arg1[, (Vector3)position=Vector3(0, 0, 0)[, (object)topradius=-1.0]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} oLineTo(PGL::Turtle {lvalue} [,PGL::Vector3=Vector3(0,0,0) [,double=-1.0]])

oLineTo( (Turtle)arg1 [, (object)x=0.0 [, (object)y=0.0 [, (object)z=0.0 [, (object)topradius=-1.0]]]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} oLineTo(PGL::Turtle {lvalue} [,double=0.0 [,double=0.0 [,double=0.0 [,double=-1.0]]]])

property path_info_cache_enabled

pinpoint((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} pinpoint(PGL::Turtle {lvalue},PGL::Vector3)

pinpoint( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} pinpoint(PGL::Turtle {lvalue},double,double,double)

pinpointRel((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} pinpointRel(PGL::Turtle {lvalue},PGL::Vector3)

pinpointRel( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} pinpointRel(PGL::Turtle {lvalue},double,double,double)

polygonPoint((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} polygonPoint(PGL::Turtle {lvalue})

pop((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} pop(PGL::Turtle {lvalue})

popEvent()

push((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} push(PGL::Turtle {lvalue})

pushEvent()

quad((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} quad(PGL::Turtle {lvalue})

quad( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} quad(PGL::Turtle {lvalue},double)

quad( (Turtle)arg1, (object)arg2, (object)arg3) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} quad(PGL::Turtle {lvalue},double,double)

remove_parameter(name)

Remove a parameter to the Turtle that was pushed and popped.

reset((Turtle)arg1) → None :

C++ signature :

void reset(PGL::Turtle {lvalue})

resetValues((Turtle)arg1) → None :

C++ signature :

void resetValues(PGL::Turtle {lvalue})

right((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} right(PGL::Turtle {lvalue})

right( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} right(PGL::Turtle {lvalue},double)

rollL((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} rollL(PGL::Turtle {lvalue})

rollL( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} rollL(PGL::Turtle {lvalue},double)

rollR((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} rollR(PGL::Turtle {lvalue})

rollR( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} rollR(PGL::Turtle {lvalue},double)

rollToHorizontal((Turtle)arg1[, (object)alpha=1.0[, (Vector3)top=Vector3(0, 0, 1)]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} rollToHorizontal(PGL::Turtle {lvalue} [,double=1.0 [,PGL::Vector3=Vector3(0,0,1)]])

rollToVert((Turtle)arg1[, (object)alpha=1.0[, (Vector3)top=Vector3(0, 0, 1)]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} rollToVert(PGL::Turtle {lvalue} [,double=1.0 [,PGL::Vector3=Vector3(0,0,1)]])

scale((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} scale(PGL::Turtle {lvalue},PGL::Vector3)

scale( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} scale(PGL::Turtle {lvalue},double,double,double)

scale( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} scale(PGL::Turtle {lvalue},double)

property sectionResolution

setAngleIncrement((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setAngleIncrement(PGL::Turtle {lvalue},double)

setColor((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setColor(PGL::Turtle {lvalue},int)

setColorIncrement((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setColorIncrement(PGL::Turtle {lvalue},int)

setCrossSection((Turtle)arg1, (Curve2D)arg2, (object)curve) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setCrossSection(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::Curve2D>,bool)

setCustomAppearance((Turtle)arg1, (Appearance)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setCustomAppearance(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::Appearance>)

setDefaultCrossSection((Turtle)arg1[, (object)slices]) → None :

C++ signature :

void setDefaultCrossSection(PGL::Turtle* [,unsigned long])

setDefaultStep((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setDefaultStep(PGL::Turtle {lvalue},double)

setDrawer((Turtle)arg1, (TurtleDrawer)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setDrawer(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::TurtleDrawer>)

setGuide((Turtle)arg1, (LineicModel)curve, (object)length) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setGuide(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::LineicModel>,double)

setGuide( (Turtle)arg1, (Curve2D)curve, (object)length [, (object)yorientation=False [, (object)ccw=False]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} setGuide(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::Curve2D>,double [,bool=False [,bool=False]])

setHead((Turtle)arg1, (Vector3)head, (Vector3)up) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setHead(PGL::Turtle {lvalue},PGL::Vector3,PGL::Vector3)

setHead( (Turtle)arg1, (object)hx, (object)hy, (object)hz, (object)ux, (object)uy, (object)uz) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} setHead(PGL::Turtle {lvalue},double,double,double,double,double,double)

setId((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setId(PGL::Turtle {lvalue},unsigned int)

setPositionOnGuide((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setPositionOnGuide(PGL::Turtle {lvalue},double)

setScaleMultiplier((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setScaleMultiplier(PGL::Turtle {lvalue},double)

setScreenCoordinatesEnabled((Turtle)arg1[, (object)enabled=True]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setScreenCoordinatesEnabled(PGL::Turtle {lvalue} [,bool=True])

setTextureRotation((Turtle)arg1[, (object)angle=0[, (object)ucenter=0.5[, (object)vcenter=0.5]]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureRotation(PGL::Turtle {lvalue} [,double=0 [,double=0.5 [,double=0.5]]])

setTextureRotation( (Turtle)arg1 [, (object)angle=0 [, (Vector2)center=Vector2(0.5,0.5)]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureRotation(PGL::Turtle {lvalue} [,double=0 [,PGL::Vector2=Vector2(0.5,0.5)]])

setTextureScale((Turtle)arg1, (object)arg2, (object)arg3) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureScale(PGL::Turtle {lvalue},double,double)

setTextureScale( (Turtle)arg1, (Vector2)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureScale(PGL::Turtle {lvalue},PGL::Vector2)

setTextureTransformation((Turtle)arg1[, (object)uscaling=1[, (object)vscaling=1[, (object)utranslation=0[, (object)vtranslation=0[, (object)angle=0[, (object)urotcenter=0.5[, (object)vrotcenter=0.5]]]]]]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureTransformation(PGL::Turtle {lvalue} [,double=1 [,double=1 [,double=0 [,double=0 [,double=0 [,double=0.5 [,double=0.5]]]]]]])

setTextureTransformation( (Turtle)arg1 [, (Vector2)scaling=Vector2(1,1) [, (Vector2)translation=Vector2(0,0) [, (object)angle=0 [, (Vector2)rotcenter=Vector2(0.5,0.5)]]]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureTransformation(PGL::Turtle {lvalue} [,PGL::Vector2=Vector2(1,1) [,PGL::Vector2=Vector2(0,0) [,double=0 [,PGL::Vector2=Vector2(0.5,0.5)]]]])

setTextureTranslation((Turtle)arg1[, (object)u=0[, (object)v=0]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureTranslation(PGL::Turtle {lvalue} [,double=0 [,double=0]])

setTextureTranslation( (Turtle)arg1, (Vector2)t) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureTranslation(PGL::Turtle {lvalue},PGL::Vector2)

setTextureUScale((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureUScale(PGL::Turtle {lvalue},double)

setTextureVScale((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTextureVScale(PGL::Turtle {lvalue},double)

setTropism((Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setTropism(PGL::Turtle {lvalue},double,double,double)

setWidth((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setWidth(PGL::Turtle {lvalue},double)

setWidthIncrement((Turtle)arg1, (object)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} setWidthIncrement(PGL::Turtle {lvalue},double)

shift((Turtle)arg1, (Vector3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} shift(PGL::Turtle {lvalue},PGL::Vector3)

shift( (Turtle)arg1, (object)arg2, (object)arg3, (object)arg4) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} shift(PGL::Turtle {lvalue},double,double,double)

sphere((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} sphere(PGL::Turtle {lvalue})

sphere( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} sphere(PGL::Turtle {lvalue},double)

start((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} start(PGL::Turtle {lvalue})

startGC((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} startGC(PGL::Turtle {lvalue})

startPolygon((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} startPolygon(PGL::Turtle {lvalue})

stop((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} stop(PGL::Turtle {lvalue})

stopGC((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} stopGC(PGL::Turtle {lvalue})

stopPolygon((Turtle)arg1[, (object)concavetest=False]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} stopPolygon(PGL::Turtle {lvalue} [,bool=False])

surface((Turtle)arg1, (str)arg2, (object)arg3) → Turtle :

C++ signature :

PGL::Turtle {lvalue} surface(PGL::Turtle {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,double)

sweep((Turtle)arg1, (Curve2D)path, (Curve2D)section, (object)length, (object)dlength[, (object)radiusmagnitude=1.0[, (QuantisedFunction)radiusvariation=None]]) → Turtle :

C++ signature :

PGL::Turtle {lvalue} sweep(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::Curve2D>,PGL::RefCountPtr<PGL::Curve2D>,double,double [,double=1.0 [,PGL::RefCountPtr<PGL::QuantisedFunction>=None]])

sweep( (Turtle)arg1, (LineicModel)path, (Curve2D)section, (object)length, (object)dlength [, (object)radiusmagnitude=1.0 [, (QuantisedFunction)radiusvariation=None]]) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} sweep(PGL::Turtle {lvalue},PGL::RefCountPtr<PGL::LineicModel>,PGL::RefCountPtr<PGL::Curve2D>,double,double [,double=1.0 [,PGL::RefCountPtr<PGL::QuantisedFunction>=None]])

transform((Turtle)arg1, (Matrix3)arg2) → Turtle :

C++ signature :

PGL::Turtle {lvalue} transform(PGL::Turtle {lvalue},PGL::Matrix3)

property tropism

up((Turtle)arg1) → Turtle :

C++ signature :

PGL::Turtle {lvalue} up(PGL::Turtle {lvalue})

up( (Turtle)arg1, (object)arg2) -> Turtle :

C++ signature :

PGL::Turtle {lvalue} up(PGL::Turtle {lvalue},double)

property warn_on_error

class TurtleDrawer

arrow((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7, (object)arg8, (object)arg9) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} arrow(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,double,double,double,unsigned int)

arrow_color((TurtleDrawer)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7, (object)arg8, (object)arg9, (object)arg10) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} arrow_color(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::FrameInfo,double,double,double,double,double,double,unsigned int)

box((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} box(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,double,double)

circle((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} circle(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,unsigned int)

customGeometry((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (Geometry)arg5, (object)arg6) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} customGeometry(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,PGL::RefCountPtr<PGL::Geometry>,double)

cylinder((TurtleDrawer)arg1, (object)arg2, (object)arg3, (Appearance)arg4, (object)arg5, (object)arg6, (object)arg7) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} cylinder(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::FrameInfo,PGL::RefCountPtr<PGL::Appearance>,double,double,unsigned int)

frame((TurtleDrawer)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7, (object)arg8, (object)arg9, (object)arg10) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} frame(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::FrameInfo,double,double,double,double,double,double,unsigned int)

frustum((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7, (object)arg8) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} frustum(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,double,double,unsigned int)

generalizedCylinder((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (Point3Array)arg5, (object)arg6, (object)arg7, (Curve2D)arg8, (object)arg9, (object)arg10) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} generalizedCylinder(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,PGL::RefCountPtr<PGL::Point3Array>,std::vector<PGL::Vector3, std::allocator<PGL::Vector3> >,std::vector<double, std::allocator<double> >,PGL::RefCountPtr<PGL::Curve2D>,bool,unsigned int)

label((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (str)arg5, (object)arg6, (object)arg7) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} label(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,bool,int)

polygon((TurtleDrawer)arg1, (object)arg2, (object)arg3, (Appearance)arg4, (Point3Array)arg5, (object)arg6) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} polygon(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::FrameInfo,PGL::RefCountPtr<PGL::Appearance>,PGL::RefCountPtr<PGL::Point3Array>,bool)

quad((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} quad(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,double,double)

smallSweep((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6, (object)arg7, (Curve2D)arg8, (object)arg9, (object)arg10) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} smallSweep(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,double,double,PGL::RefCountPtr<PGL::Curve2D>,bool,unsigned int)

sphere((TurtleDrawer)arg1, (object)arg2, (Appearance)arg3, (object)arg4, (object)arg5, (object)arg6) → TurtleDrawer :

C++ signature :

PGL::TurtleDrawer {lvalue} sphere(PGL::TurtleDrawer {lvalue},PGL::id_pair,PGL::RefCountPtr<PGL::Appearance>,PGL::FrameInfo,double,unsigned int)

class TurtleParam

property color

copy((TurtleParam)arg1) → TurtleParam :

C++ signature :

PGL::TurtleParam* copy(PGL::TurtleParam {lvalue})

property crossSection

dump((TurtleParam)arg1) → None :

C++ signature :

void dump(PGL::TurtleParam {lvalue})

generalizedCylinder((TurtleParam)arg1, (object)arg2) → None :

C++ signature :

void generalizedCylinder(PGL::TurtleParam {lvalue},bool)

getOrientationMatrix((TurtleParam)arg1) → Matrix3 :

C++ signature :

PGL::Matrix3 getOrientationMatrix(PGL::TurtleParam {lvalue})

getTransformationMatrix((TurtleParam)arg1) → Matrix4 :

C++ signature :

PGL::Matrix4 getTransformationMatrix(PGL::TurtleParam {lvalue})

property heading

isGeneralizedCylinderOn((TurtleParam)arg1) → bool :

C++ signature :

bool isGeneralizedCylinderOn(PGL::TurtleParam {lvalue})

isPolygonOn((TurtleParam)arg1) → bool :

C++ signature :

bool isPolygonOn(PGL::TurtleParam {lvalue})

isValid((TurtleParam)arg1) → bool :

C++ signature :

bool isValid(PGL::TurtleParam {lvalue})

keepLastPoint((TurtleParam)arg1) → None :

C++ signature :

void keepLastPoint(PGL::TurtleParam {lvalue})

property left

polygon((TurtleParam)arg1, (object)arg2) → None :

C++ signature :

void polygon(PGL::TurtleParam {lvalue},bool)

property position

pushPosition((TurtleParam)arg1) → None :

C++ signature :

void pushPosition(PGL::TurtleParam {lvalue})

removePoints((TurtleParam)arg1) → None :

C++ signature :

void removePoints(PGL::TurtleParam {lvalue})

reset((TurtleParam)arg1) → None :

C++ signature :

void reset(PGL::TurtleParam {lvalue})

property scale

transform((TurtleParam)arg1, (Matrix3)arg2) → None :

C++ signature :

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

property up

property width

class VgStarFilePrinter

class VgStarStrPrinter

clear((VgStarStrPrinter)arg1) → None :

C++ signature :

void clear(PyStrVgstarPrinter*)

class VgstarPrinter

class VolComputer

process((VolComputer)arg1, (Scene)arg2) → bool :

C++ signature :

bool process(PGL::VolComputer {lvalue},PGL::RefCountPtr<PGL::Scene>)

property result

property volume

Return the volume of the shape

class VrmlPrinter

setBackground((VrmlPrinter)arg1, (Color3)arg2) → bool :

setBackGround( Color3)

C++ signature :

bool setBackground(PGL::VrmlPrinter {lvalue},PGL::Color3)

setCamera((VrmlPrinter)arg1, (Vector3)arg2, (object)arg3, (object)arg4, (str)arg5) → bool :

setCamera (Vector3 position, real_t az, real_t el, name)

C++ signature :

bool setCamera(PGL::VrmlPrinter {lvalue},PGL::Vector3,double,double,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

setLight((VrmlPrinter)arg1, (Vector3)arg2, (Color3)arg3, (Color3)arg4, (object)arg5) → bool :

setLight( position: Vector3, ambient: Color3, diffuse: Color3)

C++ signature :

bool setLight(PGL::VrmlPrinter {lvalue},PGL::Vector3,PGL::Color3,PGL::Color3,double)

class WireComputer

property result

property wire

Return the wire representation of the shape

class ZBufferEngine

duplicateBuffer((ZBufferEngine)arg1, (Vector3)from[, (Vector3)to=600[, (object)useDefaultColor=True[, (Color3)defaultcolor=Color3(0, 0, 0)]]]) → None :

C++ signature :

void duplicateBuffer(PGL::ZBufferEngine {lvalue},PGL::Vector3 [,PGL::Vector3=600 [,bool=True [,PGL::Color3=Color3(0,0,0)]]])

duplicateBuffer( (ZBufferEngine)arg1, (object)arg2, (object)from [, (object)to=600 [, (object)useDefaultColor=True [, (Color3)defaultcolor=Color3(0,0,0)]]]) -> None :

C++ signature :

void duplicateBuffer(PGL::ZBufferEngine {lvalue},int,int [,double=600 [,bool=True [,PGL::Color3=Color3(0,0,0)]]])

property faceculling

getDepthBuffer((ZBufferEngine)arg1) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> getDepthBuffer(PGL::ZBufferEngine {lvalue})

getIdBuffer((ZBufferEngine)arg1) → object :

C++ signature :

PGL::RefCountPtr<PGL::NumericArray2<unsigned int> > getIdBuffer(PGL::ZBufferEngine {lvalue})

getIdBufferAsImage((ZBufferEngine)arg1[, (eColor4Format)conversionFormat=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB]) → Image :

C++ signature :

PGL::RefCountPtr<PGL::Image> getIdBufferAsImage(PGL::ZBufferEngine {lvalue} [,PGL::Color4::eColor4Format=openalea.plantgl.scenegraph._pglsg.eColor4Format.eARGB])

getImage((ZBufferEngine)arg1) → Image :

C++ signature :

PGL::RefCountPtr<PGL::Image> getImage(PGL::ZBufferEngine {lvalue})

getOrientationBuffer((ZBufferEngine)arg1) → object :

C++ signature :

PGL::RefCountPtr<PGL::NumericArray2<bool> > getOrientationBuffer(PGL::ZBufferEngine {lvalue})

getRenderingStyle((ZBufferEngine)arg1) → eRenderingStyle :

C++ signature :

PGL::ZBufferEngine::eRenderingStyle getRenderingStyle(PGL::ZBufferEngine {lvalue})

grabSortedZBufferPoints((ZBufferEngine)arg1[, (object)jitter=0[, (object)raywidth=0]]) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> grabSortedZBufferPoints(PGL::ZBufferEngine {lvalue} [,double=0 [,double=0]])

grabZBufferPoints((ZBufferEngine)arg1[, (object)jitter=0[, (object)raywidth=0]]) → object :

C++ signature :

boost::python::api::object grabZBufferPoints(PGL::ZBufferEngine* [,double=0 [,double=0]])

idhistogram((ZBufferEngine)arg1[, (object)solidangle=True]) → object :

C++ signature :

boost::python::api::object idhistogram(PGL::ZBufferEngine* [,bool=True])

isVisible((ZBufferEngine)arg1, (object)x, (object)y, (object)z) → bool :

C++ signature :

bool isVisible(PGL::ZBufferEngine {lvalue},int,int,double)

isVisible( (ZBufferEngine)arg1, (Vector3)position) -> bool :

C++ signature :

bool isVisible(PGL::ZBufferEngine {lvalue},PGL::Vector3)

property multithreaded

periodizeBuffer((ZBufferEngine)arg1, (Vector3)from[, (Vector3)to=600[, (object)useDefaultColor=True[, (Color3)defaultcolor=Color3(0, 0, 0)]]]) → None :

C++ signature :

void periodizeBuffer(PGL::ZBufferEngine {lvalue},PGL::Vector3 [,PGL::Vector3=600 [,bool=True [,PGL::Color3=Color3(0,0,0)]]])

periodizeBuffer( (ZBufferEngine)arg1, (object)arg2, (object)from [, (object)to=600 [, (object)useDefaultColor=True [, (Color3)defaultcolor=Color3(0,0,0)]]]) -> None :

C++ signature :

void periodizeBuffer(PGL::ZBufferEngine {lvalue},int,int [,double=600 [,bool=True [,PGL::Color3=Color3(0,0,0)]]])

setCylindricalCamera((ZBufferEngine)arg1[, (object)viewAngle=180[, (object)bottom=-1[, (object)top=1[, (object)near=0[, (object)far=1.7976931348623157e+308]]]]]) → None :

C++ signature :

void setCylindricalCamera(PGL::ZBufferEngine {lvalue} [,double=180 [,double=-1 [,double=1 [,double=0 [,double=1.7976931348623157e+308]]]]])

setHemisphericCamera((ZBufferEngine)arg1[, (object)near=0[, (object)far=1.7976931348623157e+308]]) → None :

C++ signature :

void setHemisphericCamera(PGL::ZBufferEngine {lvalue} [,double=0 [,double=1.7976931348623157e+308]])

setLight((ZBufferEngine)arg1, (Vector3)position[, (Color3)color=Color3(255, 255, 255)[, (object)directional=False]]) → None :

C++ signature :

void setLight(PGL::ZBufferEngine {lvalue},PGL::Vector3 [,PGL::Color3=Color3(255,255,255) [,bool=False]])

setLight( (ZBufferEngine)arg1, (Vector3)position [, (Color3)ambient=Color3(255,255,255) [, (Color3)diffuse=Color3(255,255,255) [, (Color3)specular=Color3(255,255,255) [, (object)directional=False]]]]) -> None :

C++ signature :

void setLight(PGL::ZBufferEngine {lvalue},PGL::Vector3 [,PGL::Color3=Color3(255,255,255) [,PGL::Color3=Color3(255,255,255) [,PGL::Color3=Color3(255,255,255) [,bool=False]]]])

setSphericalCamera((ZBufferEngine)arg1[, (object)viewAngle=180[, (object)near=0[, (object)far=1.7976931348623157e+308]]]) → None :

C++ signature :

void setSphericalCamera(PGL::ZBufferEngine {lvalue} [,double=180 [,double=0 [,double=1.7976931348623157e+308]]])

adaptive_contration((Point3Array)points, (Point3Array)orientations, (IndexArray)adjacencies, (RealArray)densities, (object)minradius, (object)maxradius[, (QuantisedFunction)densityradiusmap=0[, (object)alpha=1.0[, (object)beta=1.0]]]) → Point3Array :

Contract the pointset with an adptive radius of contraction

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> adaptive_contration(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::RealArray>,double,double [,PGL::RefCountPtr<PGL::QuantisedFunction>=0 [,double=1.0 [,double=1.0]]])

adaptive_radii((RealArray)density, (object)minradius, (object)maxradius[, (QuantisedFunction)densityradiusmap=None]) → RealArray :

Compute a radius for each density value

C++ signature :

PGL::RefCountPtr<PGL::RealArray> adaptive_radii(PGL::RefCountPtr<PGL::RealArray>,double,double [,PGL::RefCountPtr<PGL::QuantisedFunction>=None])

adaptive_section_circles((Point3Array)points, (IndexArray)adjacencies, (Point3Array)directions, (RealArray)widths, (RealArray)maxradii) → object :

C++ signature :

boost::python::api::object adaptive_section_circles(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::RealArray>,PGL::RefCountPtr<PGL::RealArray>)

adaptive_section_circles( (Point3Array)points, (IndexArray)adjacencies, (Point3Array)directions, (object)widths, (RealArray)maxradii) -> object :

C++ signature :

boost::python::api::object adaptive_section_circles(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::Point3Array>,double,PGL::RefCountPtr<PGL::RealArray>)

adaptive_section_contration((Point3Array)points, (Point3Array)orientations, (IndexArray)adjacencies, (RealArray)densities, (object)minradius, (object)maxradius[, (QuantisedFunction)densityradiusmap=0[, (object)alpha=1.0[, (object)beta=1.0]]]) → object :

Contract the pointset with an adptive radius of contraction

C++ signature :

boost::python::api::object adaptive_section_contration(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::RealArray>,double,double [,PGL::RefCountPtr<PGL::QuantisedFunction>=0 [,double=1.0 [,double=1.0]]])

add_baricenter_points_of_path((Point3Array)point, (IndexArray)kclosest, (Index)path, (object)radius) → object :

C++ signature :

boost::python::api::object add_baricenter_points_of_path(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> {lvalue},PGL::PglVector<unsigned int>,double)

approx_pointset_median((Point3Array)points[, (object)nbIterMax=200]) → int :

C++ signature :

unsigned int approx_pointset_median(PGL::RefCountPtr<PGL::Point3Array> [,unsigned int=200])

average_distance_to_shape((Point3Array)points, (Point3Array)nodes, (UIntArray)parents, (RealArray)radii[, (object)maxclosestnodes=10]) → float :

C++ signature :

double average_distance_to_shape(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray> [,unsigned int=10])

average_radius((Point3Array)points, (Point3Array)nodes, (UIntArray)parents[, (object)maxclosestnodes=10]) → float :

C++ signature :

double average_radius(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > [,unsigned int=10])

carried_length((Point3Array)points, (UIntArray)parents) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> carried_length(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >)

centroid_of_group((Point3Array), (Index)group) → Vector3 :

C++ signature :

PGL::Vector3 centroid_of_group(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

centroids_of_groups((Point3Array)points, (IndexArray)groups) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> centroids_of_groups(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

cluster_junction_points((IndexArray)pointtoppology, (Index)group1, (Index)group2) → object :

C++ signature :

boost::python::api::object cluster_junction_points(PGL::RefCountPtr<PGL::IndexArray>,PGL::PglVector<unsigned int>,PGL::PglVector<unsigned int>)

cluster_points((Point3Array)points, (Point3Array)clustercentroid) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> cluster_points(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>)

connect_all_connex_components((Point3Array)points, (IndexArray)adjacencies[, (object)verbose=False]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> connect_all_connex_components(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> [,bool=False])

contract_point2((Point2Array)points, (object)radius) → Point2Array :

C++ signature :

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

contract_point3((Point3Array)points, (object)radius) → Point3Array :

C++ signature :

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

contract_point4((Point4Array)points, (object)radius) → Point4Array :

C++ signature :

PGL::RefCountPtr<PGL::Point4Array> contract_point4(PGL::RefCountPtr<PGL::Point4Array>,double)

delaunay_point_connection((Point3Array)points) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> delaunay_point_connection(PGL::RefCountPtr<PGL::Point3Array>)

delaunay_triangulation((Point3Array)points) → Index3Array :

C++ signature :

PGL::RefCountPtr<PGL::Index3Array> delaunay_triangulation(PGL::RefCountPtr<PGL::Point3Array>)

delaunay_triangulation3D((Point3Array)points) → Index3Array :

C++ signature :

PGL::RefCountPtr<PGL::Index3Array> delaunay_triangulation3D(PGL::RefCountPtr<PGL::Point3Array>)

densities_from_k_neighborhood((Point3Array)points, (IndexArray)adjacencies[, (object)k=0]) → RealArray :

Compute local densities of a set of points according to their k neighboordhood. If k is 0, its value is deduced from adjacencies.

C++ signature :

PGL::RefCountPtr<PGL::RealArray> densities_from_k_neighborhood(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> [,unsigned int=0])

densities_from_r_neighborhood((Point3Array)points, (IndexArray)adjacencies, (object)radius) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> densities_from_r_neighborhood(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double)

densities_from_r_neighborhood( (IndexArray)neighborhood, (object)radius) -> RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> densities_from_r_neighborhood(PGL::RefCountPtr<PGL::IndexArray>,double)

density_from_k_neighborhood((object)pid, (Point3Array)points, (IndexArray)adjacencies[, (object)k=0]) → float :

Compute density of a point according to its k neighboordhood. If k is 0, its value is deduced from adjacencies.

C++ signature :

double density_from_k_neighborhood(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> [,unsigned int=0])

density_from_r_neighborhood((object)pid, (Point3Array)points, (IndexArray)adjacencies, (object)radius) → float :

C++ signature :

double density_from_r_neighborhood(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double)

detect_short_nodes((Point3Array)nodes, (UIntArray)parents[, (object)edgelengthfilter=0.001]) → Index :

C++ signature :

PGL::PglVector<unsigned int> detect_short_nodes(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > [,double=0.001])

detect_similar_nodes((Point3Array)nodes, (UIntArray)parents, (RealArray)radii, (RealArray)weight[, (object)overlapfilter=0.5]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> detect_similar_nodes(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray>,PGL::RefCountPtr<PGL::RealArray> [,double=0.5])

determine_children((UIntArray)arg1) → object :

C++ signature :

boost::python::api::object determine_children(PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >)

determine_faceedges_from_edges((Point2Array)points, (object)edges) → IndexArray :

Return list of edge ids that form faces

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> determine_faceedges_from_edges(PGL::RefCountPtr<PGL::Point2Array>,boost::python::api::object)

determine_faces_from_edges((Point2Array)points, (object)edges) → IndexArray :

Return list of pids that form faces

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> determine_faces_from_edges(PGL::RefCountPtr<PGL::Point2Array>,boost::python::api::object)

dijkstra_shortest_paths((IndexArray)connections, (object)root, (object)edgeweigthevaluator) → object :

Return the parent and distance to the root for each node.connections is an array that should contains at the ith place all nodes connected to the ith node.edgeweigthevaluator should be a function that takes as argument the ids of two nodes and return the weigth of the edge between these 2 nodes.

C++ signature :

boost::python::api::object dijkstra_shortest_paths(PGL::RefCountPtr<PGL::IndexArray>,unsigned int,boost::python::api::object)

dijkstra_shortest_paths_in_a_range((IndexArray)connections, (object)root, (object)edgeweigthevaluator[, (object)maxdist=1.7976931348623157e+308[, (object)maxnbelements=0]]) → object :

Return list of id, parent and distance to the root for node with distance < maxdist. connections is an array that should contains at the ith place all nodes connected to the ith node.edgeweigthevaluator should be a function that takes as argument the ids of two nodes and return the weigth of the edge between these 2 nodes.if maxnbelements is set to 0, no constraints is taken.

C++ signature :

boost::python::api::object dijkstra_shortest_paths_in_a_range(PGL::RefCountPtr<PGL::IndexArray>,unsigned int,boost::python::api::object [,double=1.7976931348623157e+308 [,unsigned int=0]])

discretize((Geometry)arg1) → ExplicitModel :

C++ signature :

PGL::RefCountPtr<PGL::ExplicitModel> discretize(PGL::RefCountPtr<PGL::Geometry>)

distance_to_shape((Point3Array)points, (Point3Array)nodes, (UIntArray)parents, (RealArray)radii[, (object)maxclosestnodes=10]) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> distance_to_shape(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray> [,unsigned int=10])

class eFaceCulling

eBackFaceCulling = openalea.plantgl.algo._pglalgo.eFaceCulling.eBackFaceCulling

eBothFaceCulling = openalea.plantgl.algo._pglalgo.eFaceCulling.eBothFaceCulling

eFrontFaceCulling = openalea.plantgl.algo._pglalgo.eFaceCulling.eFrontFaceCulling

eNoCulling = openalea.plantgl.algo._pglalgo.eFaceCulling.eNoCulling

names = {'eBackFaceCulling': openalea.plantgl.algo._pglalgo.eFaceCulling.eBackFaceCulling, 'eBothFaceCulling': openalea.plantgl.algo._pglalgo.eFaceCulling.eBothFaceCulling, 'eFrontFaceCulling': openalea.plantgl.algo._pglalgo.eFaceCulling.eFrontFaceCulling, 'eNoCulling': openalea.plantgl.algo._pglalgo.eFaceCulling.eNoCulling}

values = {0: openalea.plantgl.algo._pglalgo.eFaceCulling.eNoCulling, 1: openalea.plantgl.algo._pglalgo.eFaceCulling.eBackFaceCulling, 2: openalea.plantgl.algo._pglalgo.eFaceCulling.eFrontFaceCulling, 3: openalea.plantgl.algo._pglalgo.eFaceCulling.eBothFaceCulling}

class eProjectionMethodType

eProjection = openalea.plantgl.algo._pglalgo.eProjectionMethodType.eProjection

eRayIntersection = openalea.plantgl.algo._pglalgo.eProjectionMethodType.eRayIntersection

names = {'eProjection': openalea.plantgl.algo._pglalgo.eProjectionMethodType.eProjection, 'eRayIntersection': openalea.plantgl.algo._pglalgo.eProjectionMethodType.eRayIntersection}

values = {0: openalea.plantgl.algo._pglalgo.eProjectionMethodType.eProjection, 1: openalea.plantgl.algo._pglalgo.eProjectionMethodType.eRayIntersection}

class eProjectionType

eCylindrical = openalea.plantgl.algo._pglalgo.eProjectionType.eCylindrical

eHemispheric = openalea.plantgl.algo._pglalgo.eProjectionType.eHemispheric

eOrthographic = openalea.plantgl.algo._pglalgo.eProjectionType.eOrthographic

ePerspective = openalea.plantgl.algo._pglalgo.eProjectionType.ePerspective

names = {'eCylindrical': openalea.plantgl.algo._pglalgo.eProjectionType.eCylindrical, 'eHemispheric': openalea.plantgl.algo._pglalgo.eProjectionType.eHemispheric, 'eOrthographic': openalea.plantgl.algo._pglalgo.eProjectionType.eOrthographic, 'ePerspective': openalea.plantgl.algo._pglalgo.eProjectionType.ePerspective}

values = {0: openalea.plantgl.algo._pglalgo.eProjectionType.eOrthographic, 1: openalea.plantgl.algo._pglalgo.eProjectionType.ePerspective, 2: openalea.plantgl.algo._pglalgo.eProjectionType.eHemispheric, 3: openalea.plantgl.algo._pglalgo.eProjectionType.eCylindrical}

class eRenderingStyle

eColorAndOrientationBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eColorAndOrientationBased

eColorBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eColorBased

eDepthOnly = openalea.plantgl.algo._pglalgo.eRenderingStyle.eDepthOnly

eIdAndColorAndOrientationBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndColorAndOrientationBased

eIdAndColorBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndColorBased

eIdAndOrientationBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndOrientationBased

eIdBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdBased

eOrientationBased = openalea.plantgl.algo._pglalgo.eRenderingStyle.eOrientationBased

names = {'eColorAndOrientationBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eColorAndOrientationBased, 'eColorBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eColorBased, 'eDepthOnly': openalea.plantgl.algo._pglalgo.eRenderingStyle.eDepthOnly, 'eIdAndColorAndOrientationBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndColorAndOrientationBased, 'eIdAndColorBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndColorBased, 'eIdAndOrientationBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndOrientationBased, 'eIdBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdBased, 'eOrientationBased': openalea.plantgl.algo._pglalgo.eRenderingStyle.eOrientationBased}

values = {0: openalea.plantgl.algo._pglalgo.eRenderingStyle.eDepthOnly, 1: openalea.plantgl.algo._pglalgo.eRenderingStyle.eColorBased, 2: openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdBased, 3: openalea.plantgl.algo._pglalgo.eRenderingStyle.eOrientationBased, 5: openalea.plantgl.algo._pglalgo.eRenderingStyle.eColorAndOrientationBased, 6: openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndOrientationBased, 7: openalea.plantgl.algo._pglalgo.eRenderingStyle.eIdAndColorAndOrientationBased}

estimate_radii_from_pipemodel((Point3Array)nodes, (UIntArray)parents, (RealArray)weights, (object)averageradius[, (object)pipeexponent=2.5]) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> estimate_radii_from_pipemodel(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray>,double [,double=2.5])

estimate_radii_from_points((Point3Array)points, (Point3Array)nodes, (UIntArray)parents[, (object)maxmethod=False[, (object)maxclosestnodes=10]]) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> estimate_radii_from_points(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > [,bool=False [,unsigned int=10]])

filter_max_densities((RealArray)densities, (object)densityratio) → Index :

C++ signature :

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

filter_min_densities((RealArray)densities, (object)densityratio) → Index :

C++ signature :

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

findClosestFromSubset((Vector3)origin, (Point3Array)points[, (Index)group=Index()]) → object :

C++ signature :

boost::python::api::object findClosestFromSubset(PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

fit((str)algo, (Geometry)src) → Geometry :

C++ signature :

PGL::RefCountPtr<PGL::Geometry> fit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,PGL::RefCountPtr<PGL::Geometry>)

formFactors((Point3Array)points, (Index3Array)triangles[, (Point3Array)normals=None[, (object)ccw=True[, (object)discretization=200[, (object)solidangle=200]]]]) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> formFactors(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Index3Array> [,PGL::RefCountPtr<PGL::Point3Array>=None [,bool=True [,unsigned short=200 [,bool=200]]]])

frombinarystring((object)arg1) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> frombinarystring(boost::python::api::object)

generate_point_color((PointSet)point) → Color4Array :

C++ signature :

PGL::RefCountPtr<PGL::Color4Array> generate_point_color(PGL::PointSet {lvalue})

get_all_connex_components((Point3Array)points, (IndexArray)adjacencies[, (object)verbose=False]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> get_all_connex_components(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> [,bool=False])

get_radii_of_path((Point3Array)point, (IndexArray)kclosest, (Index)path, (object)around_radius) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> get_radii_of_path(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::PglVector<unsigned int>,double)

get_shortest_path((Point3Array)points, (IndexArray)kclosest, (object)point_begin, (object)point_end) → Index :

C++ signature :

PGL::PglVector<unsigned int> get_shortest_path(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> {lvalue},unsigned int,unsigned int)

get_sorted_element_order((RealArray)elements) → Index :

C++ signature :

PGL::PglVector<unsigned int> get_sorted_element_order(PGL::RefCountPtr<PGL::RealArray>)

inertiaAxis((Point3Array)points) → object :

C++ signature :

boost::python::api::object inertiaAxis(PGL::Point3Array*)

inertiaAxis( (Point2Array)points) -> object :

C++ signature :

boost::python::api::object inertiaAxis(PGL::Point2Array*)

isPglParserVerbose() → bool :

C++ signature :

bool isPglParserVerbose()

is_point_in_cone((Vector2)arg1, (Vector2)arg2, (Vector2)arg3, (object)arg4, (object)arg5) → bool :

C++ signature :

bool is_point_in_cone(PGL::Vector2,PGL::Vector2,PGL::Vector2,double,double)

is_point_in_cone( (Vector3)arg1, (Vector3)arg2, (Vector3)arg3, (object)arg4, (object)arg5) -> bool :

C++ signature :

bool is_point_in_cone(PGL::Vector3,PGL::Vector3,PGL::Vector3,double,double)

is_point_in_cone( (Vector4)arg1, (Vector4)arg2, (Vector4)arg3, (object)arg4, (object)arg5) -> bool :

C++ signature :

bool is_point_in_cone(PGL::Vector4,PGL::Vector4,PGL::Vector4,double,double)

is_simple_polygon((Point2Array)contour) → bool :

C++ signature :

bool is_simple_polygon(PGL::RefCountPtr<PGL::Point2Array>)

k_closest_points_from_ann((Point3Array)points, (object)k[, (object)symmetric=False]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> k_closest_points_from_ann(PGL::RefCountPtr<PGL::Point3Array>,unsigned long [,bool=False])

k_closest_points_from_delaunay((Point3Array)points, (object)k) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> k_closest_points_from_delaunay(PGL::RefCountPtr<PGL::Point3Array>,unsigned long)

k_neighborhood((object)pid, (Point3Array)points, (IndexArray)adjacencies, (object)k) → Index :

C++ signature :

PGL::PglVector<unsigned int> k_neighborhood(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,unsigned int)

k_neighborhoods((Point3Array)points, (IndexArray)adjacencies, (object)k) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> k_neighborhoods(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,unsigned int)

merge_nodes((IndexArray)tomerge, (Point3Array)nodes, (UIntArray)parents, (RealArray)radii, (RealArray)weight) → object :

C++ signature :

boost::python::api::object merge_nodes(PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray>,PGL::RefCountPtr<PGL::RealArray>)

min_max_mean_edge_length((Point3Array)points, (UIntArray)parents) → Vector3 :

C++ signature :

PGL::Vector3 min_max_mean_edge_length(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >)

min_max_mean_edge_length( (Point3Array)points, (IndexArray)graph) -> Vector3 :

C++ signature :

PGL::Vector3 min_max_mean_edge_length(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

next_quotient_points_from_adjacency_graph((object)initiallevel, (object)binsize, (Index)current, (IndexArray)adjacencies, (RealArray)distances_to_root) → object :

C++ signature :

boost::python::api::object next_quotient_points_from_adjacency_graph(double,double,PGL::PglVector<unsigned int>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::RealArray>)

node_continuity_test((Vector3)node, (object)radius, (Vector3)parent, (object)parentradius, (Vector3)child, (object)radius[, (object)overlapfilter=0.5[, (object)verbose=False]]) → object :

C++ signature :

boost::python::api::object node_continuity_test(PGL::Vector3,double,PGL::Vector3,double,PGL::Vector3,double [,double=0.5 [,bool=False]])

node_intersection_test((Vector3)parent, (object)parentradius, (Vector3)node1, (object)radius1, (Vector3)node2, (object)radius2[, (object)overlapfilter=0.5[, (object)verbose=False]]) → object :

C++ signature :

boost::python::api::object node_intersection_test(PGL::Vector3,double,PGL::Vector3,double,PGL::Vector3,double [,double=0.5 [,bool=False]])

optimize_orientations((Point3Array)points, (UIntArray)parents, (RealArray)weights) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> optimize_orientations(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray>)

optimize_positions((Point3Array)points, (Point3Array)orientations, (UIntArray)parents, (RealArray)weights) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> optimize_positions(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,PGL::RefCountPtr<PGL::RealArray>)

orientations_distances((Point3Array)orientations[, (Index)group=Index()]) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> orientations_distances(PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

orientations_similarities((Point3Array)orientations[, (Index)group=Index()]) → RealArray2 :

C++ signature :

PGL::RefCountPtr<PGL::RealArray2> orientations_similarities(PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

pglParserVerbose([(object)verbose=True]) → None :

C++ signature :

void pglParserVerbose([ bool=True])

pgl_read((str)input[, (str)fname='string']) → object :

C++ signature :

boost::python::api::object pgl_read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’string’])

plane_pointset_clip((Plane3)plane, (Point3Array)points[, (Index)subgroup=Index()]) → Index :

Clip the pointset according to the plane.

C++ signature :

PGL::PglVector<unsigned int> plane_pointset_clip(PGL::Plane3,PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

plane_segment_clip((Plane3)plane, (Vector3)point1, (Vector3)point2) → Point3Array :

Clip segment according to the plane.

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> plane_segment_clip(PGL::Plane3,PGL::Vector3,PGL::Vector3)

plane_triangle_clip((Plane3)plane, (Vector3)point1, (Vector3)point2, (Vector3)point3) → Point3Array :

Clip triangle according to the plane.

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> plane_triangle_clip(PGL::Plane3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

point_section((object)pid, (Point3Array)points, (IndexArray)adjacencies, (Vector3)direction, (object)width) → Index :

C++ signature :

PGL::PglVector<unsigned int> point_section(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::Vector3,double)

point_section( (object)pid, (Point3Array)points, (IndexArray)adjacencies, (Vector3)direction, (object)width, (object)maxradius) -> Index :

C++ signature :

PGL::PglVector<unsigned int> point_section(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::Vector3,double,double)

points_at_distance_from_skeleton((Point3Array)points, (Point3Array)nodes, (UIntArray)parents, (object)distance[, (object)maxclosestnodes=10]) → Index :

Return indices of all point which are below a given distance ot the skeleton. If distance is negative, return point above a distance

C++ signature :

PGL::PglVector<unsigned int> points_at_distance_from_skeleton(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >,double [,unsigned int=10])

points_clusters((Point3Array)points, (Point3Array)clustercentroid) → UIntArray :

C++ signature :

PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > points_clusters(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>)

points_dijkstra_shortest_path((Point3Array)points, (IndexArray)adjacencies, (object)root) → object :

C++ signature :

boost::python::api::object points_dijkstra_shortest_path(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,unsigned int)

points_in_range_from_root((object)initiallevel, (object)binsize, (RealArray)distances_to_root) → Index :

C++ signature :

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

points_sections((Point3Array)points, (IndexArray)adjacencies, (Point3Array)directions, (object)width) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> points_sections(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::Point3Array>,double)

pointset_angulardirections((Point3Array)points[, (Vector3)origin=Vector3(0, 0, 0)[, (Index)group=Index()]]) → Point2Array :

C++ signature :

PGL::RefCountPtr<PGL::Point2Array> pointset_angulardirections(PGL::RefCountPtr<PGL::Point3Array> [,PGL::Vector3=Vector3(0,0,0) [,PGL::PglVector<unsigned int>=Index()]])

pointset_circle((Point3Array)points, (Index)group[, (object)direction=None[, (object)bounding=False]]) → object :

C++ signature :

boost::python::api::object pointset_circle(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int> [,boost::python::api::object=None [,bool=False]])

pointset_covariance((Point3Array)points[, (Index)group=Index()]) → Matrix3 :

C++ signature :

PGL::Matrix3 pointset_covariance(PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

pointset_directions((Vector3)origin, (Point3Array)points[, (Index)group=Index()]) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> pointset_directions(PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

pointset_max_distance((object)pid, (Point3Array)points, (Index)group) → float :

C++ signature :

double pointset_max_distance(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_max_distance( (Vector3)center, (Point3Array)points, (Index)group) -> float :

C++ signature :

double pointset_max_distance(PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_max_radial_distance((Vector3)center, (Vector3)direction, (Point3Array)points, (Index)group) → float :

C++ signature :

double pointset_max_radial_distance(PGL::Vector3,PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_mean_direction((Vector3)origin, (Point3Array)points[, (Index)group=Index()]) → Vector3 :

C++ signature :

PGL::Vector3 pointset_mean_direction(PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array> [,PGL::PglVector<unsigned int>=Index()])

pointset_mean_distance((Vector3)center, (Point3Array)points, (Index)group) → float :

C++ signature :

double pointset_mean_distance(PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_mean_distances((Point3Array)arg1, (Point3Array)points, (IndexArray)groups) → RealArray :

C++ signature :

PGL::RefCountPtr<PGL::RealArray> pointset_mean_distances(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

pointset_mean_radial_distance((Vector3)center, (Vector3)direction, (Point3Array)points, (Index)group) → float :

C++ signature :

double pointset_mean_radial_distance(PGL::Vector3,PGL::Vector3,PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_median((Point3Array)points) → int :

C++ signature :

unsigned int pointset_median(PGL::RefCountPtr<PGL::Point3Array>)

pointset_normal((Point3Array)points, (Index)groups) → Vector3 :

C++ signature :

PGL::Vector3 pointset_normal(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_orientation((Point3Array)points, (Index)group) → Vector3 :

C++ signature :

PGL::Vector3 pointset_orientation(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointset_plane((Point3Array)points, (Index)group) → object :

C++ signature :

boost::python::api::object pointset_plane(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

pointsets_circles((Point3Array)points, (IndexArray)groups[, (Point3Array)directions=None[, (object)bounding=False]]) → object :

C++ signature :

boost::python::api::object pointsets_circles(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> [,PGL::RefCountPtr<PGL::Point3Array>=None [,bool=False]])

pointsets_normals((Point3Array)points, (IndexArray)groups) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> pointsets_normals(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

pointsets_orient_normals((Point3Array)normals, (Point3Array)points, (IndexArray)adjacencies) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> pointsets_orient_normals(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

pointsets_orient_normals( (Point3Array)normals, (object)source, (IndexArray)adjacencies) -> Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> pointsets_orient_normals(PGL::RefCountPtr<PGL::Point3Array>,unsigned int,PGL::RefCountPtr<PGL::IndexArray>)

pointsets_orientations((Point3Array)points, (IndexArray)groups) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> pointsets_orientations(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

pointsets_section_circles((Point3Array)points, (IndexArray)adjacencies, (Point3Array)directions, (object)width[, (object)bounding=False]) → object :

C++ signature :

boost::python::api::object pointsets_section_circles(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::Point3Array>,double [,bool=False])

polygon2ds_intersection((Point2Array)polygon1, (Point2Array)polygon1) → object :

Compute intersection between two 2D polygons.

C++ signature :

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

polygon2ds_intersection( (Point2Array)points, (Index)polygon1, (Index)polygon1) -> object :

Compute intersection between two 2D polygons.

C++ signature :

boost::python::api::object polygon2ds_intersection(PGL::RefCountPtr<PGL::Point2Array>,PGL::PglVector<unsigned int>,PGL::PglVector<unsigned int>)

polygonization((Point2Array)contour[, (TriangulationMethod)method=openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> polygonization(PGL::RefCountPtr<PGL::Point2Array> [,PGL::TriangulationMethod=openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation])

principal_curvatures((Point3Array)points, (object)pid, (Index)group[, (object)fitting_degree=4[, (object)monge_degree=4]]) → object :

Compute principal curvature information. Return a tuple with folowin informations: (origin,(maximal_curvature_direction,maximal_curvature),(minimal_curvature_direction,minimal_curvature),normal)

C++ signature :

boost::python::api::object principal_curvatures(PGL::RefCountPtr<PGL::Point3Array>,unsigned int,PGL::PglVector<unsigned int> [,unsigned long=4 [,unsigned long=4]])

principal_curvatures( (Point3Array)points, (IndexArray)groups [, (object)fitting_degree=4 [, (object)monge_degree=4]]) -> object :

C++ signature :

boost::python::api::object principal_curvatures(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> [,unsigned long=4 [,unsigned long=4]])

principal_curvatures( (Point3Array)points, (IndexArray)adjacencies, (object)radius [, (object)fitting_degree=4 [, (object)monge_degree=4]]) -> object :

C++ signature :

boost::python::api::object principal_curvatures(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double [,unsigned long=4 [,unsigned long=4]])

quotient_adjacency_graph((IndexArray)adjacencies, (IndexArray)groups) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> quotient_adjacency_graph(PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::IndexArray>)

quotient_points_from_adjacency_graph((object)binsize, (Point3Array)points, (IndexArray)adjacencies, (RealArray)distances_to_root) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> quotient_points_from_adjacency_graph(double,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::RealArray>)

r_anisotropic_neighborhood((object)pid, (Point3Array)points, (IndexArray)adjacencies, (object)radius, (Vector3)direction, (object)alpha, (object)beta) → Index :

C++ signature :

PGL::PglVector<unsigned int> r_anisotropic_neighborhood(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double,PGL::Vector3,double,double)

r_anisotropic_neighborhoods((Point3Array)points, (IndexArray)adjacencies, (RealArray)radii, (Point3Array)directions, (object)alpha, (object)beta) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_anisotropic_neighborhoods(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::RealArray>,PGL::RefCountPtr<PGL::Point3Array>,double,double)

r_anisotropic_neighborhoods( (Point3Array)points, (IndexArray)adjacencies, (object)radius, (Point3Array)directions, (object)alpha, (object)beta) -> IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_anisotropic_neighborhoods(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double,PGL::RefCountPtr<PGL::Point3Array>,double,double)

r_neighborhood((object)pid, (Point3Array)points, (IndexArray)adjacencies, (object)radius) → Index :

C++ signature :

PGL::PglVector<unsigned int> r_neighborhood(unsigned int,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double)

r_neighborhoods((Point3Array)points, (IndexArray)adjacencies, (RealArray)radii) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_neighborhoods(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,PGL::RefCountPtr<PGL::RealArray>)

r_neighborhoods( (Point3Array)points, (IndexArray)adjacencies, (object)radius [, (object)verbose=False]) -> IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_neighborhoods(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double [,bool=False])

r_neighborhoods_mt((Point3Array)points, (IndexArray)adjacencies, (object)radius[, (object)verbose=False]) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> r_neighborhoods_mt(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>,double [,bool=False])

random_point_in_box((Vector3)minpt, (Vector3)maxpt) → Vector3 :

C++ signature :

PGL::Vector3 random_point_in_box(PGL::Vector3,PGL::Vector3)

random_point_in_tetrahedron((Vector3)p0, (Vector3)p1, (Vector3)p2, (Vector3)p3) → Vector3 :

C++ signature :

PGL::Vector3 random_point_in_tetrahedron(PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

random_points_in_tetrahedra((object)nb_per_tetra, (Point3Array)pointlist, (Index4Array)tetraindices) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> random_points_in_tetrahedra(unsigned long,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Index4Array>)

random_points_in_tetrahedron((object)nb, (Vector3)p0, (Vector3)p1, (Vector3)p2, (Vector3)p3) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> random_points_in_tetrahedron(unsigned long,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

remove_nodes((Index)toremove, (Point3Array)nodes, (UIntArray)parents[, (RealArray)radii=None]) → object :

C++ signature :

boost::python::api::object remove_nodes(PGL::PglVector<unsigned int>,PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > [,PGL::RefCountPtr<PGL::RealArray>=None])

section_normal((Point3Array)pointnormals, (Index)section) → Vector3 :

C++ signature :

PGL::Vector3 section_normal(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>)

sections_normals((Point3Array)pointnormals, (IndexArray)sections) → Point3Array :

C++ signature :

PGL::RefCountPtr<PGL::Point3Array> sections_normals(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray>)

segmentIntersect((Vector2)segA1, (Vector2)segA2, (Vector2)segB1, (Vector2)segB2) → bool :

C++ signature :

bool segmentIntersect(PGL::Vector2,PGL::Vector2,PGL::Vector2,PGL::Vector2)

segmentIntersect( (Vector3)segA1, (Vector3)segA2, (Vector3)point) -> bool :

C++ signature :

bool segmentIntersect(PGL::Vector3,PGL::Vector3,PGL::Vector3)

segmentIntersect( (Vector3)segA1, (Vector3)segA2, (Vector3)segB1, (Vector3)segB2) -> bool :

C++ signature :

bool segmentIntersect(PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

segmentIntersect( (Vector3)segA1, (Vector3)segA2, (Vector3)tr1, (Vector3)tr2, (Vector3)tr3) -> bool :

C++ signature :

bool segmentIntersect(PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

segmentIntersect( (Vector3)segA1, (Vector3)segA2, (Vector3)qd1, (Vector3)qd2, (Vector3)qd3, (Vector3)qd3) -> bool :

C++ signature :

bool segmentIntersect(PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

select_pole_from_point((Point3Array)points, (Vector3)startPoint, (object)iterations, (object)maxAngle) → object :

C++ signature :

boost::python::api::object select_pole_from_point(PGL::RefCountPtr<PGL::Point3Array>,PGL::Vector3,unsigned long,double)

select_pole_points((Point3Array)point, (object)radius, (object)iterations[, (object)tolerance=-1.0]) → object :

C++ signature :

boost::python::api::object select_pole_points(PGL::RefCountPtr<PGL::Point3Array>,double,unsigned int [,double=-1.0])

select_pole_points_mt((Point3Array)point, (object)radius, (object)iterations[, (object)tolerance=-1.0]) → object :

C++ signature :

boost::python::api::object select_pole_points_mt(PGL::RefCountPtr<PGL::Point3Array>,double,unsigned int [,double=-1.0])

select_soil((Point3Array)point, (IndexArray)kclosest, (object)topHeightPourcent, (object)bottomThreshold) → Index :

C++ signature :

PGL::PglVector<unsigned int> select_soil(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::IndexArray> {lvalue},unsigned int,double)

select_wire_from_path((Point3Array)point, (Index)path, (object)radius, (RealArray)radii) → Index :

C++ signature :

PGL::PglVector<unsigned int> select_wire_from_path(PGL::RefCountPtr<PGL::Point3Array>,PGL::PglVector<unsigned int>,double,PGL::RefCountPtr<PGL::RealArray>)

skeleton_from_distance_to_root_clusters((Point3Array)points, (object)root, (object)binsize[, (object)k=10[, (object)connect_all_points=False[, (object)verbose=False]]]) → object :

Implementation of Xu et al. 07 method for main branching system

C++ signature :

boost::python::api::object skeleton_from_distance_to_root_clusters(PGL::RefCountPtr<PGL::Point3Array>,unsigned int,double [,unsigned int=10 [,bool=False [,bool=False]]])

subtrees_size((UIntArray)parents) → UIntArray :

C++ signature :

PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > subtrees_size(PGL::RefCountPtr<PGL::NumericArray1<unsigned int> >)

subtrees_size( (IndexArray)children, (object)root) -> UIntArray :

C++ signature :

PGL::RefCountPtr<PGL::NumericArray1<unsigned int> > subtrees_size(PGL::RefCountPtr<PGL::IndexArray>,unsigned int)

surface((Scene)arg1) → float :

Compute surface of a scene

C++ signature :

double surface(PGL::RefCountPtr<PGL::Scene>)

surface( (Geometry)arg1) -> float :

Compute surface of a geometry

C++ signature :

double surface(PGL::Geometry*)

surface( (Shape)arg1) -> float :

Compute surface of a shape

C++ signature :

double surface(PGL::Shape*)

surface( (Vector2)arg1, (Vector2)arg2, (Vector2)arg3) -> float :

Compute surface of a 2D triangle

C++ signature :

double surface(PGL::Vector2,PGL::Vector2,PGL::Vector2)

surface( (Vector3)arg1, (Vector3)arg2, (Vector3)arg3) -> float :

Compute surface of a triangle

C++ signature :

double surface(PGL::Vector3,PGL::Vector3,PGL::Vector3)

surfaces((Index3Array)arg1, (Point3Array)arg2) → RealArray :

Compute the surfaces of a set of triangles

C++ signature :

PGL::RefCountPtr<PGL::RealArray> surfaces(PGL::Index3Array*,PGL::Point3Array*)

symmetrize_connections((IndexArray)adjacencies) → IndexArray :

C++ signature :

PGL::RefCountPtr<PGL::IndexArray> symmetrize_connections(PGL::RefCountPtr<PGL::IndexArray>)

tesselate((Geometry)arg1) → TriangleSet :

C++ signature :

PGL::RefCountPtr<PGL::TriangleSet> tesselate(PGL::RefCountPtr<PGL::Geometry>)

tobinarystring((Scene)scene[, (object)double_precision=True[, (str)comment='']]) → object :

C++ signature :

boost::python::api::object tobinarystring(PGL::RefCountPtr<PGL::Scene> [,bool=True [,char const*=’’]])

triangle_triangle_intersection((Vector3)arg1, (Vector3)arg2, (Vector3)arg3, (Vector3)arg4, (Vector3)arg5, (Vector3)arg6) → object :

C++ signature :

boost::python::api::object triangle_triangle_intersection(PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3,PGL::Vector3)

triangleset_orientation((Point3Array)points, (Index3Array)triangles) → Vector3 :

C++ signature :

PGL::Vector3 triangleset_orientation(PGL::RefCountPtr<PGL::Point3Array>,PGL::RefCountPtr<PGL::Index3Array>)

triangulation((Point2Array)contour[, (TriangulationMethod)method=openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation]) → Index3Array :

C++ signature :

PGL::RefCountPtr<PGL::Index3Array> triangulation(PGL::RefCountPtr<PGL::Point2Array> [,PGL::TriangulationMethod=openalea.plantgl.algo._pglalgo.TriangulationMethod.eConvexTriangulation])

volume((Scene)arg1) → float :

Compute volume of a scene

C++ signature :

double volume(PGL::RefCountPtr<PGL::Scene>)

volume( (Geometry)arg1) -> float :

Compute volume of a geometry

C++ signature :

double volume(PGL::Geometry*)

volume( (Shape)arg1) -> float :

Compute volume of a shape

C++ signature :

double volume(PGL::Shape*)

wire((Geometry)arg1) → Geometry :

Compute the wire representation of a geometry

C++ signature :

PGL::RefCountPtr<PGL::Geometry> wire(PGL::Geometry*)

wire( (Shape)arg1) -> Geometry :

Compute the wire representation of a shape

C++ signature :

PGL::RefCountPtr<PGL::Geometry> wire(PGL::Shape*)