NemAll_Python_Geometry

Exposed classes and functions from NemAll_Python_Geometry

 
Classes
       
Boost.Python.enum(builtins.int)
Offset3DPlane
PolyhedronType
eApproximationSettingsType
eBoolOpResult
eBoxPoint
eClothoidType
eCreatePatchResult
eFilletErrorCode
eFilletType
eGeometryErrorCode
eLinePointIdentification
ePolygonHealingSettings
ePolygonNormalizeType
ePolyhedronHealingSettings
eProjectionMatrixType
eServiceResult
eSplitResult
eSurfaceTrimParam
eValidationStatusPolygon3D
Boost.Python.instance(builtins.object)
Angle
AngleList
ApproximationSettings
Arc2D
Arc2DList
Arc3D
Arc3DList
Axis2D
Axis3D
AxisPlacement2D
AxisPlacement2DList
AxisPlacement3D
AxisPlacement3DList
BRep3D
BRep3DList
BSpline2DList
BSpline3DList
BSplineSurface3D
BSplineSurface3DList
BoundingBox2D
BoundingBox2DList
ChamferCalculus
ClippedSweptSolid3D
ClippedSweptSolid3DList
ClosedArea2D
ClosedArea2DList
ClosedArea3D
ClosedArea3DList
ClosedAreaComposite2D
ClosedAreaComposite2DList
ClosedAreaComposite3D
ClosedAreaComposite3DList
Clothoid2D
Clothoid2DList
Comparison
Cone3D
Cone3DList
ConicalSurface3D
ConicalSurface3DList
Cuboid3D
Cuboid3DList
Cylinder3D
Cylinder3DList
DivisionPoints
Ellipsoid3D
Ellipsoid3DList
ExtrudedAreaSolid3D
ExtrudedAreaSolid3DList
FilletCalculus2D
FilletCalculus3D
GeometryEdge
GeometryEdgeList
Kanten_t
Line2D
Line2DList
Line3D
Line3DList
Matrix2D
Matrix3D
MinMax2D
MinMax2DList
MinMax3D
OrientedEdge
OrientedEdgeList
Path
Path2D
Path3D
Path2DList
Path3DList
Plane3D
Point2D
Point2DList
Point3D
Point3DList
PolyPoints2D
BSpline2D
Polygon2D
Polyline2D
Spline2D
PolyPoints3D
BSpline3D
Polygon3D
Polyline3D
Spline3D
Polygon2DList
Polygon3DList
PolygonalArea
PolygonalArea2D
PolygonalArea3D
PolygonalArea2DList
PolygonalArea3DList
Polyhedron3D
Polyhedron3DList
PolyhedronFace
Polyline2DList
Polyline3DList
Spline2DList
Spline3DList
TangentCalculus
TransformCoord
Vector2D
Vector2DList
Vector3D
Vector3DList

 
class Angle(Boost.Python.instance)
    Angle class
 
 
Method resolution order:
Angle
Boost.Python.instance
builtins.object

Methods defined here:
DegToRad(...)
DegToRad( (float)angleDeg) -> float :
    Convert angle from deg to rad
    
    Can be used for initialization of Angle class with deg angle.
    
    Angle angle(Angle::DegToRad(45));  // angle will be 0.75[rad] (approx.)
    
    Parameter: angleDeg  Angle in deg
    
    Return: Angle in rad
Get(...)
Get( (Angle)arg1) -> float :
    Get angle as radian value.
    
    Return: double as radian value.
GetDeg(...)
GetDeg( (Angle)arg1) -> float :
    Get angle as degree value.
    
    Return: double as degree value.
Normalize2Pi(...)
Normalize2Pi( (Angle)arg1) -> None :
    Normalize the angle to a range of <0, 2PI>.
    
    This method is checked and throwing exception (THROW_GEO_EXCEPTION_OUT_OF_RANGE_)
    while angle is out of range <-1e8, 1e8>. The algorithm isn't stable for angle out of this range.
NormalizePi(...)
NormalizePi( (Angle)arg1) -> None :
    Normalize the angle to a range of <-PI, PI>.
    
    This method is checked and throwing exception (THROW_GEO_EXCEPTION_OUT_OF_RANGE_)
    while angle is out of range <-1e8, 1e8>. The algorithm isn't stable for angle out of this range.
RadToDeg(...)
RadToDeg( (float)angleRad) -> float :
    Convert angle from rad to deg
    
    Parameter: angleRad  Angle in rad
    
    Return: Angle in rad
RadToGrad(...)
RadToGrad( (float)angleRad) -> float :
    Convert angle from rad to grad
    
    Parameter: angleRad  Angle in rad
    
    Return: Angle in grad
Set(...)
Set( (Angle)arg1, (float)angle) -> None :
    Set angle as radian value.
    
    Parameter: angle  angle which will be set.
    
 
Set( (Angle)arg1, (Angle)angle) -> None :
    Set angle as radian value.
    
    Parameter: angle  angle which will be set.
SetDeg(...)
SetDeg( (Angle)arg1, (float)angleDeg) -> None :
    Set angle as degree value.
    
    Parameter: angleDeg  angle as degree value which will be set.
__add__(...)
__add__( (Angle)arg1, (Angle)angle) -> object :
    Addition operator
    
    Parameter: angle  Angle which will be added
    
    Return:  New angle
 
__add__( (Angle)arg1, (float)angle) -> object :
    Addition operator
    
    Parameter: angle  Angle as double value which will be added
    
    Return:  New angle
__eq__(...)
__eq__( (Angle)arg1, (Angle)angle) -> object :
    Comparison of angles without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: angle  Compared angle.
    
    Return: True when angles are equal, otherwise false.
__float__(...)
__float__( (Angle)arg1) -> object :
    Type conversion operator.
    
    Return: Angle as double.
__iadd__(...)
__iadd__( (object)arg1, (Angle)angle) -> object :
    Addition assignment operator.
    
    Parameter: angle  Angle which will be added.
    
    Return: Reference to Angle.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (float)angle) -> None :
    Constructor.
    
    Initialize angle from single value
    
    Parameter: angle  Angle.
__isub__(...)
__isub__( (object)arg1, (Angle)angle) -> object :
    Subtraction assignment operator.
    
    Parameter: angle  Angle which will be subtracted.
    
    Return: Reference to Angle.
__ne__(...)
__ne__( (Angle)arg1, (Angle)angle) -> object :
    Comparison of angles without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: angle Compared angle.
    
    Return: True when angles are not equal, otherwise false.
__reduce__ = (...)
__repr__(...)
__repr__( (Angle)arg1) -> str

Data descriptors defined here:
Deg
Property access for the angle degree value
Rad
Property access for the angle radiant value

Data and other attributes defined here:
__instance_size__ = 24

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class AngleList(Boost.Python.instance)
    
Method resolution order:
AngleList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (AngleList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (AngleList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (AngleList)arg1) -> int
__reduce__ = (...)
__setitem__(...)
__setitem__( (AngleList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (AngleList)arg1, (object)arg2) -> None
extend(...)
extend( (AngleList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ApproximationSettings(Boost.Python.instance)
    Class holding approximation options.
 
 
Method resolution order:
ApproximationSettings
Boost.Python.instance
builtins.object

Methods defined here:
GetDensity(...)
GetDensity( (ApproximationSettings)arg1) -> float :
    Get Density value
    
    Return: density value
GetMaxAngle(...)
GetMaxAngle( (ApproximationSettings)arg1) -> Angle :
    Get Maximal Angle value
    
    Return: maximal angle value
GetMaxDistance(...)
GetMaxDistance( (ApproximationSettings)arg1) -> float :
    Get MaxDistance value
    
    Return: const Reference to MaxDistance value
GetMaxLength(...)
GetMaxLength( (ApproximationSettings)arg1) -> float :
    Get MaxLength value
    
    Return: const Reference to MaxLength value
GetMinLength(...)
GetMinLength( (ApproximationSettings)arg1) -> float :
    Get Minimal Length value
    
    Return: minimal length value
GetSegmentation(...)
GetSegmentation( (ApproximationSettings)arg1) -> int :
    Get Segmentation value
    
    Return: const Reference to Segmentation value
GetType(...)
GetType( (ApproximationSettings)arg1) -> eApproximationSettingsType :
    Get Type of the settings
    
    Return: const Reference to Settings type
IsBRepTesselation(...)
IsBRepTesselation( (ApproximationSettings)arg1) -> bool :
    Check whether the type of the settings is ASET_BREP_TESSELATION
    
    Return: true/false.
IsMaxDistance(...)
IsMaxDistance( (ApproximationSettings)arg1) -> bool :
    Check whether the type of the settings is ASET_MAX_DISTANCE
    
    Return: true/false.
IsMaxLength(...)
IsMaxLength( (ApproximationSettings)arg1) -> bool :
    Check whether the type of the settings is ASET_MAX_LENGTH
    
    Return: true/false.
IsSegmentation(...)
IsSegmentation( (ApproximationSettings)arg1) -> bool :
    Check whether the type of the settings is ASET_SEGMENTATION
    
    Return: true/false.
SetBRepTesselation(...)
SetBRepTesselation( (ApproximationSettings)arg1, (float)density, (Angle)maxLength, (float)minLength, (float)maxAngle) -> None :
    Set all settings for BRep3D tesselation.
    
    Parameter: density    new density value.
               maxLength  new maximal edge length value.
               minLength  new minimal edge length value.
               maxAngle   new maximal angle value.
SetMaxDistance(...)
SetMaxDistance( (ApproximationSettings)arg1, (float)maxDistance) -> None :
    Set MaxDistance value.
    
    Parameter: maxDistance  new MaxDistance value.
SetMaxLength(...)
SetMaxLength( (ApproximationSettings)arg1, (float)maxLength) -> None :
    Set MaxLength value.
    
    Parameter: maxLength  new MaxLength value.
SetSegmentation(...)
SetSegmentation( (ApproximationSettings)arg1, (int)segmentation) -> None :
    Set Segmentation.
    
    Parameter: segmentation  new Segmentation value.
__eq__(...)
__eq__( (ApproximationSettings)arg1, (ApproximationSettings)right) -> object :
    Operator ==
    
    Parameter: right  settings to compare
    
    Return:  true if settings are equal
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (eApproximationSettingsType)oType, (float)value) -> None :
    Default constructor.
    
    Other members will be set to 0. Types can be found in GeometryEnums.h
    
    Parameter: oType  Type of the settings which will be set
               value  value which will be set
 
__init__( (object)arg1, (ApproximationSettings)options) -> None :
    Copy constructor.
    
    Parameter: options  ApproximationSettings which will be copied.
__ne__(...)
__ne__( (ApproximationSettings)arg1, (ApproximationSettings)right) -> object :
    Operator !=
    
    Parameter: right  settings to compare
    
    Return:  true if settings are NOT equal
__reduce__ = (...)

Data and other attributes defined here:
__instance_size__ = 72

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Arc2D(Boost.Python.instance)
    Arc2D could be a circular or elliptical arc. All angles are given as central angles.
In case of an elliptical arc the ellipse angle and the central angle do not correspond.
All start angle is normalized to the range [-PI..2PI]. The winding direction of the arc could either
be in clockwise or in counterclockwise direction.
 
 
Method resolution order:
Arc2D
Boost.Python.instance
builtins.object

Methods defined here:
Close(...)
Close( (Arc2D)arg1) -> None :
    Close arc
    
    End angle will be adjusted to close arc.
GetAxisAngle(...)
GetAxisAngle( (Arc2D)arg1) -> Angle :
    Get the axis angle
    
    Returns the angle of the major axis
    
    Return: axis angle.
GetCenter(...)
GetCenter( (Arc2D)arg1) -> Point2D :
    Get center point
    
    Return: center point
GetCenterRel(...)
GetCenterRel( (Arc2D)arg1) -> Point2D :
    Get center point in relative coordinate system.
    
    Return: center point
GetDeltaAngle(...)
GetDeltaAngle( (Arc2D)arg1) -> Angle :
    Get difference between EndAngle and StartAngle
    
    Return: delta angle
GetEndAngle(...)
GetEndAngle( (Arc2D)arg1) -> Angle :
    Get end angle
    
    Return: end angle
GetEndPoint(...)
GetEndPoint( (Arc2D)arg1) -> Point2D :
    Get the end point in world coordinate system.
    
    Return: point.
GetEndRelPoint(...)
GetEndRelPoint( (Arc2D)arg1) -> Point2D :
    Get the end point in relative coordinate system
    
    Return: constant reference to point.
GetEndTangent(...)
GetEndTangent( (Arc2D)arg1) -> Vector2D :
    Get tangent vector at the end point of Arc
    
    Return: Tangent vector (unit vector)
GetMajorRadius(...)
GetMajorRadius( (Arc2D)arg1) -> float :
    Get major radius
    
    Return: major radius
GetMinorRadius(...)
GetMinorRadius( (Arc2D)arg1) -> float :
    Get minor radius
    
    Return: minor radius
GetPoint(...)
GetPoint( (Arc2D)arg1, (Angle)angle) -> Point2D :
    Get point on Arc in world coordinate system
    
    Calculates the point at central angle in parameter angle on the Arc
    
    Parameter: angle  central angle of the point
    
    Return: point on Arc
GetRefPoint(...)
GetRefPoint( (Arc2D)arg1) -> Point2D :
    Get reference point
    
    Return: reference point
GetStartAngle(...)
GetStartAngle( (Arc2D)arg1) -> Angle :
    Get start angle
    
    Return: start angle
GetStartPoint(...)
GetStartPoint( (Arc2D)arg1) -> Point2D :
    Get the start point in world coordinate system.
    
    Return: point.
GetStartRelPoint(...)
GetStartRelPoint( (Arc2D)arg1) -> Point2D :
    Get the start point in relative coordinate system
    
    Return: constant reference to point.
GetStartTangent(...)
GetStartTangent( (Arc2D)arg1) -> Vector2D :
    Get tangent vector at the start point of Arc
    
    Return: Tangent vector (unit vector)
IsAngleOnArc(...)
IsAngleOnArc( (Arc2D)arg1, (Angle)angle) -> bool :
    Checks if the given angle lies on the arc
    
    Parameter: angle  angle to test
    
    Return: Angle on arc true/false
IsCircle(...)
IsCircle( (Arc2D)arg1) -> bool :
    Test if ellipse is circle
    
    Tests if major radius equals minor radius
    
    Return: if ellipse is circle
IsClosed(...)
IsClosed( (Arc2D)arg1) -> bool :
    Check if arc is closed ( Full circle/ellipse )
    
    Return: closed curve true/false
IsCounterClockwise(...)
IsCounterClockwise( (Arc2D)arg1) -> bool :
    Returns winding direction counterclockwise true/false
    
    Return:  Is counterclockwise true/false
Reverse(...)
Reverse( (Arc2D)arg1) -> None :
    Reverse of current arc
    
    Method reverse Arc, start with end angle and orientation.
SetAxisAngle(...)
SetAxisAngle( (Arc2D)arg1, (Angle)angle) -> None :
    Set the axis angle
    
    Set the angle of the major axis
    
    Parameter: angle  axis angle
SetCenter(...)
SetCenter( (Arc2D)arg1, (Point2D)center) -> None :
    Set center point
    
    Parameter: center  center point
SetCenterRel(...)
SetCenterRel( (Arc2D)arg1, (Point2D)center) -> None :
    Set center point in local coordinate system
    
    Parameter: center  center point
SetCounterClockwise(...)
SetCounterClockwise( (Arc2D)arg1, (bool)ccw) -> None :
    Set the winding direction of the arc
    
    Parameter: ccw  winding counterclockwise true/false
SetEndAngle(...)
SetEndAngle( (Arc2D)arg1, (Angle)angle) -> None :
    Set end angle
    
    Set the end angle
    
    Parameter: angle  end angle
SetEndPoint(...)
SetEndPoint( (Arc2D)arg1, (Point2D)endpoint) -> None :
    Set the end point in world coordinate system
    
    Parameter: endpoint  constant reference to 2D point
SetMajorRadius(...)
SetMajorRadius( (Arc2D)arg1, (float)radius) -> None :
    Set major radius
    
    Parameter: radius  major radius
SetMinorRadius(...)
SetMinorRadius( (Arc2D)arg1, (float)radius) -> None :
    Set minor radius
    
    Parameter: radius  minor radius
SetRefPoint(...)
SetRefPoint( (Arc2D)arg1, (Point2D)refPoint) -> None :
    Set reference point
    
    Parameter: refPoint  reference point
SetStartAngle(...)
SetStartAngle( (Arc2D)arg1, (Angle)angle) -> None :
    Set start angle
    
    Set the start angle
    
    Parameter: angle  start angle
SetStartPoint(...)
SetStartPoint( (Arc2D)arg1, (Point2D)startpoint) -> None :
    Set the start point in world coordinate system
    
    Parameter: startpoint  constant reference to 2D point
Supplement(...)
Supplement( (Arc2D)arg1) -> None :
    Convert to supplementary arc
    
    Orientation of arc will not be changed.
__eq__(...)
__eq__( (Arc2D)arg1, (Arc2D)arc) -> object :
    Comparison of arcs without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: arc  Compared arc.
    
    Return: True when arcs are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Arc2D)arc) -> None :
    Copy constructor.
    
    Parameter: arc  Arc2D to be copied
    
 
__init__( (object)arg1, (Point2D)center, (float)minor, (float)major, (float)axisangle, (float)startangle, (float)endangle [, (bool)counterClockwise]) -> None :
    Constructor
    
    Parameter: center            Center point
               minor             Minor radius
               major             Major radius
               axisangle         Axis angle
               startangle        Start angle
               endangle          End angle
               counterClockwise  Direction is counter clockwise: true/false
    
 
__init__( (object)arg1, (Point2D)center, (float)radius [, (bool)counterClockwise]) -> None :
    Constructor for creating circle
    
    Create circle as arc with start angle 0 [rad] and end angle 2pi [rad].
    Minor and major radii are equal.
    
    Parameter: center            Center point
               radius            Minor radius
               counterClockwise  Direction is counter clockwise: true/false
__mul__(...)
__mul__( (Arc2D)arg1, (Matrix2D)matrix) -> object :
    Matrix transformation.
    
    Parameter: matrix  transformation matrix.
    
    Return: transformed Arc2D.
__reduce__ = (...)
__repr__(...)
__repr__( (Arc2D)arg1) -> str

Data descriptors defined here:
AxisAngle
Get and set the axis angle as property
Center
Get and set the center point as property
CenterRel
Get and set the center point in the relative coordinate system as property
CounterClockwise
Get and set the counter clockwise flag as property
DeltaAngle
Get the delta angle as property
EndAngle
Get and set the end angle as property
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
MajorRadius
Get and set the major radius as property
MinorRadius
Get and set the minor radius as property
RefPoint
Get and set the reference point as property
StartAngle
Get and set the start angle as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Data and other attributes defined here:
__instance_size__ = 96

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Arc2DList(Boost.Python.instance)
    
Method resolution order:
Arc2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Arc2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Arc2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Arc2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Arc2DList)arg1) -> str
__setitem__(...)
__setitem__( (Arc2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Arc2DList)arg1, (object)arg2) -> None
extend(...)
extend( (Arc2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Arc3D(Boost.Python.instance)
    Arc3D could be a circular or elliptical arc. All angles are given as central angles.
In case of an elliptical arc the ellipse angle and the central angle do not correspond.
All start angle is normalized to the range [-PI..2PI]. The winding direction of the arc could either
be in clockwise or in counterclockwise direction.
 
 
Method resolution order:
Arc3D
Boost.Python.instance
builtins.object

Methods defined here:
Close(...)
Close( (Arc3D)arg1) -> None :
    Close the arc.
    
    Set the delta angle to 2Pi, to close the arc
GetCenter(...)
GetCenter( (Arc3D)arg1) -> Point3D :
    Get center.
    
    Return: Point3D center point
GetCenterRel(...)
GetCenterRel( (Arc3D)arg1) -> Point3D :
    Get center in relative coordinate system
    
    Return: Point3D center point
GetDeltaAngle(...)
GetDeltaAngle( (Arc3D)arg1) -> Angle :
    Get the delta angle
    
    Return: delta angle
GetEndAngle(...)
GetEndAngle( (Arc3D)arg1) -> Angle :
    Get end angle.
    
    Return: angle as const Angle.
GetEndPoint(...)
GetEndPoint( (Arc3D)arg1) -> Point3D :
    Get end point in world coordinates
    
    Return: end point.
GetEndRelPoint(...)
GetEndRelPoint( (Arc3D)arg1) -> Point3D :
    Get end point in relative coordinates
    
    Return: End Point in relative coordinates.
GetLocalPoint(...)
GetLocalPoint( (Arc3D)arg1, (Point3D)arg2) -> Point3D :
    Get the local coordinates of a global world point
    
    Return: point angle
GetMajorAxis(...)
GetMajorAxis( (Arc3D)arg1) -> Vector3D :
    Get the major axis
    
    The major axis is calculated according to the plane normal and the axis angle
    
    Return: major axis as Vector3D
GetMajorRadius(...)
GetMajorRadius( (Arc3D)arg1) -> float :
    Get major radius.
    
    Return: major radius as const double.
GetMinorAxis(...)
GetMinorAxis( (Arc3D)arg1) -> Vector3D :
    Get the minor axis
    
    The minor axis is calculated via the cross product of major axis and plane normal
    
    Return: minor axis as Vector3D
GetMinorRadius(...)
GetMinorRadius( (Arc3D)arg1) -> float :
    Get minor radius.
    
    Return: minor radius as const double.
GetNormVector(...)
GetNormVector( (Arc3D)arg1) -> Vector3D :
    Get normvector.
    
    Return: normvector as const Vector3D.
GetOrigin(...)
GetOrigin( (Arc3D)arg1) -> Point3D :
    Get Origin.
    
    Return: Point3D Origin
GetPoint(...)
GetPoint( (Arc3D)arg1, (Angle)angle) -> Point3D :
    Get point on arc with given angle in world coordinates
    
    Parameter: angle  central angle of the point
    
    Return: point on arc as Point3D.
GetPointAngle(...)
GetPointAngle( (Arc3D)arg1, (Point3D)arg2) -> Angle :
    Get the angle of a point
    
    Return: point angle
GetPointRel(...)
GetPointRel( (Arc3D)arg1, (Angle)angle) -> Point3D :
    Get point on arc with given angle in relative coordinates
    
    Parameter: angle  central angle of the point
    
    Return: point on arc as Point3D.
GetRefPlacement(...)
GetRefPlacement( (Arc3D)arg1) -> AxisPlacement3D :
    Get the reference placement
    
    Return: reference placement
GetRefPlacementRel(...)
GetRefPlacementRel( (Arc3D)arg1) -> AxisPlacement3D :
    Get the reference placement
    
    Return: reference placement
GetRefPoint(...)
GetRefPoint( (Arc3D)arg1) -> Point3D :
    Get the reference point
    
    Return: reference point
GetStartAngle(...)
GetStartAngle( (Arc3D)arg1) -> Angle :
    Get start angle.
    
    Return: angle as const Angle.
GetStartPoint(...)
GetStartPoint( (Arc3D)arg1) -> Point3D :
    Get start point in world coordinates
    
    Return: start point
GetStartRelPoint(...)
GetStartRelPoint( (Arc3D)arg1) -> Point3D :
    Get start point in relative coordinates
    
    Return: start point in relative coordinates
GetXAxis(...)
GetXAxis( (Arc3D)arg1) -> Vector3D :
    Get Major axis (X-Axis of the placement).
    
    Return: Major axis as const Vector3D.
GetZAxis(...)
GetZAxis( (Arc3D)arg1) -> Vector3D :
    Get Normal vector of the placement.
    
    Return: Normal vector as const Vector3D.
IsAngleOnArc(...)
IsAngleOnArc( (Arc3D)arg1, (Angle)angle) -> bool :
    Checks if the given angle lies on the arc
    
    Parameter: angle  angle to test
    
    Return: Angle on arc true/false
IsCircle(...)
IsCircle( (Arc3D)arg1) -> bool :
    Check if minor radius equals major radius
    
    Return: result of check as bool.
IsClockwise(...)
IsClockwise( (Arc3D)arg1) -> bool :
    Returns winding direction clockwise true/false
    
    Return:  Is winding direction clockwise true/false
IsClosed(...)
IsClosed( (Arc3D)arg1) -> bool :
    Check delta angle is 2pi
    
    Return: result of check as bool.
IsCounterClockwise(...)
IsCounterClockwise( (Arc3D)arg1) -> bool :
    Returns winding direction counterclockwise true/false
    
    Return:  Is winding direction counterclockwise true/false
IsEpsilonClosed(...)
IsEpsilonClosed( (Arc3D)arg1) -> bool :
    Check delta angle is 2pi
    
    Return: result of check as bool.
IsValid(...)
IsValid( (Arc3D)arg1) -> bool :
    Checks if the arc is valid
    
    Return: Validity true/false
Reverse(...)
Reverse( (Arc3D)arg1) -> None :
    Reverse of current arc
    
    Method reverse Arc, start with end angle and orientation.
RotateAroundLocalZAxis(...)
RotateAroundLocalZAxis( (Arc3D)arg1, (Angle)angle) -> None :
    Rotate the arc around the Z-axis (normal vector)
    
    Parameter: angle  Rotation angle
SetCenter(...)
SetCenter( (Arc3D)arg1, (Point3D)center) -> None :
    Set center point.
    
    Parameter: center  center point
SetCenterRel(...)
SetCenterRel( (Arc3D)arg1, (Point3D)center) -> None :
    Set center point in local coordinate system
    
    Parameter: center  center point
SetClockwise(...)
SetClockwise( (Arc3D)arg1, (bool)cw) -> None :
    Set the winding direction of the arc
    
    Parameter: cw  winding clockwise true/false
 
SetClockwise( (Arc3D)arg1) -> None :
    Set the winding direction of the arc to CW
SetCounterClockwise(...)
SetCounterClockwise( (Arc3D)arg1, (bool)ccw) -> None :
    Set the winding direction of the arc
    
    Parameter: ccw  winding counterclockwise true/false
 
SetCounterClockwise( (Arc3D)arg1) -> None :
    Set the winding direction of the arc to CCW
SetDeltaAngle(...)
SetDeltaAngle( (Arc3D)arg1, (Angle)deltaAngle) -> None :
    Set the delta angle.
    
    Set the delta angle
    
    Parameter: deltaAngle  angle which will be set.
SetEndAngle(...)
SetEndAngle( (Arc3D)arg1, (Angle)angle) -> None :
    Set end angle.
    
    Set the end angle and normalize it to [0,2PI[
    
    Parameter: angle  angle which will be set.
 
SetEndAngle( (Arc3D)arg1, (Angle)angle, (bool)ccw) -> None :
    Set end angle.
    
    Set the end angle and normalize it to [0,2PI[
    
    Parameter: angle  angle which will be set.
               ccw    in counterclockwise winding
SetEndPoint(...)
SetEndPoint( (Arc3D)arg1, (Point3D)endpoint) -> None :
    Set the end point of an object in world coordinates
    
    Parameter: endpoint  New end point of curve
SetMajorRadius(...)
SetMajorRadius( (Arc3D)arg1, (float)radius) -> None :
    Set major radius.
    
    Parameter: radius  major radius
SetMinorRadius(...)
SetMinorRadius( (Arc3D)arg1, (float)radius) -> None :
    Set minor radius.
    
    Parameter: radius  minor radius
SetNormVector(...)
SetNormVector( (Arc3D)arg1, (Vector3D)normalVec) -> None :
    Set the normvector
    
    Set the plane normal and normalizes it to unit vector
    
    Parameter: normalVec  Vector3D to be set
SetOrigin(...)
SetOrigin( (Arc3D)arg1, (Point3D)center) -> None :
    Set Origin
    
    Parameter: center  Origin
SetRefPlacement(...)
SetRefPlacement( (Arc3D)arg1, (AxisPlacement3D)refPlacement) -> None :
    Set the reference placement
    
    Parameter: refPlacement  reference placement
    
 
SetRefPlacement( (Arc3D)arg1, (Point3D)center, (Vector3D)xAxis, (Vector3D)normalVec) -> None :
    Set the reference placement
    
    Parameter: center     center point
               xAxis      X-axis of the arc
               normalVec  normal vector (Z-axis) of the arc
SetRefPlacementRel(...)
SetRefPlacementRel( (Arc3D)arg1, (AxisPlacement3D)refPlacement) -> None :
    Set the reference placement relative to the refPoint
    
    Parameter: refPlacement  reference placement
SetRefPoint(...)
SetRefPoint( (Arc3D)arg1, (Point3D)refPoint) -> None :
    Set the reference point
    
    Parameter: refPoint  reference point
SetStartAngle(...)
SetStartAngle( (Arc3D)arg1, (Angle)angle) -> None :
    Set start angle
    
    Set the start angle and normalize it to [0,2PI[
    
    Parameter: angle  angle which will be set.
 
SetStartAngle( (Arc3D)arg1, (Angle)angle, (bool)ccw) -> None :
    Set start angle.
    
    Set the start angle and normalize it to [0,2PI[
    
    Parameter: angle  angle which will be set.
               ccw    in counterclockwise winding
SetStartPoint(...)
SetStartPoint( (Arc3D)arg1, (Point3D)startpoint) -> None :
    Set the start point of an object in world coordinates
    
    Parameter: startpoint  New start point of curve
__eq__(...)
__eq__( (Arc3D)arg1, (Arc3D)arc) -> object :
    Comparison of arcs without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: arc  Compared arc.
    
    Return: True when arcs are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Arc3D)arc) -> None :
    Copy constructor.
    
    Parameter: arc  Arc3D which will be copied.
    
 
__init__( (object)arg1, (Point3D)center, (Vector3D)xDir, (Vector3D)normVector, (float)minor, (float)major, (float)startAngle, (float)deltaAngle) -> None :
    Constructor
    
    Parameter: center      Center point
               xDir        X-axis
               normVector  Normal vector
               minor       Minor radius
               major       Major radius
               startAngle  Start angle
               deltaAngle  Delta angle
 
__init__( (object)arg1, (Point3D)center, (Vector3D)xDir, (Vector3D)normVector, (float)minor, (float)major, (float)startAngle, (float)endAngle, (bool)counterClockwise) -> None :
    Constructor
    
    Parameter: center            Center point
               xDir              X-axis
               normVector        Normal vector
               minor             Minor radius
               major             Major radius
               startAngle        Start angle
               endAngle          End angle
               counterClockwise  Winding direction
 
__init__( (object)arg1, (Point3D)center, (float)minor, (float)major, (float)startAngle, (float)deltaAngle) -> None :
    Constructor
    
    Parameter: center      Center point
               minor       Minor radius
               major       Major radius
               startAngle  Start angle
               deltaAngle  Delta angle
 
__init__( (object)arg1, (Point3D)center, (float)minor, (float)major, (float)startAngle, (float)endAngle, (bool)counterClockwise) -> None :
    Constructor
    
    Parameter: center            Center point
               minor             Minor radius
               major             Major radius
               startAngle        Start angle
               endAngle          End angle
               counterClockwise  Winding direction
 
__init__( (object)arg1, (AxisPlacement3D)placement, (float)minor, (float)major, (float)startAngle, (float)deltaAngle) -> None :
    Constructor
    
    Parameter: placement   3D Placement
               minor       Minor radius
               major       Major radius
               startAngle  Start angle
               deltaAngle  Delta angle
 
__init__( (object)arg1, (AxisPlacement3D)placement, (float)minor, (float)major, (float)startAngle, (float)endAngle, (bool)counterClockwise) -> None :
    Constructor
    
    Parameter: placement         3D Placement
               minor             Minor radius
               major             Major radius
               startAngle        Start angle
               endAngle          End angle
               counterClockwise  Winding direction
 
__init__( (object)arg1, (Arc2D)arc2D) -> None :
    Constructor
    
    Parameter: arc2D  Arc to copy
__reduce__ = (...)
__repr__(...)
__repr__( (Arc3D)arg1) -> str

Data descriptors defined here:
Center
Get and set the center point as property
CenterRel
Get and set the center point in the relative coordinate system as property
CounterClockwise
Get and set the counter clockwise flag as property
DeltaAngle
Get and set the delta angle as property
EndAngle
Get and set the end angle as property
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
MajorRadius
Get and set the major radius as property
MinorRadius
Get and set the minor radius as property
RefPoint
Get and set the reference point as property
StartAngle
Get and set the start angle as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Data and other attributes defined here:
__instance_size__ = 152

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Arc3DList(Boost.Python.instance)
    
Method resolution order:
Arc3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Arc3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Arc3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Arc3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Arc3DList)arg1) -> str
__setitem__(...)
__setitem__( (Arc3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Arc3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Arc3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Axis2D(Boost.Python.instance)
    Axis2D
 
 
Method resolution order:
Axis2D
Boost.Python.instance
builtins.object

Methods defined here:
GetAxisPoint(...)
GetAxisPoint( (Axis2D)arg1) -> Point2D :
    Get axis point in world coordinate system.
    
    Return: Axis point in world coordinates
GetAxisPoint2(...)
GetAxisPoint2( (Axis2D)arg1) -> Point2D :
    Get second axis point. Used world coordinate system.
    
    Return: Second axis point in world coordinates
GetAxisRelPoint(...)
GetAxisRelPoint( (Axis2D)arg1) -> Point2D :
    Get axis point in local coordinate system
    
    Return: Axis point in local coordinates
GetAxisRelPoint2(...)
GetAxisRelPoint2( (Axis2D)arg1) -> Point2D :
    Get second axis point. Used local coordinate system
    
    Return: Second axis point in local coordinates
GetRefPoint(...)
GetRefPoint( (Axis2D)arg1) -> Point2D :
    Get reference point.
    
    Return: Reference point
GetVector(...)
GetVector( (Axis2D)arg1) -> Vector2D :
    Get axis vector
    
    Return: Axis vector
Set(...)
Set( (Axis2D)arg1, (Axis2D)axis) -> None :
    Set axis
    
    Parameter: axis  Axis which will be copied
 
Set( (Axis2D)arg1, (Point2D)refPoint, (Point2D)axisPoint, (Vector2D)vector) -> None :
    Set axis
    
    Used local coordinate system for axisPoint
    
    Parameter: refPoint   Reference point
               axisPoint  Axis point
               vector     Axis vector
SetAxisPoint(...)
SetAxisPoint( (Axis2D)arg1, (Point2D)point) -> None :
    Set axis point, used world coordinate system.
    
    Parameter: point  Axis point in world coordinates
SetAxisRelPoint(...)
SetAxisRelPoint( (Axis2D)arg1, (Point2D)axisPoint) -> None :
    Set axis point, used local coordinate system.
    
    Parameter: axisPoint  Axis point in local coordinates
SetRefPoint(...)
SetRefPoint( (Axis2D)arg1, (Point2D)refPoint) -> None :
    Set reference point
    
    Parameter: refPoint  New reference point
SetVector(...)
SetVector( (Axis2D)arg1, (Vector2D)vector) -> None :
    Set axis vector
    
    Parameter: vector  New axis vector
__eq__(...)
__eq__( (Axis2D)arg1, (Axis2D)axis) -> object :
    Comparison of axis objects without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: axis  Compared axis.
    
    Return: True when axis objects are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Axis2D)axis) -> None :
    Copy constructor.
    
    Parameter: axis  Axis which will be copied
 
__init__( (object)arg1, (Point2D)axisPoint, (Vector2D)vector) -> None :
    Constructor.
    
    Reference point is initialized to [0.,0.]
    Used world coordinate system for AxisPoint
    
    Parameter: axisPoint  Axis point
               vector     Axis vector
 
__init__( (object)arg1, (Point2D)refPoint, (Point2D)axisPoint, (Vector2D)vector) -> None :
    Constructor.
    
    Used local coordinate system for AxisPoint
    
    Parameter: refPoint   Reference point
               axisPoint  Axis point
               vector     Axis vector
 
__init__( (object)arg1, (Line2D)line) -> None :
    Explicit constructor from Line2D
    
    Parameter: line  2D line
__reduce__ = (...)
__repr__(...)
__repr__( (Axis2D)arg1) -> str

Data descriptors defined here:
AxisPoint
Get and set the axis point as property
AxisRefPoint
Get and set the axis ref point as property
AxisRelPoint
Get and set the axis point in local coordinate system as property
AxisVector
Get and set the vector as property

Data and other attributes defined here:
__instance_size__ = 64

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Axis3D(Boost.Python.instance)
    Axis3D
 
 
Method resolution order:
Axis3D
Boost.Python.instance
builtins.object

Methods defined here:
GetAxisPoint(...)
GetAxisPoint( (Axis3D)arg1) -> Point3D :
    Get axis point in world coordinate system.
    
    Return: Axis point in world coordinates
GetAxisPoint2(...)
GetAxisPoint2( (Axis3D)arg1) -> Point3D :
    Get second axis point. Used world coordinate system.
    
    Return: Second axis point in world coordinates
GetAxisRelPoint(...)
GetAxisRelPoint( (Axis3D)arg1) -> Point3D :
    Get axis point in local coordinate system
    
    Return: Axis point in local coordinates
GetAxisRelPoint2(...)
GetAxisRelPoint2( (Axis3D)arg1) -> Point3D :
    Get second axis point. Used local coordinate system
    
    Return: Second axis point in local coordinates
GetRefPoint(...)
GetRefPoint( (Axis3D)arg1) -> Point3D :
    Get reference point.
    
    Return: Reference point
GetVector(...)
GetVector( (Axis3D)arg1) -> Vector3D :
    Get axis vector
    
    Return: Axis vector
Set(...)
Set( (Axis3D)arg1, (Axis3D)axis) -> None :
    Set axis
    
    Parameter: axis  Axis which will be copied
 
Set( (Axis3D)arg1, (Point3D)refPoint, (Point3D)axisPoint, (Vector3D)vector) -> None :
    Set axis
    
    Used local coordinate system for axisPoint
    
    Parameter: refPoint   Reference point
               axisPoint  Axis point
               vector     Axis vector
SetAxisPoint(...)
SetAxisPoint( (Axis3D)arg1, (Point3D)point) -> None :
    Set axis point, used world coordinate system.
    
    Parameter: point  Axis point in world coordinates
SetAxisRelPoint(...)
SetAxisRelPoint( (Axis3D)arg1, (Point3D)axisPoint) -> None :
    Set axis point, used local coordinate system.
    
    Parameter: axisPoint  Axis point in local coordinates
SetRefPoint(...)
SetRefPoint( (Axis3D)arg1, (Point3D)refPoint) -> None :
    Set reference point
    
    Parameter: refPoint  New reference point
SetVector(...)
SetVector( (Axis3D)arg1, (Vector3D)vector) -> None :
    Set axis vector
    
    Parameter: vector  New axis vector
__eq__(...)
__eq__( (Axis3D)arg1, (Axis3D)axis) -> object :
    Comparison of axis objects without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: axis  Compared axis.
    
    Return: True when axis objects are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Axis3D)axis) -> None :
    Copy constructor.
    
    Parameter: axis  Axis which will be copied
 
__init__( (object)arg1, (Point3D)axisPoint, (Vector3D)vector) -> None :
    Constructor.
    
    Reference point is initialized to [0.,0.,0.]
    Used world coordinate system for AxisPoint
    
    Parameter: axisPoint  Axis point
               vector     Axis vector
 
__init__( (object)arg1, (Point3D)refPoint, (Point3D)axisPoint, (Vector3D)vector) -> None :
    Constructor.
    
    Used local coordinate system for AxisPoint
    
    Parameter: refPoint   Reference point
               axisPoint  Axis point
               vector     Axis vector
 
__init__( (object)arg1, (Line3D)line) -> None :
    Constructor
    
    Parameter: line  3D line representing axis
__reduce__ = (...)
__repr__(...)
__repr__( (Axis3D)arg1) -> str

Data descriptors defined here:
AxisPoint
Get and set the axis point as property
AxisRefPoint
Get and set the axis ref point as property
AxisRelPoint
Get and set the axis point in local coordinate system as property
AxisVector
Get and set the vector as property

Data and other attributes defined here:
__instance_size__ = 88

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class AxisPlacement2D(Boost.Python.instance)
    2D axisPlacement
Placement is given by reference point and direction vector of local x-axis
 
 
Method resolution order:
AxisPlacement2D
Boost.Python.instance
builtins.object

Methods defined here:
GetDirection(...)
GetDirection( (AxisPlacement2D)arg1) -> Vector2D :
    Get direction
    
    Return: Vector2D const reference
GetRefPoint(...)
GetRefPoint( (AxisPlacement2D)arg1) -> Point2D :
    Get the reference point
    
    Return: Reference point
GetYDirection(...)
GetYDirection( (AxisPlacement2D)arg1) -> Vector2D :
    Get direction of local y-axis
    
    Return: Vector2D const reference
IsValid(...)
IsValid( (AxisPlacement2D)arg1) -> bool :
    Check if the placement is valid
    
    Return: True if it is a valid placement
SetDirection(...)
SetDirection( (AxisPlacement2D)arg1, (Vector2D)dir) -> None :
    Set direction
    
    Parameter: dir  Vector2D const reference
                    -----------------------------------------------------------------------------
SetRefPoint(...)
SetRefPoint( (AxisPlacement2D)arg1, (Point2D)refPoint) -> None :
    Set reference point
    
    Parameter: refPoint  New reference point
                         -----------------------------------------------------------------------------
__eq__(...)
__eq__( (AxisPlacement2D)arg1, (AxisPlacement2D)axisPlacement) -> object :
    Comparison of axis placements without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: axisPlacement Compared axis placement.
    
    Return: True when axis placements are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (AxisPlacement2D)placement) -> None :
    Copy constructor.
    
    Parameter: placement  Extruded area placement which will be copied
                          -----------------------------------------------------------------------------
 
__init__( (object)arg1, (Point2D)refPoint, (Vector2D)dirvector) -> None :
    Constructor which fully constructs the element.
    
    Parameter: refPoint   reference point
               dirvector  direction vector
                          -----------------------------------------------------------------------------
__reduce__ = (...)
__repr__(...)
__repr__( (AxisPlacement2D)arg1) -> str

Data descriptors defined here:
Direction
Get and set the direction vector as property
RefPoint
Get and set the ref point as property

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class AxisPlacement2DList(Boost.Python.instance)
    
Method resolution order:
AxisPlacement2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (AxisPlacement2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (AxisPlacement2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (AxisPlacement2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (AxisPlacement2DList)arg1) -> str
__setitem__(...)
__setitem__( (AxisPlacement2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (AxisPlacement2DList)arg1, (object)arg2) -> None
extend(...)
extend( (AxisPlacement2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class AxisPlacement3D(Boost.Python.instance)
    3D axisPlacement
Placement is given by Origin and 2 direction vectors - local x-axis
and local z-axis. y-axis is computed on demand
 
 
Method resolution order:
AxisPlacement3D
Boost.Python.instance
builtins.object

Methods defined here:
CalcGlobalPoint(...)
CalcGlobalPoint( (AxisPlacement3D)arg1, (Point3D)point) -> Point3D :
    Calculate global point from local coordinate system of placement 3D
    
    Parameter: point  local point 3D
    
    Return: Point3D instance
CalcLocalPoint(...)
CalcLocalPoint( (AxisPlacement3D)arg1, (Point3D)point) -> Point3D :
    Calculate local point in coordinate system of placement 3D
    
    Parameter: point  global point 3D
    
    Return: Point3D instance
GetOrigin(...)
GetOrigin( (AxisPlacement3D)arg1) -> Point3D :
    Get origin
    
    Return: Origin
GetRotationMatrix(...)
GetRotationMatrix( (AxisPlacement3D)arg1) -> Matrix3D :
    Get Rotation matrix given by placement 3D
    
    Return: Matrix3D const reference
GetTransformationMatrix(...)
GetTransformationMatrix( (AxisPlacement3D)arg1) -> Matrix3D :
    Get Transformation matrix given by placement 3D
    
    Return: Matrix3D const reference
GetXDirection(...)
GetXDirection( (AxisPlacement3D)arg1) -> Vector3D :
    Get x-direction
    
    Return: Vector3D const reference
GetYDirection(...)
GetYDirection( (AxisPlacement3D)arg1) -> Vector3D :
    Get direction of local y-axis
    
    Return: Vector3D const reference
GetZDirection(...)
GetZDirection( (AxisPlacement3D)arg1) -> Vector3D :
    Get z-direction
    
    Return: Vector3D const reference
IsValid(...)
IsValid( (AxisPlacement3D)arg1) -> bool :
    Check if the placement is valid
    
    Return: True if it is a valid placement
RotateAroundLocalZAxis(...)
RotateAroundLocalZAxis( (AxisPlacement3D)arg1, (Angle)angle) -> None :
    Rotate the placement around it's Z-axis
    
    Parameter: angle  rotation angle
Set(...)
Set( (AxisPlacement3D)arg1, (Point3D)origin, (Vector3D)xDir, (Vector3D)zDir) -> None :
    Set the placement
    
    Parameter: origin  New origin
               xDir    New X-direction
               zDir    New Z-direction
SetOrigin(...)
SetOrigin( (AxisPlacement3D)arg1, (Point3D)origin) -> None :
    Set origin
    
    Parameter: origin  New origin
SetXDirection(...)
SetXDirection( (AxisPlacement3D)arg1, (Vector3D)dir) -> None :
    Set x-direction
    
    Parameter: dir  Vector3D const reference
SetZDirection(...)
SetZDirection( (AxisPlacement3D)arg1, (Vector3D)dir) -> None :
    Set z-direction
    
    Parameter: dir  Vector3D const reference
__eq__(...)
__eq__( (AxisPlacement3D)arg1, (AxisPlacement3D)axisPlacement) -> object :
    Comparison of axis placements without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: axisPlacement Compared axis placement.
    
    Return: True when axis placements are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (AxisPlacement3D)placement) -> None :
    Copy constructor.
    
    Parameter: placement  Placement to be copied
    
 
__init__( (object)arg1, (Point3D)refPoint) -> None :
    Constructor with only reference point
    
    Parameter: refPoint  reference point
    
 
__init__( (object)arg1, (Point3D)refPoint, (Vector3D)xvector, (Vector3D)zvector) -> None :
    Constructor which fully constructs the element.
    
    Parameter: refPoint  reference point
               xvector   direction vector X
               zvector   direction vector Z
    
 
__init__( (object)arg1, (Matrix3D)matrix) -> None :
    Constructor from Matrix3D
    
    Parameter: matrix  matrix
__reduce__ = (...)
__repr__(...)
__repr__( (AxisPlacement3D)arg1) -> str

Data descriptors defined here:
Origin
Get and set the origin point property
XDirection
Get and set the x axis property
ZDirection
Get and set the z axis property

Data and other attributes defined here:
__instance_size__ = 88

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class AxisPlacement3DList(Boost.Python.instance)
    
Method resolution order:
AxisPlacement3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (AxisPlacement3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (AxisPlacement3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (AxisPlacement3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (AxisPlacement3DList)arg1) -> str
__setitem__(...)
__setitem__( (AxisPlacement3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (AxisPlacement3DList)arg1, (object)arg2) -> None
extend(...)
extend( (AxisPlacement3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BRep3D(Boost.Python.instance)
    3D brep
 
 
Method resolution order:
BRep3D
Boost.Python.instance
builtins.object

Methods defined here:
AreFacesNaturallyTrimmed(...)
AreFacesNaturallyTrimmed( (BRep3D)arg1) -> bool :
    Find if all faces are naturally trimmed by their surfaces
    
        hrow Allplan::Geometry::Exception in case of invalid object.
    
    Return:  bool (true = yes)
CreateCone(...)
CreateCone( (Cone3D)cone) -> BRep3D :
    Create BRep3D as cone
    
    Parameter: cone  cone data
    
    Return:  created geometry
CreateCuboid(...)
CreateCuboid( (AxisPlacement3D)placement, (float)length, (float)width, (float)height) -> BRep3D :
    Create BRep3D as cuboid
    
    Parameter: placement  cuboid origin
               length     length in its x axis
               width      width in its y axis
               height     height in its z axis
    
    Return:  created geometry
CreateCylinder(...)
CreateCylinder( (AxisPlacement3D)placement, (float)radius, (float)height) -> BRep3D :
    Create Brep as cylinder
    
    Parameter: placement  axis placement
               radius     cylinder radius
               height     cylinder height
    
    Return:  created cone
CreateSphere(...)
CreateSphere( (AxisPlacement3D)placement, (float)radius) -> BRep3D :
    Create BRep3D as sphere
    
    Parameter: placement  sphere origin
               radius     sphere radius
    
    Return:  created geometry
CreateWireBody(...)
CreateWireBody( (object)icurve) -> BRep3D :
    Create wire body from the curve as one edge
    
    Parameter: icurve  curve for edge geometry
    
    Return:  created BRep3D element
DeleteFace(...)
DeleteFace( (BRep3D)arg1, (int)faceIndex) -> object :
    Delete face from brep
    
    Parameter: faceIndex  index of face we want to delete
    
    Return:  error code
DeleteFaces(...)
DeleteFaces( (BRep3D)arg1, (VecULongList)faceIndices) -> object :
    Delete faces from brep
    
    Parameter: faceIndices  indices of faces to delete
    
    Return:  error code
GetEdgeCount(...)
GetEdgeCount( (BRep3D)arg1) -> int :
    Get the edges count
    
    Return: size_t count of edges
GetEdgeCurves(...)
GetEdgeCurves( (BRep3D)arg1) -> tuple :
    get all edge curves as BSpline3D
    
    Return:  error code,
            result edge curves handle vector
GetEdgeFaceIndices(...)
GetEdgeFaceIndices( (BRep3D)arg1, (int)edge) -> tuple :
    Get faces containing this edge (if any)
    
    Parameter: edge  desired edge index
    
    Return:  error code,
            face indices
GetEdgeGeometry(...)
GetEdgeGeometry( (BRep3D)arg1, (int)edge) -> object :
    Get (trimmed) edge geometry
    
    Parameter: edge  egde index
    
    Return:  handle to geometry curve
GetEdgeParametricCurves(...)
GetEdgeParametricCurves( (BRep3D)arg1) -> tuple :
    get parametric curves of all edges
    
    Return:  error code,
            result edge curves handle vector
GetEdgeVertexIndices(...)
GetEdgeVertexIndices( (BRep3D)arg1, (int)edge) -> tuple :
    Get vertex indices of the edge
    
    Parameter: edge  edge index
    
    Return:  error code,
            start vertex index,
            end vertex index
GetEdgeVertices(...)
GetEdgeVertices( (BRep3D)arg1, (int)edge) -> tuple :
    get edge vertices
    
    Parameter: edge  edge index
    
    Return:  error code,
            start vertex,
            end vertex
GetFaceBoundaryCurves(...)
GetFaceBoundaryCurves( (BRep3D)arg1, (int)face) -> tuple :
    Get face boundary curves, curves are trimmed
    
    Parameter: face  face index
    
    Return:  error code,
            result geometries
GetFaceCount(...)
GetFaceCount( (BRep3D)arg1) -> int :
    Get the faces count
    
    Return: size_t count of faces
GetFaceEdgeNaturalTrimming(...)
GetFaceEdgeNaturalTrimming( (BRep3D)arg1, (int)face, (OrientedEdge)oedge) -> tuple :
    get edge trimming on this face
    
    Parameter: face   face index
               oedge  oriented edge
    
    Return:  error code,
            result trimming
GetFaceEdgeOrientation(...)
GetFaceEdgeOrientation( (BRep3D)arg1, (int)face, (int)edge) -> tuple :
    Get orientation of the edge in the given face
    
    Parameter: face  face index
               edge  edge index
    
    Return:  error code,
            result orientation (same = true or opposite = false)
GetFaceEdges(...)
GetFaceEdges( (BRep3D)arg1, (int)faceIndex) -> tuple :
    Get face edges together with their orientations
    
    Parameter: faceIndex  face index
    
    Return:  error code,
            result edges
GetFaceFlags(...)
GetFaceFlags( (BRep3D)arg1, (int)face) -> int :
    Get flags of the face.
    
    Parameter: face  face index
    
    Return:  flags value
GetFaceGeometry(...)
GetFaceGeometry( (BRep3D)arg1, (int)face) -> object :
    Get surface geometry of the face
    
    
        hrow Allplan::Geometry::Exception in case of invalid input.
    
    Parameter: face  face index
    
    Return:  surface geometry handle
GetFaceGeometryOrientation(...)
GetFaceGeometryOrientation( (BRep3D)arg1, (int)face) -> bool :
    Get surface geometry orientation of the face
    
    Parameter: face  face index
    
    Return:  surface geometry orientation
GetFaceLoopsCount(...)
GetFaceLoopsCount( (BRep3D)arg1, (int)face) -> int :
    Get count of loops of face given by index
    
    Parameter: face  index of face
    
    Return:  count of loops
GetIsoCurves(...)
GetIsoCurves( (BRep3D)arg1, (int)ucount, (int)vcount, (bool)planarfaces) -> tuple :
    Get iso curves from all faces
    
    Parameter: ucount       number of u-curves
               vcount       number of v-curves
               planarfaces  include planar faces
    
    Return:  error code,
            result iso curves handle vector
GetParts(...)
GetParts( (BRep3D)arg1) -> tuple :
    Get separated parts (continuos shells)
    
    Return:  error code,
            separated bodies
GetPartsCount(...)
GetPartsCount( (BRep3D)arg1) -> int :
    Get number of parts in this body
    
    Return:  number of parts
GetRefPoint(...)
GetRefPoint( (BRep3D)arg1) -> Point3D :
    Get the reference point
    
    Return: Constant reference to reference point.
GetSilhouetteCurves(...)
GetSilhouetteCurves( (BRep3D)arg1, (Matrix3D)viewMatrix, (bool)bPerspective) -> tuple :
    Get silhouette curves of Brep
    
    Parameter: viewMatrix    View matrix
               bPerspective  Flag if it is central projection or not (true / false)
    
    Return:  error code,
            silhouette curves
GetSilhouetteVertices(...)
GetSilhouetteVertices( (BRep3D)arg1, (Matrix3D)viewMatrix, (bool)bPerspective) -> tuple :
    Get vertices (end points) of silhouette curves
    
    Parameter: viewMatrix    view matrix
               bPerspective  Flag if view is central perspective (true / false)
    
    Return:  error code,
            output vector of found points
GetVertex(...)
GetVertex( (BRep3D)arg1, (int)vertexIndex) -> tuple :
    Get vertex geometry
    
    Parameter: vertexIndex  vertex index
    
    Return:  error code,
            vertex point
GetVertexCount(...)
GetVertexCount( (BRep3D)arg1) -> int :
    Get the vertices count
    
    Return:  count of vertices
GetVertexEdges(...)
GetVertexEdges( (BRep3D)arg1, (int)vertex) -> tuple :
    Get the edges containing given vertex
    
    Parameter: vertex  Index of vertex
    
    Return: Error code,
            Indices of edges that contains vertex
GetVertices(...)
GetVertices( (BRep3D)arg1) -> tuple :
    Get all vertices from brep
    
    Return:  error code,
            vertices of brep
HasPlanarFaces(...)
HasPlanarFaces( (BRep3D)arg1) -> bool :
    Check if this brep contains planar faces
    
    Return:  bool true = yes
InvertAllFacesFlags(...)
InvertAllFacesFlags( (BRep3D)arg1) -> None :
    Invert flags for the all faces
IsClosed(...)
IsClosed( (BRep3D)arg1) -> bool :
    Check whether the B-rep is closed (closed shells)
    
    Return:  bool true = yes
IsCone(...)
IsCone( (BRep3D)arg1) -> tuple :
    Check if the b-rep is a cone
    
    Return:  bool true = yes,
            result axis placement (cone bottom center, axis orientation),
            cone bottom radius,
            cone top radius,
            cone height
IsFaceNaturallyTrimmed(...)
IsFaceNaturallyTrimmed( (BRep3D)arg1, (int)face) -> bool :
    Find if the face is naturally trimmed by its surface
    
    
        hrow Allplan::Geometry::Exception in case of invalid input.
    
    Parameter: face  face index
    
    Return:  bool (true = yes)
IsPolyhedron(...)
IsPolyhedron( (BRep3D)arg1) -> bool :
    Check if the b-rep is a polyhedron
    
    Return:  bool true = yes
IsSphere(...)
IsSphere( (BRep3D)arg1) -> tuple :
    Check if the b-rep is a sphere
    
    Return:  bool true = yes,
            result axis placement (sphere center, axis orientation),
            sphere radius
IsValid(...)
IsValid( (BRep3D)arg1) -> bool :
    check whether data is valid
    
    Return:  bool true = is valid
IsWire(...)
IsWire( (BRep3D)arg1) -> bool :
    Check if BRep is wire body. If has only edges.
    
    Return:  true if BRep is wire.
PickEdge(...)
PickEdge( (BRep3D)arg1, (Point3D)rayPoint, (Vector3D)rayVector, (float)searchRadius) -> tuple :
    Pick the edge under cursor
    
    Parameter: rayPoint      ray point
               rayVector     ray vector
               searchRadius  search radius
    
    Return:  true if any edge under cursor found,
            index of found edge,
            minimal distance between edge and ray,
            nearest point on ray from edge
PickFace(...)
PickFace( (BRep3D)arg1, (Point3D)rayPoint, (Vector3D)rayVector) -> tuple :
    Pick the face under cursor
    
    Parameter: rayPoint   ray point
               rayVector  ray vector
    
    Return:  true if any face under cursor found,
            index of found face,
            nearest point on ray from face (intersection point)
PickVertex(...)
PickVertex( (BRep3D)arg1, (Point3D)rayPoint, (Vector3D)rayVector, (float)searchRadius) -> tuple :
    Pick the vertex under cursor
    
    Parameter: rayPoint      ray point
               rayVector     ray vector
               searchRadius  search radius
    
    Return:  true if any vertex under cursor found,
            index of found vertex,
            minimal distance between vertex and ray,
            nearest point on ray from vertex
Reverse(...)
Reverse( (BRep3D)arg1) -> object :
    Reverse the orientation of BRep
    
    Return:  error code
SetAllFacesFlags(...)
SetAllFacesFlags( (BRep3D)arg1, (int)flags) -> None :
    Set flags to the all faces.
    
    Parameter: flags  flags value
SetFaceFlags(...)
SetFaceFlags( (BRep3D)arg1, (int)face, (int)flags) -> None :
    Set flags to the face.
    
    Parameter: face   face index
               flags  flags value
SetRefPoint(...)
SetRefPoint( (BRep3D)arg1, (Point3D)refPoint) -> None :
    Set the reference point
    
    Parameter: refPoint  New reference point.
__eq__(...)
__eq__( (BRep3D)arg1, (BRep3D)brep) -> object :
    Comparison of breps without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: brep Compared brep.
    
    Return: True when breps are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (BRep3D)brep) -> None :
    Copy constructor
    
    Parameter: brep  BRep3D which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (BRep3D)arg1) -> str

Data descriptors defined here:
RefPoint
Get and set the ref point property

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BRep3DList(Boost.Python.instance)
    
Method resolution order:
BRep3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (BRep3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (BRep3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (BRep3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (BRep3DList)arg1) -> str
__setitem__(...)
__setitem__( (BRep3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (BRep3DList)arg1, (object)arg2) -> None
extend(...)
extend( (BRep3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BSpline2D(PolyPoints2D)
    2D bspline
class for 2D (non uniform, rational) B-spline geometry
 
 
Method resolution order:
BSpline2D
PolyPoints2D
Boost.Python.instance
builtins.object

Methods defined here:
Clear(...)
Clear( (BSpline2D)arg1) -> None :
    Clear data, getting invalid state
CreateLine2D(...)
CreateLine2D( (Line2D)line) -> BSpline2D :
    Create BSpline2D from Line2D
    
    Parameter: line  Input line.
    
    Return:  Created BSpline2D.
Get(...)
Get( (BSpline2D)arg1) -> tuple :
    Get values of BSpline
    
    Return: List of points,
            List of weights,
            List of knots,
            Degree type,
GetDegree(...)
GetDegree( (BSpline2D)arg1) -> int :
    Gets spline degree
    
    Return:  spline degree
GetKnots(...)
GetKnots( (BSpline2D)arg1) -> VecDoubleList :
    Get knot vector
    
    Return:  knot vector const reference
GetWeights(...)
GetWeights( (BSpline2D)arg1) -> VecDoubleList :
    Get control points weights
    
    Return:  weights vector const reference
IsClosed(...)
IsClosed( (BSpline2D)arg1) -> bool :
    Check if spline is closed ( first/last points are equal )
    
    Return: closed spline true/false
IsRational(...)
IsRational( (BSpline2D)arg1) -> bool :
    Check if the spline is rational
    
    Return:  bool true = rational
IsValid(...)
IsValid( (BSpline2D)arg1) -> bool :
    Check spline validity
    
    Return:  bool valid = true
Reverse(...)
Reverse( (BSpline2D)arg1) -> None :
    Reverse of current spline
    
    Method reverse Spline using reverse from PolyPoints and swapping tangents.
Set(...)
Set( (BSpline2D)arg1, (Point2DList)arg2, (VecDoubleList)points, (VecDoubleList)weights, (int)knots, (bool)degree) -> None :
    Set values for BSpline
    
    Parameter: points      Vector of points
               weights     Vector of weights
               knots       Vector of knots
               degree      Degree type
               isPeriodic  True, if BSpline is periodic
SetDegree(...)
SetDegree( (BSpline2D)arg1, (int)degree) -> None :
    Set spline degree
    
    Parameter: degree  desired degree
SetKnots(...)
SetKnots( (BSpline2D)arg1, (VecDoubleList)knots) -> None :
    Set knot vector
    
    Parameter: knots  knot vector to set
SetPeriodic(...)
SetPeriodic( (BSpline2D)arg1, (bool)arg2) -> None :
    Set the periodic flag
    
    Parameter: flag   True if BSpline is periodic
SetWeights(...)
SetWeights( (BSpline2D)arg1, (VecDoubleList)weights) -> None :
    Set weights for control points
    
    Parameter: weights  weights vector to set
__eq__(...)
__eq__( (BSpline2D)arg1, (BSpline2D)bspline) -> object :
    Comparison of bsplines without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: bspline Compared bspline.
    
    Return: True when bsplines are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point2DList)points, (VecDoubleList)weights, (VecDoubleList)knots, (int)degree, (bool)isPeriodic) -> None :
    Constructor.
    
    Parameter: points      Vector of points
               weights     Vector of Weights
               knots       Vector of Knots
               degree      Degree type
               isPeriodic  True, if BSpline is periodic
 
__init__( (object)arg1, (BSpline2D)spline) -> None :
    Copy constructor.
    
    Parameter: spline  Spline which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (BSpline2D)arg1) -> str

Data descriptors defined here:
Degree
Get and set the degree property
IsPeriodic
Get the periodic property
Knots
Get and set the knots property
Weights
Get and set the weights property

Data and other attributes defined here:
__instance_size__ = 136

Methods inherited from PolyPoints2D:
Count(...)
Count( (PolyPoints2D)arg1) -> int :
    Get count of points.
    
    Return: bool.
Empty(...)
Empty( (PolyPoints2D)arg1) -> bool :
    Return true if no points, otherwise false.
    
    Return: bool.
EqualRef(...)
EqualRef( (PolyPoints2D)arg1, (PolyPoints2D)polyPoints) -> bool :
    Test if reference points are equal.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
    
    Return:  Reference points are equal: true/false
GetEndPoint(...)
GetEndPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the end point in world coordinate system.
    
    Return:  end point in world coordinate system
GetEndRelPoint(...)
GetEndRelPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the end point
    
    Return:  end point
GetLastPoint(...)
GetLastPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the last point in world coordinate system, copy of data.
    
    Return:  last point in world coordinate system
GetPoint(...)
GetPoint( (PolyPoints2D)arg1, (int)index) -> Point2D :
    Get point in world coordinate system, copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point point in world coordinate system.
GetPointIndex(...)
GetPointIndex( (PolyPoints2D)arg1, (Point2D)point) -> tuple :
    Get index of the given point
    
    Parameter: point  Searched point
    
    Return: True if a point was found,
            Found index
GetPointIndexes(...)
GetPointIndexes( (PolyPoints2D)arg1, (Point2D)point) -> tuple :
    Get indexes of the given point, in case that several points in the spline
    will have the same coordinates
    
    Parameter: point  Searched point
    
    Return: True if at least one point was found,
            Found indexes
GetRefPoint(...)
GetRefPoint( (PolyPoints2D)arg1) -> Point2D :
    Get reference point.
    
    Return: constant reference to the reference point in the world coordinate system.
GetRelPoint(...)
GetRelPoint( (PolyPoints2D)arg1, (int)index) -> Point2D :
    Get reference to point in Local coordinate system, no copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point constant reference to the point at position index.
GetStartPoint(...)
GetStartPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the start point in world coordinate system.
    
    Return:  start point in world coordinate system
GetStartRelPoint(...)
GetStartRelPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the start point
    
    Return:  start point
Insert(...)
Insert( (PolyPoints2D)arg1, (PolyPoints2D)polyPoints, (int)position) -> bool :
    Insert vector of points at specific position.
    
    If return false then points weren't inserted.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
               position    position where points will be inserted.
    
    Return: bool true if successful.
 
Insert( (PolyPoints2D)arg1, (Point2D)point, (int)position) -> bool :
    Insert point at specific position. Used world coordinates.
    
    If return false then points weren't Inserted.
    
    Parameter: point     constant reference to the Point.
               position  position where points will be inserted.
    
    Return: bool true if successful.
Remove(...)
Remove( (PolyPoints2D)arg1, (int)position) -> bool :
    Remove point from specific position.
    
    If return false then points weren't removed.
    
    Parameter: position  position of point which will be removed.
    
    Return: return false;
RemoveLastPoint(...)
RemoveLastPoint( (PolyPoints2D)arg1) -> bool :
    Remove the last point
    
    Return:  Point removed: true/false
Reserve(...)
Reserve( (PolyPoints2D)arg1, (int)newCount) -> None :
    Reserve container capacity
    
    Parameter: newCount  Expected size of container [count of points]
Resize(...)
Resize( (PolyPoints2D)arg1, (int)newSize) -> None :
    Specifies a new size for the points vector.
    
    Parameter: newSize  The new size of the points vector.
SetEndPoint(...)
SetEndPoint( (PolyPoints2D)arg1, (Point2D)endpoint) -> None :
    Set the end point in world coordinates
    
    Parameter: endpoint  new end point
SetPoint(...)
SetPoint( (PolyPoints2D)arg1, (Point2D)point, (int)index) -> None :
    Set point at given position in world coordinate system.
    
    Parameter: point  point in the world coordinate system.
               index  index of point which will be set
SetRefPoint(...)
SetRefPoint( (PolyPoints2D)arg1, (Point2D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Parameter: refPoint  reference point in the world coordinate system.
SetRelPoint(...)
SetRelPoint( (PolyPoints2D)arg1, (Point2D)point, (int)index) -> None :
    Set point at given position in relative coordinate system.
    
    Parameter: point  point in the relative coordinate system.
               index  index of point which will be set
SetStartPoint(...)
SetStartPoint( (PolyPoints2D)arg1, (Point2D)startpoint) -> None :
    Set the start point in world coordinates
    
    Parameter: startpoint  new start point
ToLineChain(...)
ToLineChain( (PolyPoints2D)arg1) -> Point2DList :
    Get polyline as a chain of lines composed from 2 points.
    
    Return: vector of lines composed from 2 points (start and end point of a line)
__getitem__(...)
__getitem__( (PolyPoints2D)arg1, (int)arg2) -> Point2D :
    Get point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
    
    Return: copy of point.
__iadd__(...)
__iadd__( (object)arg1, (Point2D)point) -> object :
    Add point in world coordinates.
    
    Parameter: point  adding point.
    
    Return:  New point
__setitem__(...)
__setitem__( (PolyPoints2D)arg1, (int)arg2, (Point2D)arg3) -> None :
    Set point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
               pnt    Point

Data descriptors inherited from PolyPoints2D:
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BSpline2DList(Boost.Python.instance)
    
Method resolution order:
BSpline2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (BSpline2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (BSpline2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (BSpline2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (BSpline2DList)arg1) -> str
__setitem__(...)
__setitem__( (BSpline2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (BSpline2DList)arg1, (object)arg2) -> None
extend(...)
extend( (BSpline2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BSpline3D(PolyPoints3D)
    3D bspline
class for 3D (non uniform, rational) B-spline geometry
 
 
Method resolution order:
BSpline3D
PolyPoints3D
Boost.Python.instance
builtins.object

Methods defined here:
Clear(...)
Clear( (BSpline3D)arg1) -> None :
    Clear data, getting invalid state
Create(...)
Create( (object)curve) -> BSpline3D :
    Create BSpline from curve
    
    Parameter: curve  Input curve
    
    Return:  Created BSpline3D.
CreateArc3D(...)
CreateArc3D( (Arc3D)arc) -> BSpline3D :
    Create BSpline form Arc3D
    
    Parameter: arc  Input arc
    
    Return:  Created Bspline3D
CreateBSpline(...)
CreateBSpline( (Point3DList)points, (int)degree, (bool)isPeriodic) -> BSpline3D :
    Create BSpline from control points
    
    Parameter: points      Control points
               degree      Degree of BSpline
               isPeriodic  true if BSpline should be smoothly closed
    
    Return: BSpline object
CreateBSplineInterpolated(...)
CreateBSplineInterpolated( (Point3DList)points, (int)degree, (bool)isPeriodic) -> BSpline3D :
    Create BSpline from interpolated points
    
    Parameter: points      Interpolated points
               degree      Degree of BSpline
               isPeriodic  true if BSpline should be smoothly closed
    
    Return: BSpline object
CreateBSplineJoined(...)
CreateBSplineJoined( (list)curves) -> BSpline3D :
    Create BSpline by joining curves. Curves should meet by end points.
    
    Parameter: curves  Source curves
    
    Return: BSpline object (empty, if joining failed)
CreateLine3D(...)
CreateLine3D( (Line3D)line) -> BSpline3D :
    Create BSpline3D from Line3D
    
    Parameter: line  Input line.
    
    Return:  Created BSpline3D.
CreatePolyline3D(...)
CreatePolyline3D( (Polyline3D)polyline3d) -> BSpline3D :
    Create a BSpline out of a Polyline3D object
    
    Parameter: polyline3d  Polyline3D that will be used for conversion
    
    Return:  An instance of the created BSpline3D
CreateSpline(...)
CreateSpline( (Spline3D)spline) -> BSpline3D :
    Create BSpline from Spline3D
    
    Parameter: spline  Spline
    
    Return:  Created BSpline3D.
EvaluatePoint(...)
EvaluatePoint( (BSpline3D)arg1, (float)param) -> tuple :
    Evaluate point of b-spline
    
    Parameter: param  parameter to evaluate point on b-spline
    
    Return:  error code of evaluation,
            resulting point, if succeeded
Get(...)
Get( (BSpline3D)arg1) -> tuple :
    Get values of BSpline
    
    Return: List of points,
            List of weights,
            List of knots,
            Degree type,
            True if BSpline is periodic
GetDegree(...)
GetDegree( (BSpline3D)arg1) -> int :
    Gets spline degree
    
    Return:  spline degree
GetInterpolatedPoints(...)
GetInterpolatedPoints( (BSpline3D)arg1) -> Point3DList :
    Function returns interpolated points of b-spline
    
    Return:  list of interpolated points
GetInterpolatedPointsParameters(...)
GetInterpolatedPointsParameters( (BSpline3D)arg1) -> VecDoubleList :
    Function returns list of parameters for interpolated points of b-spline
    
    Return:  list of parameters of interpolated points
GetInterval(...)
GetInterval( (BSpline3D)arg1) -> tuple :
    Function returns the interval of bspline
    
    Return:  true if success,
            start of curve interval,
            end of curve interval
GetKnotMultiplicities(...)
GetKnotMultiplicities( (BSpline3D)arg1) -> tuple :
    Get knot vector and knot multiplicities
    
    Return: knot vector with unique values,
            knot multiplicities
GetKnots(...)
GetKnots( (BSpline3D)arg1) -> VecDoubleList :
    Get knot vector
    
    Return:  knot vector const reference
GetWeights(...)
GetWeights( (BSpline3D)arg1) -> VecDoubleList :
    Get control points weights
    
    Return:  weights vector const reference
IsClosed(...)
IsClosed( (BSpline3D)arg1) -> bool :
    Check if spline is closed ( first/last points are equal )
    
    Return: closed spline true/false
IsEndClamped(...)
IsEndClamped( (BSpline3D)arg1) -> bool :
    Function returns whether the bspline is clamped at the end
    
    Return:  true if clamped on end
IsLine(...)
IsLine( (BSpline3D)arg1) -> bool :
    Check if bspline is line
    
    Return:  Returns true if it is line
IsPeriodicClosed(...)
IsPeriodicClosed( (BSpline3D)arg1) -> bool :
    Returns whether the spline is periodic or closed in 1st degree
    
    
    
    ote    BSpline with degree == 1 cannot be periodic, wherefore returns true if closed.
    
    Return:  bool true = periodic or closed
IsRational(...)
IsRational( (BSpline3D)arg1) -> bool :
    Check if the spline is rational
    
    Return:  bool true = rational
IsStartClamped(...)
IsStartClamped( (BSpline3D)arg1) -> bool :
    Function returns whether the bspline is clamped at the start
    
    Return:  true if clamped on start
IsValid(...)
IsValid( (BSpline3D)arg1) -> bool :
    Check spline validity
    
    Return:  bool valid = true
Reverse(...)
Reverse( (BSpline3D)arg1) -> None :
    Reverse of current spline
    
    Method reverse Spline using reverse from PolyPoints and swapping tangents.
Set(...)
Set( (BSpline3D)arg1, (Point3DList)points, (VecDoubleList)weights, (VecDoubleList)knots, (int)degree, (bool)isPeriodic) -> None :
    Set values for BSpline
    
    Parameter: points      Vector of points
               weights     Vector of weights
               knots       Vector of knots
               degree      Degree type
               isPeriodic  True if BSpline is periodic
SetDegree(...)
SetDegree( (BSpline3D)arg1, (int)degree) -> None :
    Set spline degree
    
    Parameter: degree  desired degree
SetKnots(...)
SetKnots( (BSpline3D)arg1, (VecDoubleList)knots) -> None :
    Set knot vector
    
    Parameter: knots  knot vector to set
SetPeriodic(...)
SetPeriodic( (BSpline3D)arg1, (bool)arg2) -> None :
    Set the periodic flag
    
    Parameter: flag   True if BSpline is periodic
SetWeights(...)
SetWeights( (BSpline3D)arg1, (VecDoubleList)weights) -> None :
    Set weights for control points
    
    Parameter: weights  weights vector to set
__eq__(...)
__eq__( (BSpline3D)arg1, (BSpline3D)bspline) -> object :
    Comparison of bsplines without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: bspline Compared bspline.
    
    Return: True when bsplines are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point3DList)points, (VecDoubleList)weights, (VecDoubleList)knots, (int)degree [, (bool)isPeriodic]) -> None :
    Constructor.
    
    Parameter: points      Vector of points
               weights     Vector of Weights
               knots       Vector of Knots
               degree      Degree type
               isPeriodic  True, if BSpline is periodic
 
__init__( (object)arg1, (BSpline3D)spline) -> None :
    Copy constructor.
    
    Parameter: spline  Spline which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (BSpline3D)arg1) -> str

Data descriptors defined here:
Degree
Get and set the degree property
IsPeriodic
Get the periodic property
Knots
Get and set the knots property
Weights
Get and set the weights property

Data and other attributes defined here:
__instance_size__ = 144

Methods inherited from PolyPoints3D:
Count(...)
Count( (PolyPoints3D)arg1) -> int :
    Get count of points.
    
    Return: bool.
Empty(...)
Empty( (PolyPoints3D)arg1) -> bool :
    Return true if no points, otherwise false.
    
    Return: bool.
EqualRef(...)
EqualRef( (PolyPoints3D)arg1, (PolyPoints3D)polyPoints) -> bool :
    Test if reference points are equal.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
    
    Return:  Reference points are equal: true/false
GetEndPoint(...)
GetEndPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the end point in world coordinate system.
    
    Return:  end point in world coordinate system
GetEndRelPoint(...)
GetEndRelPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the end point
    
    Return:  end point
GetLastPoint(...)
GetLastPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the last point in world coordinate system, copy of data.
    
    Return:  last point in world coordinate system
GetPoint(...)
GetPoint( (PolyPoints3D)arg1, (int)index) -> Point3D :
    Get point in world coordinate system, copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point point in world coordinate system.
GetPointIndex(...)
GetPointIndex( (PolyPoints3D)arg1, (Point3D)point) -> tuple :
    Get index of the given point
    
    Parameter: point  Searched point
    
    Return: True if a point was found,
            Found index
GetPointIndexes(...)
GetPointIndexes( (PolyPoints3D)arg1, (Point3D)point) -> tuple :
    Get indexes of the given point, in case that several points in the spline
    will have the same coordinates
    
    Parameter: point  Searched point
    
    Return: True if at least one point was found,
            Found indexes
GetRefPoint(...)
GetRefPoint( (PolyPoints3D)arg1) -> Point3D :
    Get reference point.
    
    Return: constant reference to the reference point in the world coordinate system.
GetRelPoint(...)
GetRelPoint( (PolyPoints3D)arg1, (int)index) -> Point3D :
    Get reference to point in Local coordinate system, no copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point constant reference to the point at position index.
GetStartPoint(...)
GetStartPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the start point in world coordinate system.
    
    Return:  start point in world coordinate system
GetStartRelPoint(...)
GetStartRelPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the start point
    
    Return:  start point
Insert(...)
Insert( (PolyPoints3D)arg1, (PolyPoints3D)polyPoints, (int)position) -> bool :
    Insert vector of points at specific position.
    
    If return false then points weren't inserted.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
               position    position where points will be inserted.
    
    Return: bool true if successful.
 
Insert( (PolyPoints3D)arg1, (Point3D)point, (int)position) -> bool :
    Insert point at specific position. Used world coordinates.
    
    If return false then points weren't Inserted.
    
    Parameter: point     constant reference to the Point.
               position  position where points will be inserted.
    
    Return: bool true if successful.
Remove(...)
Remove( (PolyPoints3D)arg1, (int)position) -> bool :
    Remove point from specific position.
    
    If return false then points weren't removed.
    
    Parameter: position  position of point which will be removed.
    
    Return: return false;
RemoveLastPoint(...)
RemoveLastPoint( (PolyPoints3D)arg1) -> bool :
    Remove the last point
    
    Return:  Point removed: true/false
Reserve(...)
Reserve( (PolyPoints3D)arg1, (int)newCount) -> None :
    Reserve container capacity
    
    Parameter: newCount  Expected size of container [count of points]
Resize(...)
Resize( (PolyPoints3D)arg1, (int)newSize) -> None :
    Specifies a new size for the points vector.
    
    Parameter: newSize  The new size of the points vector.
SetEndPoint(...)
SetEndPoint( (PolyPoints3D)arg1, (Point3D)endpoint) -> None :
    Set the end point in world coordinates
    
    Parameter: endpoint  new end point
SetPoint(...)
SetPoint( (PolyPoints3D)arg1, (Point3D)point, (int)index) -> None :
    Set point at given position in world coordinate system.
    
    Parameter: point  point in the world coordinate system.
               index  index of point which will be set
SetRefPoint(...)
SetRefPoint( (PolyPoints3D)arg1, (Point3D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Parameter: refPoint  reference point in the world coordinate system.
SetRelPoint(...)
SetRelPoint( (PolyPoints3D)arg1, (Point3D)point, (int)index) -> None :
    Set point at given position in relative coordinate system.
    
    Parameter: point  point in the relative coordinate system.
               index  index of point which will be set
SetStartPoint(...)
SetStartPoint( (PolyPoints3D)arg1, (Point3D)startpoint) -> None :
    Set the start point in world coordinates
    
    Parameter: startpoint  new start point
ToLineChain(...)
ToLineChain( (PolyPoints3D)arg1) -> Point3DList :
    Get polyline as a chain of lines composed from 2 points.
    
    Return: vector of lines composed from 2 points (start and end point of a line)
__getitem__(...)
__getitem__( (PolyPoints3D)arg1, (int)arg2) -> Point3D :
    Get point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
    
    Return: copy of point.
__iadd__(...)
__iadd__( (object)arg1, (Point3D)point) -> object :
    Add point in world coordinates.
    
    Parameter: point  adding point.
    
    Return:  New point
__setitem__(...)
__setitem__( (PolyPoints3D)arg1, (int)arg2, (Point3D)arg3) -> None :
    Set point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
               pnt    Point

Data descriptors inherited from PolyPoints3D:
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BSpline3DList(Boost.Python.instance)
    
Method resolution order:
BSpline3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (BSpline3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (BSpline3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (BSpline3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (BSpline3DList)arg1) -> str
__setitem__(...)
__setitem__( (BSpline3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (BSpline3DList)arg1, (object)arg2) -> None
extend(...)
extend( (BSpline3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BSplineSurface3D(Boost.Python.instance)
    3D bsplinesrfc
class for 3D (non uniform, rational) B-spline surface geometry
 
 
Method resolution order:
BSplineSurface3D
Boost.Python.instance
builtins.object

Methods defined here:
Clear(...)
Clear( (BSplineSurface3D)arg1) -> None :
    Clear data, getting invalid state
Get(...)
Get( (BSplineSurface3D)arg1) -> tuple :
    Get all surface members
    
    Return: all control points,
            all control points weights,
            knots in u direction,
            knots in v direction,
            degree in u direction,
            degree in v direction,
            periodic in u direction,
            periodic in v direction,
            closed in u direction,
            closed in v direction
GetCenterPoint(...)
GetCenterPoint( (BSplineSurface3D)arg1) -> Point3D :
    Get center point
    
    Return:  center point
GetNormalVector(...)
GetNormalVector( (BSplineSurface3D)arg1, (Point2D)uv) -> tuple :
    Evaluate normal vector for given parameters
    
    Parameter: uv  uv paramaters
    
    Return:  error code,
            result vector
GetPoints(...)
GetPoints( (BSplineSurface3D)arg1) -> Point3DList :
    Get control points
    
    Return: all control points
GetUDegree(...)
GetUDegree( (BSplineSurface3D)arg1) -> int :
    Get surface u-degree
    
    Return:  surface degree
GetUKnots(...)
GetUKnots( (BSplineSurface3D)arg1) -> VecDoubleList :
    Get u-knot vector
    
    Return:  knot vector const reference
GetUPointsCount(...)
GetUPointsCount( (BSplineSurface3D)arg1) -> int :
    Get control points count in u-direction
    
    Return:  size_t control points count
GetVDegree(...)
GetVDegree( (BSplineSurface3D)arg1) -> int :
    Get surface v-degree
    
    Return:  surface degree
GetVKnots(...)
GetVKnots( (BSplineSurface3D)arg1) -> VecDoubleList :
    Get v-knot vector
    
    Return:  knot vector const reference
GetVPointsCount(...)
GetVPointsCount( (BSplineSurface3D)arg1) -> int :
    Get control points count in v-direction
    
    Return:  size_t control points count
GetWeights(...)
GetWeights( (BSplineSurface3D)arg1) -> VecDoubleList :
    Get control points weights
    
    Return:  weights vector const reference
IsPlanar(...)
IsPlanar( (BSplineSurface3D)arg1) -> bool :
    Check if surface is planar
    
    Return:  bool true = yes
IsRational(...)
IsRational( (BSplineSurface3D)arg1) -> bool :
    Check if the surface is rational
    
    Return:  bool true = rational
IsValid(...)
IsValid( (BSplineSurface3D)arg1) -> bool :
    Check surface validity
    
    Return:  bool valid = true
Set(...)
Set( (BSplineSurface3D)arg1, (Point3DList)points, (VecDoubleList)weights, (VecDoubleList)uknots, (VecDoubleList)vknots, (int)udegree, (int)vdegree, (bool)isUPeriodic, (bool)isVPeriodic, (bool)isUClosed, (bool)isVClosed) -> None :
    Set all surface members
    
    Parameter: points       all control points
               weights      all control points weights
               uknots       knots in u direction
               vknots       knots in v direction
               udegree      degree in u direction
               vdegree      degree in v direction
               isUPeriodic  periodic in u direction
               isVPeriodic  periodic in v direction
               isUClosed    closed in u direction
               isVClosed    closed in v direction
SetUDegree(...)
SetUDegree( (BSplineSurface3D)arg1, (int)degree) -> None :
    Set surface v-degree
    
    Parameter: degree  desired degree
SetUKnots(...)
SetUKnots( (BSplineSurface3D)arg1, (VecDoubleList)knots) -> None :
    Set u-knot vector
    
    Parameter: knots  knot vector to set
SetVDegree(...)
SetVDegree( (BSplineSurface3D)arg1, (int)degree) -> None :
    Set surface v-degree
    
    Parameter: degree  desired degree
SetVKnots(...)
SetVKnots( (BSplineSurface3D)arg1, (VecDoubleList)knots) -> None :
    Set v-knot vector
    
    Parameter: knots  knot vector to set
SetWeights(...)
SetWeights( (BSplineSurface3D)arg1, (VecDoubleList)weights) -> None :
    Set weights for control points
    
    Parameter: weights  weights vector to set
__eq__(...)
__eq__( (BSplineSurface3D)arg1, (BSplineSurface3D)bsplinesrfc) -> object :
    Comparison of bsplinesrfcs without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: bsplinesrfc Compared bsplinesrfc.
    
    Return: True when bsplinesrfcs are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point3DList)points, (VecDoubleList)weights, (VecDoubleList)uknots, (VecDoubleList)vknots, (int)udegree, (int)vdegree, (bool)isUPeriodic, (bool)isVPeriodic, (bool)isUClosed, (bool)isVClosed) -> None :
    Constructor.
    
    Parameter: points       all control points
               weights      all control points weights
               uknots       knots in u direction
               vknots       knots in v direction
               udegree      degree in u direction
               vdegree      degree in v direction
               isUPeriodic  periodic in u direction
               isVPeriodic  periodic in v direction
               isUClosed    closed in u direction
               isVClosed    closed in v direction
 
__init__( (object)arg1, (BSplineSurface3D)surface) -> None :
    Copy constructor.
    
    Parameter: surface  Surface which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (BSplineSurface3D)arg1) -> str

Data descriptors defined here:
Points
Get the points property
UDegree
Get and set the degree property
UKnots
Get and set the uknots property
VDegree
Get and set the degree property
VKnots
Get and set the vknots property
Weights
Get and set the weights property

Data and other attributes defined here:
__instance_size__ = 176

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BSplineSurface3DList(Boost.Python.instance)
    
Method resolution order:
BSplineSurface3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (BSplineSurface3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (BSplineSurface3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (BSplineSurface3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (BSplineSurface3DList)arg1) -> str
__setitem__(...)
__setitem__( (BSplineSurface3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (BSplineSurface3DList)arg1, (object)arg2) -> None
extend(...)
extend( (BSplineSurface3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BoundingBox2D(Boost.Python.instance)
    2D boundingBox
Representation class for 2D bounding box.
 
 
Method resolution order:
BoundingBox2D
Boost.Python.instance
builtins.object

Methods defined here:
Deflate(...)
Deflate( (BoundingBox2D)arg1, (float)x, (float)y) -> None :
    Deflate in  x and  y axis
    
    Parameter: x  deflate in X axis
               y  deflate in Y axis
 
Deflate( (BoundingBox2D)arg1, (float)size) -> None :
    Deflate in x,y axis concurrently.
    
    Parameter: size  deflate in x and y axis concurrently.
Get(...)
Get( (BoundingBox2D)arg1) -> tuple :
    Get minimum point, maximum point and angle
    
    Return: minimum point in local coordinate system,
            maximum point in local coordinate system,
            direction of X axis of new coordinate system
GetAngle(...)
GetAngle( (BoundingBox2D)arg1) -> Angle :
    Get direction of X axis of new coordinate system
    
    Return: angle direction of X axis of new coordinate system
GetBoxPoint(...)
GetBoxPoint( (BoundingBox2D)arg1, (eBoxPoint)arg2) -> Point2D :
    Get world point of a dedicated location of the box
    
    Return: Point2D
GetCenter(...)
GetCenter( (BoundingBox2D)arg1) -> Point2D :
    Get box center point in local coordinate system
    
    Return: center point in local coordinates system
GetCenterPoint(...)
GetCenterPoint( (BoundingBox2D)arg1) -> Point2D :
    Get world point at center of box
    
    Return: Point2D
GetHeight(...)
GetHeight( (BoundingBox2D)arg1) -> float :
    Get height of box in local system
    
    Return: double
GetMax(...)
GetMax( (BoundingBox2D)arg1) -> Point2D :
    Get maximum point in local coordinate system
    
    Return: maximum point in local coordinate system
GetMaxPoint(...)
GetMaxPoint( (BoundingBox2D)arg1) -> Point2D :
    Get world point at maximum of box
    
    Return: Point2D
GetMin(...)
GetMin( (BoundingBox2D)arg1) -> Point2D :
    Get minimum point in local coordinate system
    
    Return: minimum point
GetMinPoint(...)
GetMinPoint( (BoundingBox2D)arg1) -> Point2D :
    Get world point at maximum of box
    
    Return: Point2D
GetWidth(...)
GetWidth( (BoundingBox2D)arg1) -> float :
    Get width of box in local system
    
    Return: double
Inflate(...)
Inflate( (BoundingBox2D)arg1, (float)x, (float)y) -> None :
    Inflate in  x and  y axis
    
    Parameter: x  inflate in X axis
               y  inflate in Y axis
 
Inflate( (BoundingBox2D)arg1, (float)size) -> None :
    Inflate in x,y axis concurrently.
    
    Parameter: size  inflate in x and y axis concurrently.
IsContaining(...)
IsContaining( (BoundingBox2D)arg1, (Point2D)point) -> bool :
    Is point inside this box
    
    Parameter: point  point in world coordinate system
    
    Return: true, if is inside, otherwise false
 
IsContaining( (BoundingBox2D)arg1, (BoundingBox2D)box) -> bool :
    Is box inside this box
    
    Parameter: box  bounding box
    
    Return: true, if is inside, otherwise false
 
IsContaining( (BoundingBox2D)arg1, (MinMax2D)minmax) -> bool :
    Is minmax box inside this box
    
    Parameter: minmax  minmax box
    
    Return: true, if is inside, otherwise false
IsValid(...)
IsValid( (BoundingBox2D)arg1) -> bool :
    Test if box is valid
    
    Return: true, if box valid, otherwise false
Overlaps(...)
Overlaps( (BoundingBox2D)arg1, (BoundingBox2D)box) -> bool :
    Does box overlap this box
    
    Parameter: box  bounding box
    
    Return: true, if boxes overlap, otherwise false
 
Overlaps( (BoundingBox2D)arg1, (MinMax2D)minmax) -> bool :
    Does minmax box overlap this box
    
    Parameter: minmax  MinMax2D box
    
    Return: true, if boxes overlap, otherwise false
Reset(...)
Reset( (BoundingBox2D)arg1, (Angle)angle) -> None :
    Reset bounding box and set initial angle
    
    When bounding box is reseted, then 
     min point is initialized to [DBL_MAX,DBL_MAX], 
     max point to [-DBL_MAX,-DBL_MAX], 
    
    This method is using when previous initialized bounding box start accept a new point values.
    
    Parameter: angle  Initial angle
Set(...)
Set( (BoundingBox2D)arg1, (Point2D)min, (Point2D)max, (Angle)angle) -> None :
    Set minimum point, maximum point and angle
    
    Parameter: min    minimum point in local coordinate system
               max    maximum point in local coordinate system
               angle  angle between world X and local X coordinate system
SetAngle(...)
SetAngle( (BoundingBox2D)arg1, (Angle)angle) -> None :
    Set direction of X axis of new coordinate system
    
    Parameter: angle  direction of X axis of new coordinate system
SetHeight(...)
SetHeight( (BoundingBox2D)arg1, (float)height) -> None :
    Set height of box in local system. Computed from Min point
    
    Parameter: height  Height
SetMax(...)
SetMax( (BoundingBox2D)arg1, (Point2D)max) -> None :
    Set maximum point in local coordinate system
    
    Parameter: max  maximum point
SetMin(...)
SetMin( (BoundingBox2D)arg1, (Point2D)min) -> None :
    Set minimum point
    
    Parameter: min  minimum point in local coordinate system
SetWidth(...)
SetWidth( (BoundingBox2D)arg1, (float)width) -> None :
    Set width of box in local system. Computed from Min point
    
    Parameter: width  Width
                      -----------------------------------------------------------------------------
__add__(...)
__add__( (BoundingBox2D)arg1, (BoundingBox2D)boundingBox) -> object :
    Expand BoundingBox2D box.
    
    Expands the BoundingBox2D box by the box given in parameter minmax
    
    Parameter: boundingBox  BoundingBox2D to be added
    
    Return: BoundingBox2D box.
 
__add__( (BoundingBox2D)arg1, (MinMax2D)minMax) -> object :
    Expand BoundingBox2D box by given MinMax2D.
    
    Expands the BoundingBox2D box by the minmax box given in parameter minmax
    
    Parameter: minMax  MinMax2D to be added
    
    Return: BoundingBox2D box.
__eq__(...)
__eq__( (BoundingBox2D)arg1, (BoundingBox2D)boundingBox) -> object :
    Comparison of boundingBoxs without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: boundingBox Compared boundingBox.
    
    Return: True when boundingBoxs are equal, otherwise false.
__getitem__(...)
__getitem__( (BoundingBox2D)arg1, (int)index) -> Point2D :
    Get the corners of bounding box.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  corner index (0-left bottom, 1-right bottom, 2-right top, 3-left top)
    
    Return: corner as Point2D in world coordinate system.
__iadd__(...)
__iadd__( (object)arg1, (BoundingBox2D)boundingBox) -> object :
    Expand BoundingBox2D box.
    
    Expands the BoundingBox2D box by the box given in parameter minmax
    
    Parameter: boundingBox  BoundingBox2D to be added
    
    Return: reference to BoundingBox2D box.
 
__iadd__( (object)arg1, (MinMax2D)minmax) -> object :
    Expand BoundingBox2D box by given MinMax2D.
    
    Expands the BoundingBox2D box by the minmax box given in parameter minmax
    
    Parameter: minmax  MinMax2D to be added
    
    Return: reference to BoundingBox2D.
 
__iadd__( (object)arg1, (Point2D)point) -> object :
    Expand BoundingBox2D box.
    
    Expands the BoundingBox2D box by the Point2D given in parameter point
    
    Parameter: point  Point2D to be added in world coordinate system
    
    Return: reference to bounding box.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Angle)angle) -> None :
    Default constructor.
    
    min point is initialized to [DBL_MAX,DBL_MAX],
    max point to [-DBL_MAX,-DBL_MAX],
    
    Parameter: angle  Angle of new initialized bounding box.
 
__init__( (object)arg1, (Point2D)min, (Point2D)max, (Angle)angle) -> None :
    Set constructor
    
    Initialize bounding box with given MIN, MAX points and slew of local coordinate system.
    
    Parameter: min    minimum point in local coordinate system
               max    maximum point in local coordinate system
               angle  direction of X axis of local coordinate system
 
__init__( (object)arg1, (BoundingBox2D)boundingBox2D) -> None :
    Copy constructor.
    
    Parameter: boundingBox2D  BoundingBox2D to be copied
 
__init__( (object)arg1, (MinMax2D)minMax2D) -> None :
    Copy constructor.
    
    Parameter: minMax2D  MinMax2D to be copied
__reduce__ = (...)
__repr__(...)
__repr__( (BoundingBox2D)arg1) -> str

Data descriptors defined here:
Angle
Get and set the angle property
Max
Get and set the max point property
Min
Get and set the min point property

Data and other attributes defined here:
__instance_size__ = 56

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class BoundingBox2DList(Boost.Python.instance)
    
Method resolution order:
BoundingBox2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (BoundingBox2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (BoundingBox2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (BoundingBox2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (BoundingBox2DList)arg1) -> str
__setitem__(...)
__setitem__( (BoundingBox2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (BoundingBox2DList)arg1, (object)arg2) -> None
extend(...)
extend( (BoundingBox2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ChamferCalculus(Boost.Python.instance)
    Class for chamfer calculation between two objects
 
 
Method resolution order:
ChamferCalculus
Boost.Python.instance
builtins.object

Methods defined here:
Calculate(...)
Calculate( (Polyhedron3D)polyhedron, (float)chamferWidth) -> tuple :
    Calculate chamfer on all edges of given Polyhedron3D
    
    Parameter: polyhedron    polyhedron to chamfer
               chamferWidth  chamfer width
    
    Return: error code,
            Resulting polyhedron
 
Calculate( (Polyhedron3D)polyhedron, (VecSizeTList)edges, (float)chamferWidth, (bool)propagation) -> tuple :
    Calculate chamfer on selected edges of given Polyhedron3D
    
    Parameter: polyhedron    polyhedron to chamfer
               edges         edges to chamfer
               chamferWidth  chamfer width
               propagation   flag for propagation of neighboring edges
    
    Return: error code,
            Resulting polyhedron
 
Calculate( (BRep3D)brep, (float)chamferWidth) -> tuple :
    Calculate chamfer on all edges of given BRep3D
    
    Parameter: brep          BRep to chamfer
               chamferWidth  chamfer width
    
    Return: error code,
            Resulting BRep
 
Calculate( (BRep3D)brep, (VecSizeTList)edges, (float)chamferWidth, (bool)propagation) -> tuple :
    Calculate chamfer on selected edges of given BRep3D
    
    Parameter: brep          BRep to chamfer
               edges         edges to chamfer
               chamferWidth  chamfer width
               propagation   flag for propagation of neighboring edges
    
    Return: error code,
            Resulting BRep
CalculateApplicableChamfers(...)
CalculateApplicableChamfers( (Line2D)line1, (Line2D)line2, (Point2D)intersectionPoint, (float)chamferWidth) -> Line2DList :
    Calculates four applicable chamfer lines
    
    Parameter: line1              Geometry of first chamfered line
               line2              Geometry of second chamfered line
               intersectionPoint  Intersection point of 2 chamfered lines
               chamferWidth       Chamfer width
    
    Return: Calculated 4 applicable chamfer lines
 
CalculateApplicableChamfers( (object)igeo1, (object)igeo2, (Plane3D)plane3D, (Point3D)intersectionPoint, (float)chamferWidth) -> Line3DList :
    Calculates four applicable chamfer lines
    
    Parameter: igeo1              Geometry of first object
               igeo2              Geometry of second object
               plane3D            3D plane in which objects lie
               intersectionPoint  Intersection point of 2 chamfered objects
               chamferWidth       Chamfer width
    
    Return: Calculated 4 applicable chamfer lines
 
CalculateApplicableChamfers( (Line3D)line1, (Line3D)line2, (Plane3D)plane3D, (Point3D)intersectionPoint, (float)chamferWidth) -> Line3DList :
    Calculates applicable chamfer lines between two 3D lines
    
    Parameter: line1              Geometry of the first line
               line2              Geometry of the second line
               plane3D            3D plane in which line lies
               intersectionPoint  Intersection point of 2 chamfered lines
               chamferWidth       Chamfer width
    
    Return: Calculated 4 applicable chamfer lines
 
CalculateApplicableChamfers( (Line3D)line, (Arc3D)arc, (Arc3D)chamferArc, (bool)bFirstElementIsLine) -> Line3DList :
    Calculates applicable chamfer lines between 3D line and 3D arc
    
    Parameter: line                 Geometry of 3D line
               arc                  Geometry of 3D arc
               chamferArc           Geometry of chamfer arc
               bFirstElementIsLine  Flag for order of element's intersection calculation
    
    Return: Calculated 4 applicable chamfer lines
 
CalculateApplicableChamfers( (Arc3D)arc1, (Arc3D)arc2, (Arc3D)chamferArc) -> Line3DList :
    Calculates applicable chamfer lines between two 3D arcs
    
    Parameter: arc1        Geometry of the first arc
               arc2        Geometry of the second arc
               chamferArc  Geometry of chamfer arc
    
    Return: Calculated 4 applicable chamfer lines
CalculateChamferInsideOnePolyline(...)
CalculateChamferInsideOnePolyline( (Line3D)originalChamferLine, (Polyline3D)originalPolyLine, (int)polySegment1, (int)polySegment2) -> Polyline3D :
    Calculate chamfer inside one polyline - 2 different segments of a polyline are to be chamfered
    
    Parameter: originalChamferLine  Geometry of chamfer line
               originalPolyLine     Geometry of chamfered polyline
               polySegment1         First segment index of polyline
               polySegment2         Second segment index of polyline
    
    Return:    Calculated chamfered polyline
CalculateChamferLine(...)
CalculateChamferLine( (Line2D)line1, (Line2D)line2, (Point2D)inputPoint) -> Line2D :
    Calculates chamfer line
    
    Parameter: line1       Geometry of first chamfered line
               line2       Geometry of second chamfered line
               inputPoint  Point of click (through which the chamfer should run)
    
    Return: Calculated chamfer line
 
CalculateChamferLine( (object)igeo1, (object)igeo2, (Plane3D)plane3D, (Point3D)intersectionPoint, (Point3D)inputPoint) -> Line3D :
    Calculates chamfer line
    
    Parameter: igeo1              Geometry of first object
               igeo2              Geometry of second object
               plane3D            3D plane of the objects
               intersectionPoint  Intersection point of objects for chamfering
               inputPoint         Point of click (through which the chamfer should run)
    
    Return:    Calculated chamfer line
 
CalculateChamferLine( (Line3D)line1, (Line3D)line2, (Plane3D)plane3D, (Point3D)intersectionPoint, (Point3D)inputPoint) -> Line3D :
    Calculates chamfer line between two 3D lines
    
    Parameter: line1              Geometry of first 3D line
               line2              Geometry of second 3D line
               plane3D            3D plane of the objects
               intersectionPoint  Intersection point of objects for chamfering
               inputPoint         Point of click (through which the chamfer should run)
    
    Return:    Calculated chamfer line
 
CalculateChamferLine( (Line3D)line, (Arc3D)arc, (Plane3D)plane3D, (Point3D)intersectionPoint, (Point3D)inputPoint, (bool)bFirstElementIsLine) -> Line3D :
    Calculates chamfer line between 3D line and 3D arc
    
    Parameter: line                 Geometry of 3D line
               arc                  Geometry of 3D arc
               plane3D              3D plane of the objects
               intersectionPoint    Intersection point of objects for chamfering
               inputPoint           Point of click (through which the chamfer should run)
               bFirstElementIsLine  Flag for order of element's intersection calculation
    
    Return:    Calculated chamfer line
 
CalculateChamferLine( (Arc3D)arc1, (Arc3D)arc2, (Plane3D)plane3D, (Point3D)intersectionPoint, (Point3D)inputPoint) -> Line3D :
    Calculates chamfer line between two 3D arcs
    
    Parameter: arc1               Geometry of the first 3D arc
               arc2               Geometry of the second 3D arc
               plane3D            3D plane of the objects
               intersectionPoint  Intersection point of objects for chamfering
               inputPoint         Point of click (through which the chamfer should run)
    
    Return:    Calculated chamfer line
CalculateChamferedLine(...)
CalculateChamferedLine( (Line2D)originalLine, (Point2D)intersectionPoint, (Point2D)chamferPoint) -> Line2D :
    Calculates chamfered line
    
    Parameter: originalLine       Line which is being chamfered
               intersectionPoint  Intersection point of 2 chamfered lines
               chamferPoint       Intersection point of chamfer line and (original) chamfered line
    
    Return: Calculated chamfered line
 
CalculateChamferedLine( (Line3D)originalLine, (Plane3D)plane3D, (Point3D)intersectionPoint, (Point3D)chamferPoint) -> Line3D :
    Calculates chamfered line
    
    Parameter: originalLine       Line which is being chamfered
               plane3D            3D plane in which line lies
               intersectionPoint  Intersection point of 2 chamfered lines
               chamferPoint       Intersection point of chamfer line and (original) chamfered line
    
    Return:    Calculated chamfered line
CalculateHalvingAngle(...)
CalculateHalvingAngle( (Line2D)line1, (Line2D)line2, (Point2D)intersectionPoint) -> Angle :
    Calculates halving angle of 2 given lines in the global coordinate system
    
    Parameter: line1              Geometry of first line
               line2              Geometry of second line
               intersectionPoint  Intersection point of the 2 lines
    
    Return: Halving angle
SwapLinePoints(...)
SwapLinePoints( (Line2D)line, (Point2D)point) -> tuple :
    Changes line orientation if given point lies on line's left side.
    
    Parameter: line   line to be changed
               point  point to be evaluated
    
    Return: True if line orientation was changed, false if orientation was left intact,
            Resulting line
 
SwapLinePoints( (Line3D)line, (Point3D)point) -> tuple :
    Changes line orientation if given point lies on line's left side
    
    Parameter: line   line to be changed
               point  point to be evaluated
    
    Return: True if line orientation was changed, false if orientation was left intact,
            Resulting line
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClippedSweptSolid3D(Boost.Python.instance)
    Representation class for solid created by extrusion of area with borders
of a plane at the bottom and a plane at the top in world z - axis direction
 
 
Method resolution order:
ClippedSweptSolid3D
Boost.Python.instance
builtins.object

Methods defined here:
GetBottomPlane(...)
GetBottomPlane( (ClippedSweptSolid3D)arg1) -> Plane3D :
    Get bottom clipping plane
    
    Return: Plane3D const reference
GetRefPoint(...)
GetRefPoint( (ClippedSweptSolid3D)arg1) -> Point3D :
    Get the reference point
    
    Return: Reference point
GetSweptArea(...)
GetSweptArea( (ClippedSweptSolid3D)arg1) -> PolygonalArea2D :
    Get Swept area
    
    Return: PolygonalArea2D const reference
GetTopPlane(...)
GetTopPlane( (ClippedSweptSolid3D)arg1) -> Plane3D :
    Get top clipping plane
    
    Return: Plane3D const reference
IsValid(...)
IsValid( (ClippedSweptSolid3D)arg1) -> bool :
    Check if the Solid is valid
    
    Return: True if it is a valid solid
SetBottomPlane(...)
SetBottomPlane( (ClippedSweptSolid3D)arg1, (Plane3D)plane) -> None :
    Set bottom clipping plane
    
    Parameter: plane  Plane3D const reference
SetRefPoint(...)
SetRefPoint( (ClippedSweptSolid3D)arg1, (Point3D)refPoint) -> None :
    Set reference point
    
    Parameter: refPoint  New reference point
SetSweptArea(...)
SetSweptArea( (ClippedSweptSolid3D)arg1, (PolygonalArea2D)area) -> None :
    Set Swept area
    
    Parameter: area  PolygonalArea2D const reference
SetTopPlane(...)
SetTopPlane( (ClippedSweptSolid3D)arg1, (Plane3D)plane) -> None :
    Set top clipping plane
    
    Parameter: plane  Plane3D const reference
__eq__(...)
__eq__( (ClippedSweptSolid3D)arg1, (ClippedSweptSolid3D)clippedSweptSolid) -> object :
    Comparison of clippedSweptSolids without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: clippedSweptSolid Compared clippedSweptSolid.
    
    Return: True when clippedSweptSolids are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (PolygonalArea2D)area, (Plane3D)bottom, (Plane3D)top) -> None :
    Constructor which sets swept area, bottom and top planes.
    
    Parameter: area    PolygonalArea3D
               bottom  Bottom Plane3D
               top     Top Plane3D
 
__init__( (object)arg1, (ClippedSweptSolid3D)solid) -> None :
    Copy constructor.
    
    Parameter: solid  Clipped swept area solid which will be copied
 
__init__( (object)arg1, (Point3D)refPoint, (ClippedSweptSolid3D)solid) -> None :
    Copy constructor.
    
    Parameter: refPoint  reference point
               solid     Solid which will be copied
__mul__(...)
__mul__( (ClippedSweptSolid3D)arg1, (Matrix3D)matrix) -> object :
    Matrix transformation
    
    Parameter: matrix  Transformation 3D matrix
    
    Return:  Transformed ClippedSweptSolid3D
__reduce__ = (...)
__repr__(...)
__repr__( (ClippedSweptSolid3D)arg1) -> str

Data descriptors defined here:
BottomPlane
Get and set the bottom plane as property
RefPoint
Get and set the reference point as property
SweptArea
Get and set the swept area as property
TopPlane
Get and set the top plane as property

Data and other attributes defined here:
__instance_size__ = 160

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClippedSweptSolid3DList(Boost.Python.instance)
    
Method resolution order:
ClippedSweptSolid3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ClippedSweptSolid3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ClippedSweptSolid3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ClippedSweptSolid3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ClippedSweptSolid3DList)arg1) -> str
__setitem__(...)
__setitem__( (ClippedSweptSolid3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ClippedSweptSolid3DList)arg1, (object)arg2) -> None
extend(...)
extend( (ClippedSweptSolid3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedArea2D(Boost.Python.instance)
    2D closed area
Representation class for 2D geometry closed (path bounded) area
 
 
Method resolution order:
ClosedArea2D
Boost.Python.instance
builtins.object

Methods defined here:
AddInnerCurve(...)
AddInnerCurve( (ClosedArea2D)arg1, (Path2D)innerpath) -> bool :
    Add new inner curve
    
    Parameter: innerpath  New inner curve ( Path2D )
    
    Return: true if the operation was successful
Clear(...)
Clear( (ClosedArea2D)arg1) -> None :
    Clear all the components of this Area
GetInnerCurve(...)
GetInnerCurve( (ClosedArea2D)arg1, (int)index) -> Path2D :
    Get the curve of given index
    
    Parameter: index  Index of the inner curve
    
    Return: const reference to the curve ( Path2D )
GetInnerList(...)
GetInnerList( (ClosedArea2D)arg1) -> Path2DList :
    Get the list of the inner curves
    
    Return: reference to a vector that contains the inner curves ( Path2D )
GetOuterCurve(...)
GetOuterCurve( (ClosedArea2D)arg1) -> Path2D :
    Get the outer curve of this area
    
    Return: const reference to outer curve ( Path2D )
InnerCount(...)
InnerCount( (ClosedArea2D)arg1) -> int :
    Get the count of inner curves
    
    Return: count of inner curves
IsValid(...)
IsValid( (ClosedArea2D)arg1) -> bool :
    Set Check the validity
    
    Return: true if this Area is valid
SetOuterCurve(...)
SetOuterCurve( (ClosedArea2D)arg1, (Path2D)outerpath) -> None :
    Set new Outer curve ( bounds )
    
    Parameter: outerpath  New outer curve ( Path2D )
__eq__(...)
__eq__( (ClosedArea2D)arg1, (ClosedArea2D)closedArea) -> object :
    Comparison of closedAreas without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: closedArea Compared closedArea.
    
    Return: True when closedAreas are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (ClosedArea2D)area) -> None :
    Copy constructor
    
    Parameter: area  Area which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedArea2D)arg1) -> str

Data descriptors defined here:
InnerList
Get the inner path list as property
OuterCurve
Get and set the outer path as property

Data and other attributes defined here:
__instance_size__ = 72

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedArea2DList(Boost.Python.instance)
    
Method resolution order:
ClosedArea2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ClosedArea2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ClosedArea2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ClosedArea2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedArea2DList)arg1) -> str
__setitem__(...)
__setitem__( (ClosedArea2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ClosedArea2DList)arg1, (object)arg2) -> None
extend(...)
extend( (ClosedArea2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedArea3D(Boost.Python.instance)
    3D closed area
Representation class for 3D geometry area
 
 
Method resolution order:
ClosedArea3D
Boost.Python.instance
builtins.object

Methods defined here:
AddInnerCurve(...)
AddInnerCurve( (ClosedArea3D)arg1, (Path2D)innerpath) -> bool :
    Add new inner curve
    
    Parameter: innerpath  New inner curve ( Path2D )
    
    Return: true if the operation was successful
Clear(...)
Clear( (ClosedArea3D)arg1) -> None :
    Clear all the components of this Profile
GetInnerCurve(...)
GetInnerCurve( (ClosedArea3D)arg1, (int)index) -> Path2D :
    Get the curve of given index
    
    Parameter: index  Index of the inner curve
    
    Return: const reference to the curve ( Path2D )
GetInnerList(...)
GetInnerList( (ClosedArea3D)arg1) -> Path2DList :
    Get the list of the inner curves
    
    Return: reference to a vector that contains the inner curves ( Path2D )
GetOuterCurve(...)
GetOuterCurve( (ClosedArea3D)arg1) -> Path2D :
    Get the outer curve of this profile
    
    Return: const reference to outer curve ( Path2D )
GetRefPlacement(...)
GetRefPlacement( (ClosedArea3D)arg1) -> AxisPlacement3D :
    Get axis placement
    
    Return: const reference to the reference axis placement
InnerCount(...)
InnerCount( (ClosedArea3D)arg1) -> int :
    Get the count of inner curves
    
    Return: count of inner curves
IsValid(...)
IsValid( (ClosedArea3D)arg1) -> bool :
    Set Check the validity
    
    Return: true if this Profile is valid
SetOuterCurve(...)
SetOuterCurve( (ClosedArea3D)arg1, (Path2D)outerpath) -> None :
    Set new Outer curve ( bounds )
    
    Parameter: outerpath  New outer curve ( Path2D )
SetRefPlacement(...)
SetRefPlacement( (ClosedArea3D)arg1, (AxisPlacement3D)placement) -> None :
    Set axis placement
    
    Parameter: placement  Reference axis placement
__eq__(...)
__eq__( (ClosedArea3D)arg1, (ClosedArea3D)closedArea) -> object :
    Comparison of closedAreas without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: closedArea Compared closedArea.
    
    Return: True when closedAreas are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (ClosedArea3D)closedArea) -> None :
    Copy constructor.
    
    Parameter: closedArea  3D closed area which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedArea3D)arg1) -> str

Data descriptors defined here:
RefPlacement
Get and set the reference placement 3d as property

Data and other attributes defined here:
__instance_size__ = 144

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedArea3DList(Boost.Python.instance)
    
Method resolution order:
ClosedArea3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ClosedArea3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ClosedArea3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ClosedArea3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedArea3DList)arg1) -> str
__setitem__(...)
__setitem__( (ClosedArea3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ClosedArea3DList)arg1, (object)arg2) -> None
extend(...)
extend( (ClosedArea3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedAreaComposite2D(Boost.Python.instance)
    2D closed area composite
Representation class for 2D geometry closed (path bounded) area composite
 
 
Method resolution order:
ClosedAreaComposite2D
Boost.Python.instance
builtins.object

Methods defined here:
Add(...)
Add( (ClosedAreaComposite2D)arg1, (ClosedArea2D)area) -> bool :
    Add new area
    
    Parameter: area  New area
    
    Return: true if the operation was successful
Clear(...)
Clear( (ClosedAreaComposite2D)arg1) -> None :
    Clear contents of this composite
GetProfile(...)
GetProfile( (ClosedAreaComposite2D)arg1, (int)index) -> ClosedArea2D :
    Get profile from list of profiles
    
    Parameter: index  Index of profile in vector of profiles
    
    Return: reference to profile
GetProfileCount(...)
GetProfileCount( (ClosedAreaComposite2D)arg1) -> int :
    Get count of profiles (areas)
    
    Return: size_t - count of profiles (areas)
GetProfileList(...)
GetProfileList( (ClosedAreaComposite2D)arg1) -> ClosedArea2DList :
    Get const reference to vector of profiles
    
    Return: const reference to vector of profiles
IsEmpty(...)
IsEmpty( (ClosedAreaComposite2D)arg1) -> bool :
    Check if this composite has any contents ( areas )
    
    Return: true if it is empty
__eq__(...)
__eq__( (ClosedAreaComposite2D)arg1, (ClosedAreaComposite2D)closedAreaComposite) -> object :
    Comparison of closedAreaComposites without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: closedAreaComposite Compared closedAreaComposite.
    
    Return: True when closedAreaComposites are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (ClosedAreaComposite2D)composite) -> None :
    Copy constructor
    
    Parameter: composite  Area composite which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedAreaComposite2D)arg1) -> str

Data descriptors defined here:
ProfileList
Get the profile list as property

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedAreaComposite2DList(Boost.Python.instance)
    
Method resolution order:
ClosedAreaComposite2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ClosedAreaComposite2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ClosedAreaComposite2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ClosedAreaComposite2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedAreaComposite2DList)arg1) -> str
__setitem__(...)
__setitem__( (ClosedAreaComposite2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ClosedAreaComposite2DList)arg1, (object)arg2) -> None
extend(...)
extend( (ClosedAreaComposite2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedAreaComposite3D(Boost.Python.instance)
    3D closed area composite
Representation class for 3D geometry profile composite
 
 
Method resolution order:
ClosedAreaComposite3D
Boost.Python.instance
builtins.object

Methods defined here:
Add(...)
Add( (ClosedAreaComposite3D)arg1, (ClosedArea2D)profile) -> bool :
    Add new profile
    
    Parameter: profile  New profile
    
    Return: true if the operation was successful
Clear(...)
Clear( (ClosedAreaComposite3D)arg1) -> None :
    Clear contents of this composite
GetClosedAreaComposite(...)
GetClosedAreaComposite( (ClosedAreaComposite3D)arg1) -> ClosedAreaComposite2D :
    Get constant reference to composite of ClosedArea2D
    
    Return: ClosedAreaComposite2D
GetRefPlacement(...)
GetRefPlacement( (ClosedAreaComposite3D)arg1) -> AxisPlacement3D :
    Get axis placement
    
    Return: const reference to the reference axis placement
IsEmpty(...)
IsEmpty( (ClosedAreaComposite3D)arg1) -> bool :
    Check if this composite has any contents ( profiles )
    
    Return: true if it is empty
SetRefPlacement(...)
SetRefPlacement( (ClosedAreaComposite3D)arg1, (AxisPlacement3D)placement) -> None :
    Set axis placement
    
    Parameter: placement  Reference axis placement
__eq__(...)
__eq__( (ClosedAreaComposite3D)arg1, (ClosedAreaComposite3D)closedAreaComposite) -> object :
    Comparison of closedAreaComposites without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: closedAreaComposite Compared closedAreaComposite.
    
    Return: True when closedAreaComposites are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (ClosedAreaComposite3D)composite) -> None :
    Copy constructor
    
    Parameter: composite  Profile composite which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedAreaComposite3D)arg1) -> str

Data descriptors defined here:
ClosedAreaComposite
Get the 2d closed area composite as property
RefPlacement
Get and set the reference placement 3d as property

Data and other attributes defined here:
__instance_size__ = 120

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ClosedAreaComposite3DList(Boost.Python.instance)
    
Method resolution order:
ClosedAreaComposite3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ClosedAreaComposite3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ClosedAreaComposite3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ClosedAreaComposite3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ClosedAreaComposite3DList)arg1) -> str
__setitem__(...)
__setitem__( (ClosedAreaComposite3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ClosedAreaComposite3DList)arg1, (object)arg2) -> None
extend(...)
extend( (ClosedAreaComposite3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Clothoid2D(Boost.Python.instance)
    2D clothoid
Representation class for 2D clothoid.
 
 
Method resolution order:
Clothoid2D
Boost.Python.instance
builtins.object

Methods defined here:
GetEndCurvature(...)
GetEndCurvature( (Clothoid2D)arg1) -> float :
    Get end curvature.
    
    Return: double end curvature of clothoid.
GetEndPoint(...)
GetEndPoint( (Clothoid2D)arg1) -> Point2D :
    Get end point in world coordinate system.
    
    Return: point Point2D.
GetEndRelPoint(...)
GetEndRelPoint( (Clothoid2D)arg1) -> Point2D :
    Get the end point in relative coordinate system
    
    Return: constant reference to Point2D.
GetIsReversed(...)
GetIsReversed( (Clothoid2D)arg1) -> bool :
    is clothoid reversed
    
    Return: true/false
GetLength(...)
GetLength( (Clothoid2D)arg1) -> float :
    Get length of clothoid.
    
    Return: double length of clothoid.
GetParallel(...)
GetParallel( (Clothoid2D)arg1) -> float :
    Get parallel of clothoid.
    
    Return: double parallel of clothoid.
GetRefPoint(...)
GetRefPoint( (Clothoid2D)arg1) -> Point2D :
    Get reference point in world coordinate system
    
    Return: reference to point.
GetStartCurvature(...)
GetStartCurvature( (Clothoid2D)arg1) -> float :
    Get start curvature.
    
    Return: double start curvature of clothoid.
GetStartPoint(...)
GetStartPoint( (Clothoid2D)arg1) -> Point2D :
    Get start point in world coordinate system.
    
    Return: point Point2D.
GetStartRelPoint(...)
GetStartRelPoint( (Clothoid2D)arg1) -> Point2D :
    Get the start point in relative coordinate system
    
    Return: constant reference to Point2D.
GetStartVector(...)
GetStartVector( (Clothoid2D)arg1) -> Vector2D :
    Get start vector.
    
    Return: const reference to Vector2D.
GetType(...)
GetType( (Clothoid2D)arg1) -> eClothoidType :
    Get type of clothoid.
    
    Return: eClothoidType type of clothoid.
Reverse(...)
Reverse( (Clothoid2D)arg1) -> None :
    Reverse orientation of the Clothoid
Set(...)
Set( (Clothoid2D)arg1, (Clothoid2D)clothoid) -> None :
    Initialize clothoid from clothoid.
    
    Parameter: clothoid  Clothoid2D.
SetEndCurvature(...)
SetEndCurvature( (Clothoid2D)arg1, (float)curvature) -> None :
    Set end curvature of clothoid.
    
    Parameter: curvature  end curvature of clothoid
SetEndPoint(...)
SetEndPoint( (Clothoid2D)arg1, (Point2D)point) -> None :
    Set end point in world coordinate system.
    
    Parameter: point  const reference to Point2D in World coordinate system.
SetEndRelPoint(...)
SetEndRelPoint( (Clothoid2D)arg1, (Point2D)point) -> None :
    Set end point in local coordinate system
    
    Parameter: point  Point2D in local coordinate system
SetLength(...)
SetLength( (Clothoid2D)arg1, (float)length) -> None :
    Set length of clothoid.
    
    Parameter: length  length of clothoid.
SetParallel(...)
SetParallel( (Clothoid2D)arg1, (float)parallel) -> None :
    Set parallel of clothoid.
    
    Parameter: parallel  length of clothoid.
SetRefPoint(...)
SetRefPoint( (Clothoid2D)arg1, (Point2D)refPoint) -> None :
    Set reference point in world coordinate system
    
    Parameter: refPoint  const reference to Point2D in World coordinate system.
SetReversed(...)
SetReversed( (Clothoid2D)arg1, (bool)flag) -> None :
    Set orientation.
    
    Parameter: flag  true for reversed, false normal orientation.
SetStartCurvature(...)
SetStartCurvature( (Clothoid2D)arg1, (float)curvature) -> None :
    Set start curvature of clothoid.
    
    Parameter: curvature  start curvature of clothoid
SetStartPoint(...)
SetStartPoint( (Clothoid2D)arg1, (Point2D)point) -> None :
    Set start point in world coordinate system.
    
    Parameter: point  const reference to Point2D in World coordinate system.
SetStartRelPoint(...)
SetStartRelPoint( (Clothoid2D)arg1, (Point2D)point) -> None :
    Set start point in local coordinate system
    
    Parameter: point  Point2D in local coordinate system
SetStartVector(...)
SetStartVector( (Clothoid2D)arg1, (Vector2D)vec) -> None :
    Set start vector.
    
    Parameter: vec  const reference to Vector2D.
SetType(...)
SetType( (Clothoid2D)arg1, (eClothoidType)type) -> None :
    Set type of clothoid.
    
    Parameter: type  type of clothoid.
__eq__(...)
__eq__( (Clothoid2D)arg1, (Clothoid2D)clothoid) -> object :
    Comparison of clothoids without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: clothoid Compared clothoid.
    
    Return: True when clothoids are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Clothoid2D)clothoid) -> None :
    Copy constructor.
    
    Parameter: clothoid  Clothoid2D which will be copied.
__mul__(...)
__mul__( (Clothoid2D)arg1, (Matrix2D)matrix) -> object :
    Matrix transformation.
    
    Parameter: matrix  transformation matrix.
    
    Return: Clothoid2D transformed clothoid.
__reduce__ = (...)
__repr__(...)
__repr__( (Clothoid2D)arg1) -> str

Data descriptors defined here:
EndCurvature
Get and set the end curvature property
EndPoint
Get and set the end point property
IsReversed
Get and set the reversed property
Length
Get and set the length property
Parallel
Get and set the parallel property
RefPoint
Get and set the end point property
StartCurvature
Get and set the start curvature property
StartPoint
Get and set the start point property
StartVector
Get and set the start vector property
Type
Get and set the type property

Data and other attributes defined here:
__instance_size__ = 120

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Clothoid2DList(Boost.Python.instance)
    
Method resolution order:
Clothoid2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Clothoid2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Clothoid2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Clothoid2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Clothoid2DList)arg1) -> str
__setitem__(...)
__setitem__( (Clothoid2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Clothoid2DList)arg1, (object)arg2) -> None
extend(...)
extend( (Clothoid2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Comparison(Boost.Python.instance)
    Class for comparison between two objects
 
 
Method resolution order:
Comparison
Boost.Python.instance
builtins.object

Methods defined here:
Equal(...)
Equal( (float)el1, (float)el2, (float)tol) -> bool :
    compare 2 doubles with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Point2D)el1, (Point2D)el2, (float)tol) -> bool :
    compare 2 2D points with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Point3D)el1, (Point3D)el2, (float)tol) -> bool :
    compare 2 3D points with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Vector2D)el1, (Vector2D)el2, (float)tol) -> bool :
    compare 2 2D vectors with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Vector3D)el1, (Vector3D)el2, (float)tol) -> bool :
    compare 2 3D vectors with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Line2D)el1, (Line2D)el2, (float)tol) -> bool :
    compare 2 line 2D with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Line3D)el1, (Line3D)el2, (float)tol) -> bool :
    compare 2 line 3D with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Spline2D)el1, (Spline2D)el2, (float)tol) -> bool :
    compare 2 splines with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Clothoid2D)el1, (Clothoid2D)el2, (float)tol) -> bool :
    compare 2 clothoides with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Arc2D)el1, (Arc2D)el2, (float)tol) -> bool :
    compare 2 arcs with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (Arc3D)el1, (Arc3D)el2, (float)tol) -> bool :
    compare 2 3D arcs with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return: true when equal, otherwise false.
 
Equal( (BSpline2D)el1, (BSpline2D)el2, (float)tol) -> bool :
    Compare 2 BSplines with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return:  true when equal, otherwise false.
 
Equal( (BSpline3D)el1, (BSpline3D)el2, (float)tol) -> bool :
    Compare 2 BSplines with given tolerance
    
    Parameter: el1  1. element
               el2  2. element
               tol  tolerance
    
    Return:  true when equal, otherwise false.
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Cone3D(Boost.Python.instance)
    3D cone
 
 
Method resolution order:
Cone3D
Boost.Python.instance
builtins.object

Methods defined here:
GetApex(...)
GetApex( (Cone3D)arg1) -> Point3D :
    Get Apex of the Cone in the local coordinate system
    
    Return: Reference to Apex.
GetApexParent(...)
GetApexParent( (Cone3D)arg1) -> Point3D :
    Get Apex of the Cone in the parent coordinate system
    
    Return: Reference to Apex.
GetCenter(...)
GetCenter( (Cone3D)arg1) -> Point3D :
    Get Center of the Cone
    
    Return: Reference to Center.
GetHeight(...)
GetHeight( (Cone3D)arg1) -> float :
    Get Height of the Cone
    
    Return: Reference to Height of the Cone.
GetLocalPlacement(...)
GetLocalPlacement( (Cone3D)arg1) -> AxisPlacement3D :
    Get Local Placement
    
    Return: Reference to Local Placement.
GetMajorRadius(...)
GetMajorRadius( (Cone3D)arg1) -> float :
    Get Major Radius of the Cone
    
    Return: Reference to MajorRadius.
GetMinMax(...)
GetMinMax( (Cone3D)arg1) -> MinMax3D :
    Get MinMax of the Cone
    
    Return: Reference to MinMax of the Cone.
GetMinorRadius(...)
GetMinorRadius( (Cone3D)arg1) -> float :
    Get Minor Radius of the Cone
    
    Return: Reference to MinorRadius.
GetXAxis(...)
GetXAxis( (Cone3D)arg1) -> Vector3D :
    Get X-Axis of the placement of the Cone
    
    Return: Reference to X-Axis.
GetZAxis(...)
GetZAxis( (Cone3D)arg1) -> Vector3D :
    Get Z - axis of the placement of the Cone
    
    Return: Reference to Z-axis.
IsCircular(...)
IsCircular( (Cone3D)arg1) -> bool :
    Circularity check for the Cone
    
    Return: true/false
IsOblique(...)
IsOblique( (Cone3D)arg1) -> bool :
    Perpendicularity check for the Cone
    
    Return: true/false
IsValid(...)
IsValid( (Cone3D)arg1) -> bool :
    Validity check for the Cone
    
    Return: true/false
SetApex(...)
SetApex( (Cone3D)arg1, (Point3D)apex) -> None :
    Set Apex in the local coordinate system
    
    Parameter: apex  New Apex.
SetApexParent(...)
SetApexParent( (Cone3D)arg1, (Point3D)apex) -> None :
    Set Apex in the parent coordinate system
    
    Parameter: apex  New Apex.
SetCenter(...)
SetCenter( (Cone3D)arg1, (Point3D)center) -> None :
    Set center
    
    Parameter: center  New center.
SetHeight(...)
SetHeight( (Cone3D)arg1, (float)arg2) -> None :
    Set Height of the Cone
    
    Parameter: height  New height.
SetLocalPlacement(...)
SetLocalPlacement( (Cone3D)arg1, (AxisPlacement3D)placement) -> None :
    Set Local Placement.
    
    Parameter: placement  Local Placement.
SetMajorRadius(...)
SetMajorRadius( (Cone3D)arg1, (float)arg2) -> None :
    Set Major Radius of the Cone
    
    Parameter: radius  New major radius.
SetMinorRadius(...)
SetMinorRadius( (Cone3D)arg1, (float)arg2) -> None :
    Set Minor Radius of the Cone
    
    Parameter: radius  New minor radius.
__eq__(...)
__eq__( (Cone3D)arg1, (Cone3D)cone) -> object :
    Comparison of cones without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: cone Compared cone.
    
    Return: True when cones are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Cone3D)cone) -> None :
    Copy constructor.
    
    Parameter: cone  Cone which will be copied.
 
__init__( (object)arg1, (AxisPlacement3D)refPlacement, (float)radiusMajor, (float)radiusMinor, (Point3D)apex) -> None :
    Constructor.
    
    Height of the Cone is z-coordinate of the Apex.
    
    Parameter: refPlacement  Local Placement of the Cone.
               radiusMajor   Major radius of the Cone.
               radiusMinor   Minor radius of the Cone.
               apex          Apex of the Cone
 
__init__( (object)arg1, (float)radiusMajor, (float)radiusMinor, (Point3D)apex) -> None :
    Constructor.
    
    Height of the Cone is z-coordinate of the Apex.
    
    Parameter: radiusMajor  Major radius of the Cone.
               radiusMinor  Minor radius of the Cone.
               apex         Apex of the Cone
__reduce__ = (...)
__repr__(...)
__repr__( (Cone3D)arg1) -> str

Data descriptors defined here:
Apex
Get and set the apex property
LocalPlacement
Get and set the local placement property
MajorRadius
Get and set the major radius property
MinorRadius
Get and set the minor radius property

Data and other attributes defined here:
__instance_size__ = 128

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Cone3DList(Boost.Python.instance)
    
Method resolution order:
Cone3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Cone3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Cone3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Cone3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Cone3DList)arg1) -> str
__setitem__(...)
__setitem__( (Cone3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Cone3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Cone3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ConicalSurface3D(Boost.Python.instance)
    3D conical surface
 
 
Method resolution order:
ConicalSurface3D
Boost.Python.instance
builtins.object

Methods defined here:
Get(...)
Get( (ConicalSurface3D)arg1) -> tuple :
    Get all surface members
    
    Return: placement of conical surface,
            radius of conical surface in placement,
            semi angle of conical surface
GetPlacement(...)
GetPlacement( (ConicalSurface3D)arg1) -> AxisPlacement3D :
    returns axis placement of the conical surface
    
    Return:  placement - point + axis vector + reference direction vector
GetRadius(...)
GetRadius( (ConicalSurface3D)arg1) -> float :
    Returns the radius at the placement
    
    Return:  radius
GetSemiAngle(...)
GetSemiAngle( (ConicalSurface3D)arg1) -> Angle :
    Returns the value of semi angle of conical surface
    
    Return:  angle
IsValid(...)
IsValid( (ConicalSurface3D)arg1) -> bool :
    Check surface validity
    
    Return:  bool valid = true
Set(...)
Set( (ConicalSurface3D)arg1, (AxisPlacement3D)placement, (float)radius, (Angle)angle) -> None :
    Set all surface members
    
    Parameter: placement  placement of conical surface
               radius     radius of conical surface in placement
               angle      semi angle of conical surface
SetPlacement(...)
SetPlacement( (ConicalSurface3D)arg1, (AxisPlacement3D)value) -> None :
    sets the position of conical surface
    
    Parameter: value  placement - point + axis vector + reference direction vector
SetRadius(...)
SetRadius( (ConicalSurface3D)arg1, (float)value) -> None :
    Sets the radius at the placement
    
    Parameter: value  radius to be set
SetSemiAngle(...)
SetSemiAngle( (ConicalSurface3D)arg1, (Angle)value) -> None :
    Sets the value of semi angle of conical surface
    
    Parameter: value  angle to be set
__eq__(...)
__eq__( (ConicalSurface3D)arg1, (ConicalSurface3D)surface) -> object :
    Comparison of conical surfaces without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: conical surface Compared conical surface.
    
    Return: True when conical surfaces are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (AxisPlacement3D)placement, (float)radius, (Angle)angle) -> None :
    Constructor.
    
    Parameter: placement  placement of conical surface
               radius     radius at a placement
               angle      angle between placement axis and some axis on surface
                          -----------------------------------------------------------------------------
 
__init__( (object)arg1, (ConicalSurface3D)surface) -> None :
    Copy constructor.
    
    Parameter: surface  Surface which will be copied.
                        -----------------------------------------------------------------------------
__reduce__ = (...)
__repr__(...)
__repr__( (ConicalSurface3D)arg1) -> str

Data descriptors defined here:
Placement
Get and set the placement property
Radius
Get and set the radius property
SemiAngle
Get and set the semi angle property

Data and other attributes defined here:
__instance_size__ = 104

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ConicalSurface3DList(Boost.Python.instance)
    
Method resolution order:
ConicalSurface3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ConicalSurface3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ConicalSurface3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ConicalSurface3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ConicalSurface3DList)arg1) -> str
__setitem__(...)
__setitem__( (ConicalSurface3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ConicalSurface3DList)arg1, (object)arg2) -> None
extend(...)
extend( (ConicalSurface3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Cuboid3D(Boost.Python.instance)
    3D cuboid
 
 
Method resolution order:
Cuboid3D
Boost.Python.instance
builtins.object

Methods defined here:
GetBottomFacePolygon(...)
GetBottomFacePolygon( (Cuboid3D)arg1) -> Polygon3D :
    Get the boundary polygon of bottom face of the cuboid
    
    Return: Bottom face boundary polygon
GetGroundPlane(...)
GetGroundPlane( (Cuboid3D)arg1) -> Plane3D :
    Get ground plane ( ref point + Z-vector ).
    
    Return: ground Plane3D.
GetHeight(...)
GetHeight( (Cuboid3D)arg1) -> float :
    Get height.
    
    Return: Size of Z-vector ( vector3 ).
GetLength(...)
GetLength( (Cuboid3D)arg1) -> float :
    Get length.
    
    Return: Size of X-vector ( vector1 ).
GetRefPoint(...)
GetRefPoint( (Cuboid3D)arg1) -> Point3D :
    Get reference point.
    
    Return: Reference point.
GetRelStartPoint(...)
GetRelStartPoint( (Cuboid3D)arg1) -> Point3D :
    Get start point in relative coordinates.
    
    Return: Constant reference to the start point.
GetStartPoint(...)
GetStartPoint( (Cuboid3D)arg1) -> Point3D :
    Get start point in world coordinates.
    
    Return: copy of start point.
GetTopFacePolygon(...)
GetTopFacePolygon( (Cuboid3D)arg1) -> Polygon3D :
    Get the boundary polygon of top face of the cuboid
    
    Return: Top face boundary polygon
GetVector(...)
GetVector( (Cuboid3D)arg1, (int)index) -> Vector3D :
    Get given vector.
    
    Parameter: index  Index of the vector.
    
    Return: m_Vec[index]
GetWidth(...)
GetWidth( (Cuboid3D)arg1) -> float :
    Get width.
    
    Return: Size of Y-vector ( vector2 ).
Set(...)
Set( (Cuboid3D)arg1, (Point3D)refPoint, (Point3D)startPoint, (Vector3D)vec1, (Vector3D)vec2, (Vector3D)vec3) -> None :
    Set the Cuboid.
    
    Parameter: refPoint    Reference point in world coordinate system.
               startPoint  Start point of cuboid.
               vec1        X-vector.
               vec2        Y-vector.
               vec3        Z-vector.
 
Set( (Cuboid3D)arg1, (Cuboid3D)cuboid) -> None :
    Initialize from cuboid.
    
    Parameter: cuboid  Cuboid which will be copied.
SetHeight(...)
SetHeight( (Cuboid3D)arg1, (float)height) -> None :
    Set height.
    
    Parameter: height  New size of Z-vector ( vector3 ).
SetLength(...)
SetLength( (Cuboid3D)arg1, (float)length) -> None :
    Set length.
    
    Parameter: length  New size of X-vector ( vector1 ).
SetRefPoint(...)
SetRefPoint( (Cuboid3D)arg1, (Point3D)refPoint) -> None :
    Set reference point.
    
    Parameter: refPoint  New reference point.
SetStartPoint(...)
SetStartPoint( (Cuboid3D)arg1, (Point3D)startPoint) -> None :
    Set start point.
    
    Parameter: startPoint  New start point ( in world coordinates ).
SetVector(...)
SetVector( (Cuboid3D)arg1, (Vector3D)vec, (int)index) -> None :
    Set the vector.
    
    Parameter: vec    New vector.
               index  Index pf the vector.
SetWidth(...)
SetWidth( (Cuboid3D)arg1, (float)width) -> None :
    Set width.
    
    Parameter: width  New size of Y-vector ( vector2 ).
__eq__(...)
__eq__( (Cuboid3D)arg1, (Cuboid3D)cuboid) -> object :
    Comparison of cuboids without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: cuboid Compared cuboid.
    
    Return: True when cuboids are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Cuboid3D)cuboid) -> None :
    Copy constructor.
    
    Parameter: cuboid  Cuboid which will be copied.
 
__init__( (object)arg1, (Point3D)refPoint, (Point3D)startPoint, (Vector3D)vec1, (Vector3D)vec2, (Vector3D)vec3) -> None :
    Constructor.
    
    Parameter: refPoint    Reference point.
               startPoint  Start point of cuboid.
               vec1        X-vector.
               vec2        Y-vector.
               vec3        Z-vector
__reduce__ = (...)
__repr__(...)
__repr__( (Cuboid3D)arg1) -> str

Data descriptors defined here:
HeightVector
Get and set the height vector property
LengthVector
Get and set the length vector property
RefPoint
Get and set the ref point property
StartPoint
Get and set the start point property
WidthVector
Get and set the width vector property

Data and other attributes defined here:
__instance_size__ = 136

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Cuboid3DList(Boost.Python.instance)
    
Method resolution order:
Cuboid3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Cuboid3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Cuboid3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Cuboid3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Cuboid3DList)arg1) -> str
__setitem__(...)
__setitem__( (Cuboid3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Cuboid3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Cuboid3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Cylinder3D(Boost.Python.instance)
    3D cylinder
 
 
Method resolution order:
Cylinder3D
Boost.Python.instance
builtins.object

Methods defined here:
GetApex(...)
GetApex( (Cylinder3D)arg1) -> Point3D :
    Get Apex of the Cylinder in the local coordinate system
    
    Return: Reference to Apex.
GetApexParent(...)
GetApexParent( (Cylinder3D)arg1) -> Point3D :
    Get Apex of the Cylinder in the parent coordinate system
    
    Return: Reference to Apex.
GetBottomCenter(...)
GetBottomCenter( (Cylinder3D)arg1) -> Point3D :
    Get bottom center
    
    Return:  center of bottom base
GetCenter(...)
GetCenter( (Cylinder3D)arg1) -> Point3D :
    Get Center of the Cylinder
    
    Return: Reference to Center.
GetHeight(...)
GetHeight( (Cylinder3D)arg1) -> float :
    Get Height of the Cylinder
    
    Return: Reference to Height of the Cylinder.
GetLocalPlacement(...)
GetLocalPlacement( (Cylinder3D)arg1) -> AxisPlacement3D :
    Get Local Placement
    
    Return: Reference to Local Placement.
GetMajorRadius(...)
GetMajorRadius( (Cylinder3D)arg1) -> float :
    Get Major Radius of the Cylinder
    
    Return: Reference to Major Radius.
GetMinMax(...)
GetMinMax( (Cylinder3D)arg1) -> MinMax3D :
    Get MinMax of the Cylinder
    
    Return: Reference to MinMax of the Cylinder.
GetMinorRadius(...)
GetMinorRadius( (Cylinder3D)arg1) -> float :
    Get Minor Radius of the Cylinder
    
    Return: Reference to Minor Radius.
GetSilhouetteLines(...)
GetSilhouetteLines( (Cylinder3D)arg1, (Matrix3D)viewMatrix, (bool)bPerspective) -> Line3DList :
    Get silhouette lines of cylinder
    
    Parameter: viewMatrix    View matrix
               bPerspective  Flag if it is central projection or not (true / false)
    
    Return: silhouette lines
GetTopCenter(...)
GetTopCenter( (Cylinder3D)arg1) -> Point3D :
    Get top center
    
    Return:  center of top plane
GetXAxis(...)
GetXAxis( (Cylinder3D)arg1) -> Vector3D :
    Get X-Axis of the placement of the Cylinder
    
    Return: Reference to X-Axis.
GetYAxis(...)
GetYAxis( (Cylinder3D)arg1) -> Vector3D :
    Get Y-Axis of the placement of the Cylinder
    
    Return: Reference to X-Axis.
GetZAxis(...)
GetZAxis( (Cylinder3D)arg1) -> Vector3D :
    Get Z - axis of the placement of the Cylinder
    
    Return: Reference to Z-axis.
IsCircular(...)
IsCircular( (Cylinder3D)arg1) -> bool :
    Circularity check of the Cylinder
    
    Return: true/false
IsOblique(...)
IsOblique( (Cylinder3D)arg1) -> bool :
    Perpendicularity check of the Cylinder
    
    Return: true/false
IsValid(...)
IsValid( (Cylinder3D)arg1) -> bool :
    Validity check of the Cylinder
    
    Return: true/false
SetApex(...)
SetApex( (Cylinder3D)arg1, (Point3D)apex) -> None :
    Set Apex in the local coordinate system
    
    Parameter: apex  New Apex.
SetApexParent(...)
SetApexParent( (Cylinder3D)arg1, (Point3D)apex) -> None :
    Set Apex in the parent coordinate system
    
    Parameter: apex  New Apex.
SetCenter(...)
SetCenter( (Cylinder3D)arg1, (Point3D)center) -> None :
    Set center
    
    Parameter: center  New center.
SetHeight(...)
SetHeight( (Cylinder3D)arg1, (float)arg2) -> None :
    Set Height of the Cylinder
    
    Parameter: height  New height.
SetLocalPlacement(...)
SetLocalPlacement( (Cylinder3D)arg1, (AxisPlacement3D)placement) -> None :
    Set Local Placement.
    
    Parameter: placement  Local Placement.
 
SetLocalPlacement( (Cylinder3D)arg1, (Point3D)center, (Vector3D)xAxis, (Vector3D)zAxis) -> None :
    Set Local Placement.
    
    Parameter: center  Center point of the placement
               xAxis   X-axis of the placement
               zAxis   Z-axis of the placement
SetMajorRadius(...)
SetMajorRadius( (Cylinder3D)arg1, (float)arg2) -> None :
    Set Major Radius of the Cylinder
    
    Parameter: radius  New major radius.
SetMinorRadius(...)
SetMinorRadius( (Cylinder3D)arg1, (float)arg2) -> None :
    Set Minor Radius of the Cylinder
    
    Parameter: radius  New minor radius.
__eq__(...)
__eq__( (Cylinder3D)arg1, (Cylinder3D)cylinder) -> object :
    Comparison of cylinders without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: cylinder Compared cylinder.
    
    Return: True when cylinders are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Cylinder3D)cylinder) -> None :
    Copy constructor.
    
    Parameter: cylinder  Cylinder which will be copied.
 
__init__( (object)arg1, (AxisPlacement3D)refPlacement, (float)radiusMajor, (float)radiusMinor, (Point3D)apex) -> None :
    Constructor.
    
    Height of the cylinder is z-coordinate of the Apex.
    
    Parameter: refPlacement  Local Placement of the cylinder.
               radiusMajor   Major radius of the cylinder.
               radiusMinor   Minor radius of the cylinder.
               apex          Center of the Top Ellipse
 
__init__( (object)arg1, (float)radiusMajor, (float)radiusMinor, (Point3D)apex) -> None :
    Constructor.
    
    Height of the cylinder is z-coordinate of the Apex.
    
    Parameter: radiusMajor  Major radius of the cylinder.
               radiusMinor  Minor radius of the cylinder.
               apex         Center of the Top Ellipse
__reduce__ = (...)
__repr__(...)
__repr__( (Cylinder3D)arg1) -> str

Data descriptors defined here:
Apex
Get and set the apex property
LocalPlacement
Get and set the local placement property
MajorRadius
Get and set the major radius property
MinorRadius
Get and set the minor radius property

Data and other attributes defined here:
__instance_size__ = 128

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Cylinder3DList(Boost.Python.instance)
    
Method resolution order:
Cylinder3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Cylinder3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Cylinder3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Cylinder3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Cylinder3DList)arg1) -> str
__setitem__(...)
__setitem__( (Cylinder3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Cylinder3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Cylinder3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class DivisionPoints(Boost.Python.instance)
    Class for DivisionPoints
 
 
Method resolution order:
DivisionPoints
Boost.Python.instance
builtins.object

Methods defined here:
Count(...)
Count( (DivisionPoints)arg1) -> int :
    Get number of division points
    
    Return: number of division points
GetEndPoint(...)
GetEndPoint( (DivisionPoints)arg1) -> Point3D :
    Get the end point
    
    Return: End Point
GetEndPointAngle(...)
GetEndPointAngle( (DivisionPoints)arg1) -> Angle :
    Get the angle at the end point
    
    Return: Angle at the end point
GetPoint(...)
GetPoint( (DivisionPoints)arg1, (int)index) -> Point3D :
    Get division point
    
    Parameter: index  index of the division point
    
    Return: division point as Point3D
GetPointAngle(...)
GetPointAngle( (DivisionPoints)arg1, (int)index) -> Angle :
    Get the angle of a division point
    
    Parameter: index  index of the division point
    
    Return: angle as Angle
GetPointAngles(...)
GetPointAngles( (DivisionPoints)arg1) -> AngleList :
    Get the angles of the division points
    
    Return: copy of the angles of the division points as vector of Angle
GetPoints(...)
GetPoints( (DivisionPoints)arg1) -> Point3DList :
    Get the calculated division points
    
    Return: copy of the division points as vector of Point3D
GetStartPoint(...)
GetStartPoint( (DivisionPoints)arg1) -> Point3D :
    Get the start point
    
    Return: Start Point
GetStartPointAngle(...)
GetStartPointAngle( (DivisionPoints)arg1) -> Angle :
    Get the angle at the start point
    
    Return: Angle at the start point
IsSuccessful(...)
IsSuccessful( (DivisionPoints)arg1) -> bool :
    Get the result of the computation
    
    Return: Computation successful: true / false
__init__(...)
__init__( (object)arg1, (object)geoObject, (float)sectionLength, (float)eps) -> object :
    Constructor
    
    Parameter: geoObject      object to divide
               sectionLength  length of one division section
               eps            tolerance
    
 
__init__( (object)arg1, (Path2D)path, (float)sectionLength, (float)eps) -> None :
    Constructor
    
    Parameter: path           Path to divide
               sectionLength  length of one division section
               eps            tolerance
    
 
__init__( (object)arg1, (object)geoObject, (int)number, (float)eps) -> object :
    Constructor
    
    Parameter: geoObject  object to divide
               number     number of division points
               eps        tolerance
    
 
__init__( (object)arg1, (Path2D)path, (int)number, (float)eps) -> None :
    Constructor
    
    Parameter: path    Path to divide
               number  number of division points
               eps     tolerance
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Ellipsoid3D(Boost.Python.instance)
    3D ellipsoid
 
 
Method resolution order:
Ellipsoid3D
Boost.Python.instance
builtins.object

Methods defined here:
GetCenter(...)
GetCenter( (Ellipsoid3D)arg1) -> Point3D :
    Get Center of the Ellipsoid
    
    Return: Reference to Center.
GetIsoLines(...)
GetIsoLines( (Ellipsoid3D)arg1, (int)USegmentsCount, (int)VSegmentsCount) -> Arc3DList :
    Test whether the Ellipsoid is Sphere
    
    Parameter: USegmentsCount  count of circles
               VSegmentsCount  count of circles
    
    Return: vector of circles
GetLocalPlacement(...)
GetLocalPlacement( (Ellipsoid3D)arg1) -> AxisPlacement3D :
    Get Local Placement
    
    Return: Reference to Local Placement.
GetSilhouetteContour(...)
GetSilhouetteContour( (Ellipsoid3D)arg1, (Matrix3D)viewMatrix, (bool)bPerspective) -> Arc3D :
    Get silhouette circle
    
    Parameter: viewMatrix    view matrix
               bPerspective  central perspective true/false
    
    Return: silhouette
GetXAxis(...)
GetXAxis( (Ellipsoid3D)arg1) -> Vector3D :
    Get X-Axis of the placement of the Ellipsoid
    
    Return: Reference to X-Axis.
GetXRadius(...)
GetXRadius( (Ellipsoid3D)arg1) -> float :
    Get X Radius of the Ellipsoid
    
    Return: Reference to X Radius.
GetYAxis(...)
GetYAxis( (Ellipsoid3D)arg1) -> Vector3D :
    Get Y-Axis of the placement of the Ellipsoid
    
    Return: Reference to X-Axis.
GetYRadius(...)
GetYRadius( (Ellipsoid3D)arg1) -> float :
    Get Y Radius of the Ellipsoid
    
    Return: Reference to Y Radius.
GetZAxis(...)
GetZAxis( (Ellipsoid3D)arg1) -> Vector3D :
    Get Z - axis of the placement of the Ellipsoid
    
    Return: Reference to Z-axis.
GetZRadius(...)
GetZRadius( (Ellipsoid3D)arg1) -> float :
    Get Z Radius of the Ellipsoid
    
    Return: Reference to Z Radius.
IsSphere(...)
IsSphere( (Ellipsoid3D)arg1) -> bool :
    Test whether the Ellipsoid is Sphere
    
    Return: true/false
IsValid(...)
IsValid( (Ellipsoid3D)arg1) -> bool :
    Validity check of the Ellipsoid
    
    Return: true/false
SetCenter(...)
SetCenter( (Ellipsoid3D)arg1, (Point3D)center) -> None :
    Set center
    
    Parameter: center  New center.
SetLocalPlacement(...)
SetLocalPlacement( (Ellipsoid3D)arg1, (AxisPlacement3D)placement) -> None :
    Set Local Placement.
    
    Parameter: placement  Local Placement.
 
SetLocalPlacement( (Ellipsoid3D)arg1, (Point3D)center, (Vector3D)xAxis, (Vector3D)zAxis) -> None :
    Set Local Placement.
    
    Parameter: center  Center point of the placement
               xAxis   X-axis of the placement
               zAxis   Z-axis of the placement
SetXRadius(...)
SetXRadius( (Ellipsoid3D)arg1, (float)rad) -> None :
    Set X Radius of the Ellipsoid
    
    Parameter: rad  New radius.
    
    Return: Reference to X Radius.
SetYRadius(...)
SetYRadius( (Ellipsoid3D)arg1, (float)rad) -> None :
    Set Y Radius of the Ellipsoid
    
    Parameter: rad  New radius
SetZRadius(...)
SetZRadius( (Ellipsoid3D)arg1, (float)rad) -> None :
    Set Z Radius of the Ellipsoid
    
    Parameter: rad  New radius
__eq__(...)
__eq__( (Ellipsoid3D)arg1, (Ellipsoid3D)ellipsoid) -> object :
    Comparison of ellipsoids without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: ellipsoid Compared ellipsoid.
    
    Return: True when ellipsoids are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Ellipsoid3D)ellipsoid) -> None :
    Copy constructor.
    
    Parameter: ellipsoid  Ellipsoid which will be copied.
 
__init__( (object)arg1, (AxisPlacement3D)refPlacement, (float)radiusX, (float)radiusY, (float)radiusZ) -> None :
    Constructor.
    
    Parameter: refPlacement  Local Placement of the ellipsoid.
               radiusX       X radius of the Ellipsoid.
               radiusY       Y radius of the Ellipsoid.
               radiusZ       Z radius of the Ellipsoid.
 
__init__( (object)arg1, (float)radiusX, (float)radiusY, (float)radiusZ) -> None :
    Constructor.
    
    Parameter: radiusX  X radius of the Ellipsoid.
               radiusY  Y radius of the Ellipsoid.
               radiusZ  Z radius of the Ellipsoid.
__reduce__ = (...)
__repr__(...)
__repr__( (Ellipsoid3D)arg1) -> str

Data descriptors defined here:
LocalPlacement
Get and set the local placement property
XRadius
Get and set the x radius property
YRadius
Get and set the y radius property
ZRadius
Get and set the z radius property

Data and other attributes defined here:
__instance_size__ = 112

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Ellipsoid3DList(Boost.Python.instance)
    
Method resolution order:
Ellipsoid3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Ellipsoid3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Ellipsoid3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Ellipsoid3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Ellipsoid3DList)arg1) -> str
__setitem__(...)
__setitem__( (Ellipsoid3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Ellipsoid3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Ellipsoid3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ExtrudedAreaSolid3D(Boost.Python.instance)
    Solid created by extrusion of area by given direction vector
 
 
Method resolution order:
ExtrudedAreaSolid3D
Boost.Python.instance
builtins.object

Methods defined here:
GetDirection(...)
GetDirection( (ExtrudedAreaSolid3D)arg1) -> Vector3D :
    Get direction for extrusion
    
    Return: Vector3D const reference
GetExtrudedArea(...)
GetExtrudedArea( (ExtrudedAreaSolid3D)arg1) -> PolygonalArea3D :
    Get extruded area
    
    Return: PolygonalArea3D const reference
GetRefPoint(...)
GetRefPoint( (ExtrudedAreaSolid3D)arg1) -> Point3D :
    Get the reference point
    
    Return: Reference point
IsValid(...)
IsValid( (ExtrudedAreaSolid3D)arg1) -> bool :
    Check if the Solid is valid
    
    Return: True if it is a valid solid
SetDirection(...)
SetDirection( (ExtrudedAreaSolid3D)arg1, (Vector3D)dir) -> None :
    Set direction for extrusion
    
    Parameter: dir  Vector3D const reference
SetExtrudedArea(...)
SetExtrudedArea( (ExtrudedAreaSolid3D)arg1, (PolygonalArea3D)area) -> None :
    Set extruded area
    
    Parameter: area  PolygonalArea3D const reference
SetRefPoint(...)
SetRefPoint( (ExtrudedAreaSolid3D)arg1, (Point3D)refPoint) -> None :
    Set reference point
    
    Parameter: refPoint  New reference point
__eq__(...)
__eq__( (ExtrudedAreaSolid3D)arg1, (ExtrudedAreaSolid3D)extrudedAreaSolid) -> object :
    Comparison of extrudedAreaSolids without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: extrudedAreaSolid Compared extrudedAreaSolid.
    
    Return: True when extrudedAreaSolids are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (ExtrudedAreaSolid3D)solid) -> None :
    Copy constructor.
    
    Parameter: solid  Extruded area solid which will be copied
    
 
__init__( (object)arg1, (Point3D)solid, (ExtrudedAreaSolid3D)refPoint) -> None :
    Copy constructor.
    
    Parameter: solid     Solid which will be copied
               refPoint  reference point
__mul__(...)
__mul__( (ExtrudedAreaSolid3D)arg1, (Matrix3D)matrix) -> object :
    Matrix transformation
    
    Parameter: matrix  Transformation 3D matrix
__reduce__ = (...)
__repr__(...)
__repr__( (ExtrudedAreaSolid3D)arg1) -> str

Data descriptors defined here:
Direction
Get and set the direction as property
ExtrudedArea
Get and set the extruded area as property
RefPoint
Get and set the reference point as property

Data and other attributes defined here:
__instance_size__ = 96

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class ExtrudedAreaSolid3DList(Boost.Python.instance)
    
Method resolution order:
ExtrudedAreaSolid3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (ExtrudedAreaSolid3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (ExtrudedAreaSolid3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (ExtrudedAreaSolid3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (ExtrudedAreaSolid3DList)arg1) -> str
__setitem__(...)
__setitem__( (ExtrudedAreaSolid3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (ExtrudedAreaSolid3DList)arg1, (object)arg2) -> None
extend(...)
extend( (ExtrudedAreaSolid3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class FilletCalculus2D(Boost.Python.instance)
    Class for fillet calculation between two 2D objects
 
 
Method resolution order:
FilletCalculus2D
Boost.Python.instance
builtins.object

Methods defined here:
ClickedOnObject(...)
ClickedOnObject( (Line2D)line, (Point2D)clickedPoint, (float)searchRadius) -> bool :
    Check if click point is a point located on given line
    
    Parameter: line          Line2D which will be checked
               clickedPoint  clicked point
               searchRadius  search radius
    
    Return: true if point is on the line
 
ClickedOnObject( (Arc2D)arc, (Point2D)clickedPoint, (float)searchRadius) -> bool :
    Check if click point is a point located on given arc
    
    Parameter: arc           Arc2D which will be checked
               clickedPoint  clicked point
               searchRadius  search radius
    
    Return: true if point is on the arc
GetArcHelpConstructions(...)
GetArcHelpConstructions( (FilletCalculus2D)arg1) -> Arc2DList :
    Get all arc help constructions
    
    Return: all arc help constructions
GetFilletType(...)
GetFilletType( (Line2D)line1, (Line2D)line2) -> eFilletType :
    Get fillet type for two lines
    
    Parameter: line1  first line
               line2  second line
    
    Return: eFilletType
 
GetFilletType( (Line2D)line, (Arc2D)arc) -> eFilletType :
    Get fillet type for line and arc
    
    Parameter: line  line
               arc   arc
    
    Return: eFilletType
 
GetFilletType( (Arc2D)arc1, (Arc2D)arc2) -> eFilletType :
    Get fillet type for two arcs
    
    Parameter: arc1  first arc
               arc2  second arc
    
    Return: eFilletType
 
GetFilletType( (object)geometry1, (object)geometry2) -> eFilletType :
    Get fillet type for two geometry objects
    
    Parameter: geometry1  first geometry element
               geometry2  second geometry element
    
    Return: eFilletType
GetFillets(...)
GetFillets( (FilletCalculus2D)arg1) -> Arc2DList :
    Get all possible fillets
    
    Return: possible fillets
GetLineHelpConstructions(...)
GetLineHelpConstructions( (FilletCalculus2D)arg1) -> object :
    Get all line help constructions
    
    Return: all line help constructions
GetNearest(...)
GetNearest( (FilletCalculus2D)arg1, (Point2D)point) -> Arc2D :
    Get the nearest fillet to the point
    
    Parameter: point  Point2D
    
    Return: nearest arc to the point
SplitPolylineBySegment(...)
SplitPolylineBySegment( (Polyline2D)polyline, (int)segment) -> tuple :
    Split polyline by given segment
    
    Parameter: polyline  polyline which will be split by given segment
               segment   segment where polyline will be split
    
    Return: first part of polyline,
            second part of polyline
TrimByHelpConstruction(...)
TrimByHelpConstruction( (Line2D)line, (Line2D)hcLine, (Point3DList)intersections) -> Line2D :
    Trim line by given help construction
    
    Parameter: line           line which will be trimmed
               hcLine         line help construction
               intersections  intersection points
    
    Return: line which will be trimmed
 
TrimByHelpConstruction( (Polyline2D)polyline, (Line2D)segment, (Line2D)hcLine, (Point3DList)intersections) -> Polyline2D :
    Trim polyline by given help construction
    
    Parameter: polyline       polyline which will be trimmed
               segment        selected segment
               hcLine         line help construction
               intersections  intersection points
    
    Return: polyline which will be trimmed
 
TrimByHelpConstruction( (Arc2D)arc, (Arc2D)hcArc, (Point3DList)intersections) -> Arc2D :
    Trim arc by given help construction
    
    Parameter: arc            arc which will be trimmed
               hcArc          arc help construction
               intersections  intersection points
    
    Return: arc which will be trimmed
UpdateBySelectedHelpConstruction(...)
UpdateBySelectedHelpConstruction( (Line2D)line, (object)trimHelpConstruction, (Point2D)intersection) -> Line2D :
    Update line by selected help construction
    
    Parameter: line                  line which will be updated by help construction
               trimHelpConstruction  help construction data
               intersection          intersection
    
    Return: line which will be updated by help construction
 
UpdateBySelectedHelpConstruction( (Polyline2D)polyline, (Line2D)segment, (object)trimHelpConstruction, (Point2D)intersection) -> Polyline2D :
    Update polyline by selected help construction
    
    Parameter: polyline              polyline which will be updated
               segment               selected segment
               trimHelpConstruction  help construction data
               intersection          intersection
    
    Return: polyline which will be updated
UpdateGeometry(...)
UpdateGeometry( (Line2D)geoLine, (Arc2D)fillet, (object)selectedGeometry) -> Line2D :
    Update lien geometry
    
    Parameter: geoLine           line which will be updated
               fillet            Arc2D
               selectedGeometry  selected geometry
    
    Return: line which will be updated
 
UpdateGeometry( (Arc2D)geoArc, (Arc2D)fillet, (object)selectedGeometry) -> Arc2D :
    Update arc geometry
    
    Parameter: geoArc            arc which will be updated
               fillet            Arc2D
               selectedGeometry  selected geometry
    
    Return: arc which will be updated
 
UpdateGeometry( (Polyline2D)geoPolyline, (Arc2D)fillet, (object)selectedGeometry1, (object)selectedGeometry2) -> Polyline2DList :
    Update polyline geometry
    
    Parameter: geoPolyline        polyline which will be updated
               fillet             Arc2D
               selectedGeometry1  First selected segment
               selectedGeometry2  Second selected segment
    
    Return: Result polylines
 
UpdateGeometry( (Polyline2D)geoPolyline, (Arc2D)fillet, (object)selectedGeometry) -> Polyline2D :
    Update polyline geometry
    
    Parameter: geoPolyline       polyline which will be updated
               fillet            Arc2D
               selectedGeometry  selected geometry
    
    Return: polyline which will be updated
 
UpdateGeometry( (Polyline2D)geoPolyline, (Arc2D)fillet, (object)selectedGeometry1, (object)selectedGeometry2, (int)segmentCount) -> Polyline2D :
    Update polyline geometry
    
    Parameter: geoPolyline        polyline which will be updated
               fillet             Arc2D
               selectedGeometry1  the first selected geometry
               selectedGeometry2  the second selected geometry
               segmentCount       required count of segments of the polygonized fillet
    
    Return: polyline which will be updated
 
UpdateGeometry( (Polygon2D)geoPolygon, (Arc2D)fillet, (Line2D)segment1, (Line2D)segment2, (int)segmentCount) -> Polygon2D :
    Update polyline geometry
    
    Parameter: geoPolygon         polygon which will be updated
               fillet             Arc2D
               segment1           first selected geometry
               segment2           second selected geometry
               segmentCount       required count of segments of the polygonized fillet
    
    Return: geoPolygon which will be updated
 
UpdateGeometry( (Spline2D)geoSpline, (Arc2D)fillet) -> Spline2D :
    Update spline geometry
    
    Parameter:  geoSpline  spline which will be updated
                fillet     Arc2D
    
    Return: spline which will be updated
__init__(...)
__init__( (object)arg1, (object)geoObj1, (object)geoObj2, (float)r) -> None :
    constructor
    
    Parameter: geoObj1  IGeometry object
               geoObj2  IGeometry object
               r        radius
 
__init__( (object)arg1, (Line2D)line1, (Line2D)line2, (float)r) -> None :
    constructor
    
    Parameter: line1  Line2D
               line2  Line2D
               r      radius
 
__init__( (object)arg1, (Line2D)line, (Arc2D)arc, (float)r) -> None :
    constructor
    
    Parameter: line  Line2D
               arc   Arc2D
               r     radius
 
__init__( (object)arg1, (Arc2D)arc1, (Arc2D)arc2, (float)r) -> None :
    constructor
    
    Parameter: arc1  Arc2D
               arc2  Arc2D
               r     radius
 
__init__( (object)arg1, (Arc2D)arc, (Point2D)point) -> None :
    constructor
    
    Parameter: arc    Arc2D
               point  Point2D
 
__init__( (object)arg1, (Line2D)line, (Point2D)point) -> None :
    constructor
    
    Parameter: line   Line2D
               point  Point2D
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class FilletCalculus3D(Boost.Python.instance)
    Class for 3D fillet calculation
 
 
Method resolution order:
FilletCalculus3D
Boost.Python.instance
builtins.object

Methods defined here:
Calculate(...)
Calculate( (Line3D)arg1, (Line3D)arg2, (float)radius) -> tuple :
    Calculate fillet between two coplanar 3d lines
    
    Parameter: line1   first Line3D
               line2   second Line3D
               radius  radius of fillet
    
    Return: error code,
            resulting first Line3D
            resulting second Line3D
            calculated fillet
 
Calculate( (Line3D)line1, (Line3D)line2) -> tuple :
    Calculate fillet between two parallel non collinear 3d lines.
    The end point of the first line must lie on the same plane as start point of the second line and plane is perpendicular to both lines.
    
    Parameter: line1  first Line3D
               line2  second Line3D
    
    Return: error code,
            calculated fillet
 
Calculate( (Line3D)line1, (eLinePointIdentification)endPoint, (Polyline3D)polyline, (int)startLineIndex, (int)endLineIndex, (float)radius) -> tuple :
    Calculate fillet between line1 and line2. Line2 is created as line between end point of line1 
    (by parameter endPoint) and point from polyline (limited with startPointIndex and endPointIndex)
    
    Parameter: line1           Line 1 for fillet
               endPoint        Sign for line2 (from where point of line1 should be start line2)
               polyline        Polyline (buffer of end points for line2)
               startLineIndex  Start point index for polyline
               endLineIndex    End point index for polyline
               radius          radius of fillet
    
    Return: error code,
            Line 1 from fillet calculation,
            Line 2 from fillet calculation,
            Calculated fillet
 
Calculate( (Polyhedron3D)polyhedron, (VecSizeTList)edges, (float)radius, (bool)propagation) -> tuple :
    Calculate fillet on selected edges of given Polyhedron3D
    
    Parameter: polyhedron   polyhedron to fillet
               edges        edges to fillet
               radius       fillet sphere radius
               propagation  flag for propagation of neighboring edges
    
    Return:  error code,
             resulting BRep3D
 
Calculate( (BRep3D)brep, (float)radius) -> tuple :
    Calculate fillet on all edges of given BRep3D
    
    Parameter: brep    brep to fillet
               radius  fillet sphere radius
    
    Return:  error code,
             resulting brep
 
Calculate( (BRep3D)brep, (VecSizeTList)edges, (float)radius, (bool)propagation) -> tuple :
    Calculate fillet on selected edges of given BRep3D
    
    Parameter: brep         brep to fillet
               edges        edges to fillet
               radius       fillet sphere radius
               propagation  flag for propagation of neighboring edges
    
    Return:  error code,
             resulting brep
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class GeometryEdge(Boost.Python.instance)
    Geometry edge
Identification of any edge via point indices, not via point coordinates.
 
 
Method resolution order:
GeometryEdge
Boost.Python.instance
builtins.object

Methods defined here:
GetEndIndex(...)
GetEndIndex( (GeometryEdge)arg1) -> int :
    Get end index
    
    Return: End index.
GetStartIndex(...)
GetStartIndex( (GeometryEdge)arg1) -> int :
    Get start index
    
    Return: Start index.
Set(...)
Set( (GeometryEdge)arg1, (Kanten_t)edge) -> None :
    Initialize edge from old Allplan structure
    
    Parameter: edge  Edge which will be copied.
SetEndIndex(...)
SetEndIndex( (GeometryEdge)arg1, (int)index) -> None :
    Set end index
    
    Index is not checked, you set anything.
    
    Parameter: index  End index.
SetStartIndex(...)
SetStartIndex( (GeometryEdge)arg1, (int)index) -> None :
    Set start index
    
    Index is not checked, you set anything.
    
    Parameter: index  Start index.
__eq__(...)
__eq__( (GeometryEdge)arg1, (GeometryEdge)edge) -> object :
    Comparison of edges without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: edge  Compared edge.
    
    Return: True when edges are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (int)startIndex, (int)endIndex) -> None :
    Constructor
    
    Parameter: startIndex  Start index of vertex.
               endIndex    End index of vertex.
 
__init__( (object)arg1, (GeometryEdge)edge) -> None :
    Copy constructor
    
    Parameter: edge  Edge which will be copied.
 
__init__( (object)arg1, (Kanten_t)edge) -> None :
    Copy constructor from old Allplan structure
    
    Parameter: edge  Edge which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (GeometryEdge)arg1) -> str

Data descriptors defined here:
EndIndex
Get and set the end index property
StartIndex
Get and set the start index property

Data and other attributes defined here:
__instance_size__ = 32

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class GeometryEdgeList(Boost.Python.instance)
    
Method resolution order:
GeometryEdgeList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (GeometryEdgeList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (GeometryEdgeList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (GeometryEdgeList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (GeometryEdgeList)arg1) -> str
__setitem__(...)
__setitem__( (GeometryEdgeList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (GeometryEdgeList)arg1, (object)arg2) -> None
extend(...)
extend( (GeometryEdgeList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Kanten_t(Boost.Python.instance)
    old Allplan structur
anf/end begins with 1
 
 
Method resolution order:
Kanten_t
Boost.Python.instance
builtins.object

Methods defined here:
__init__(...)
__init__( (object)arg1) -> None
__reduce__ = (...)

Data descriptors defined here:
anf
end

Data and other attributes defined here:
__instance_size__ = 24

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Line2D(Boost.Python.instance)
    2D line
 
 
Method resolution order:
Line2D
Boost.Python.instance
builtins.object

Methods defined here:
EqualRef(...)
EqualRef( (Line2D)arg1, (Line2D)line) -> bool :
    Test for equal reference points
    
    Parameter: line  line for comparision
    
    Return: True if reference points are equal else return false.
Extend(...)
Extend( (Line2D)arg1, (float)delta) -> None :
    Extend the line
    
    Parameter: delta  size of extension
GetAngle(...)
GetAngle( (Line2D)arg1) -> Angle :
    Get angle of line
    
    Return:  Angle of the line
GetCenterPoint(...)
GetCenterPoint( (Line2D)arg1) -> Point2D :
    Get the center point in world coordinate system
    
    Return:  Center point in world coordinate system
GetCoords(...)
GetCoords( (Line2D)arg1) -> tuple :
    Get coordinates in world coordinate.
    
    Return: X coordinate of start point.,
            Y coordinate of start point.,
            X coordinate of end point.,
            Y coordinate of end point.
GetEndPoint(...)
GetEndPoint( (Line2D)arg1) -> Point2D :
    Get the end point in world coordinate system
    
    Return: point.
GetEndRelPoint(...)
GetEndRelPoint( (Line2D)arg1) -> Point2D :
    Get the end point in relative coordinate system.
    
    Return: constant reference to point.
GetRefPoint(...)
GetRefPoint( (Line2D)arg1) -> Point2D :
    Get the reference point.
    
    Return: constant reference to point.
GetStartPoint(...)
GetStartPoint( (Line2D)arg1) -> Point2D :
    Get the start point in world coordinate system.
    
    Return: point.
GetStartRelPoint(...)
GetStartRelPoint( (Line2D)arg1) -> Point2D :
    Get the start point in relative coordinate system
    
    Return: constant reference to point.
GetVector(...)
GetVector( (Line2D)arg1) -> Vector2D :
    Get the vector.
    
    Return: vector.
IsPoint(...)
IsPoint( (Line2D)arg1) -> bool :
    Check, whether the line is a point (start point equal end point)
    
    Return:  Line is a point: true/false
Reverse(...)
Reverse( (Line2D)arg1) -> None :
    Reverse orientation of the line
Set(...)
Set( (Line2D)arg1, (Line2D)line) -> None :
    Initialize line from line.
    
    Parameter: line  Line2D.
 
Set( (Line2D)arg1, (float)x1, (float)y1, (float)x2, (float)y2) -> None :
    Set line points in world coordinate system.
    
    Parameter: x1  X coordinate of start point.
               y1  Y coordinate of start point.
               x2  X coordinate of end point.
               y2  Y coordinate of end point.
 
Set( (Line2D)arg1, (Point2D)point1, (Point2D)point2) -> None :
    Set line points in world coordinate system.
    
    Set line from two points. 
    
    Parameter: point1  Point2D start point of line.
               point2  Point2D end point of line.
 
Set( (Line2D)arg1, (Point2D)refPoint, (Point2D)point1, (Point2D)point2) -> None :
    Set line points.
    
    Used local coordinate system for point1 and point2.
    refPoint used global coordinate system.
    
    Parameter: refPoint  refPoint reference point of line.
               point1    Point2D start point of line.
               point2    Point2D end point of line.
SetEndPoint(...)
SetEndPoint( (Line2D)arg1, (Point2D)endPoint) -> None :
    Set end point in world coordinate system.
    
    Parameter: endPoint  New start point.
SetEndRelPoint(...)
SetEndRelPoint( (Line2D)arg1, (Point2D)endPoint) -> None :
    Set end point in local coordinate system.
    
    Parameter: endPoint  New start point.
SetRefPoint(...)
SetRefPoint( (Line2D)arg1, (Point2D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Coordinates of points will be recalculated with new reference point.
    Formula: m_Points[i] = m_RefPoint + m_Points[i] - refPoint
    
    Parameter: refPoint  new reference point.
SetStartPoint(...)
SetStartPoint( (Line2D)arg1, (Point2D)startPoint) -> None :
    Set start point in world coordinate system.
    
    Parameter: startPoint  New start point.
SetStartRelPoint(...)
SetStartRelPoint( (Line2D)arg1, (Point2D)startPoint) -> None :
    Set start point in local coordinate system.
    
    Parameter: startPoint  New start point.
TrimEnd(...)
TrimEnd( (Line2D)arg1, (float)ds) -> None :
    Trim line at the end
    
    Start                         End
    Point                         Point
      o-----------------------------o
                            <-------+
                              ds > 0
    Result:
      o--------------------o
    
    Parameter: ds  dimension value the line is modifiedA value >0 shortens the line
                   A value <0 extend the line
                   If the line is shorten larger than its actual length a exception is thrown
TrimStart(...)
TrimStart( (Line2D)arg1, (float)ds) -> None :
    Trim line at the start
    
    Start                         End
    Point                         Point
      o-----------------------------o
      +------->
       ds > 0
    
    Result:
               o--------------------o
    
    Parameter: ds  dimension value the line is modifiedA value >0 shortens the line
                   A value <0 extend the line
                   If the line is shorten larger than its actual length a exception is thrown
__eq__(...)
__eq__( (Line2D)arg1, (Line2D)line) -> object :
    Comparison of lines without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: line  Compared line.
    
    Return: True when lines are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Line2D)line) -> None :
    Copy constructor.
    
    Parameter: line  Line which will be copied.
 
__init__( (object)arg1, (Line3D)line3D) -> None :
    Copy constructor to convert a 3D line
    
    Parameter: line3D  3D line
 
__init__( (object)arg1, (Point2D)point1, (Point2D)point2) -> None :
    Constructor.
    
    Initialize line from two points
    
    Parameter: point1  Point2D start point of line.
               point2  Point2D end point of line.
 
__init__( (object)arg1, (Point2D)startPoint, (Vector2D)vec) -> None :
    Constructor.
    
    Initialize line from point and relative vector to point.
    
    Parameter: startPoint  Point2D start point of line.
               vec         Vector2D vector of end point relative to the point1.
 
__init__( (object)arg1, (float)x1, (float)y1, (float)x2, (float)y2) -> None :
    Constructor.
    
    Parameter: x1  X coordinate of start point.
               y1  Y coordinate of start point.
               x2  X coordinate of end point.
               y2  Y coordinate of end point.
 
__init__( (object)arg1, (Point2D)refPoint, (Point2D)point1, (Point2D)point2) -> None :
    Constructor.
    
    Used local coordinate system for point1 and point2.
    refPoint used global coordinate system.
    
    Parameter: refPoint  reference point of line.
               point1    start point of line.
               point2    end point of line.
__mul__(...)
__mul__( (Line2D)arg1, (Matrix2D)matrix) -> object :
    Matrix transformation.
    
    Parameter: matrix  transformation matrix.
    
    Return: Line2D transformed line.
__reduce__ = (...)
__repr__(...)
__repr__( (Line2D)arg1) -> str

Data descriptors defined here:
EndPoint
Get and set the end point as property
EndRelPoint
Get and set the end point in local coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Set and get the start point in local coordinate system as property

Data and other attributes defined here:
__instance_size__ = 64

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Line2DList(Boost.Python.instance)
    
Method resolution order:
Line2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Line2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Line2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Line2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Line2DList)arg1) -> str
__setitem__(...)
__setitem__( (Line2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Line2DList)arg1, (object)arg2) -> None
extend(...)
extend( (Line2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Line3D(Boost.Python.instance)
    3D line
 
 
Method resolution order:
Line3D
Boost.Python.instance
builtins.object

Methods defined here:
EqualRef(...)
EqualRef( (Line3D)arg1, (Line3D)line) -> bool :
    Test if reference points are equal.
    
    Parameter: line  line for comparision
    
    Return: bool
GetCenterPoint(...)
GetCenterPoint( (Line3D)arg1) -> Point3D :
    Get the center point in world coordinate system
    
    Return:  Center point
GetCoords(...)
GetCoords( (Line3D)arg1) -> tuple :
    Get the coordinates.
    
    Get the coordinates in world coordinate system.
    
    Return: X coordinate of start point.,
            Y coordinate of start point.,
            Z coordinate of start point.,
            X coordinate of end point.,
            Y coordinate of end point.,
            Z coordinate of end point.
GetEndPoint(...)
GetEndPoint( (Line3D)arg1) -> Point3D :
    Get the end point.
    
    Get the end point in world coordinate system.
    
    Return: Point3D.
GetEndRelPoint(...)
GetEndRelPoint( (Line3D)arg1) -> Point3D :
    Get the end point.
    
    Get the end point in relative coordinate system.
    
    Return: Point3D.
GetRefPoint(...)
GetRefPoint( (Line3D)arg1) -> Point3D :
    Get the reference point
    
    Return: Point3D.
GetStartPoint(...)
GetStartPoint( (Line3D)arg1) -> Point3D :
    Get the start point.
    
    Get the start point in world coordinate system.
    
    Return: Point3D
GetStartRelPoint(...)
GetStartRelPoint( (Line3D)arg1) -> Point3D :
    Get the start point.
    
    Get the start point in relative coordinate system.
    
    Return: Point3D.
GetVector(...)
GetVector( (Line3D)arg1) -> Vector3D :
    Get the vector from start to end point.
    
    Return: Vector3D.
Is2DLine(...)
Is2DLine( (Line3D)arg1) -> bool :
    Check, whether the line is a 2D line (both y coordinates are 0.)
    
    Return:  Line is a 2D line: true/false
IsPoint(...)
IsPoint( (Line3D)arg1) -> bool :
    Check, whether the line is a point (start point equal end point)
    
    Return:  Line is a point: true/false
Reverse(...)
Reverse( (Line3D)arg1) -> None :
    Reverse orientation of the Line
Set(...)
Set( (Line3D)arg1, (float)x1, (float)y1, (float)z1, (float)x2, (float)y2, (float)z2) -> None :
    Initialize from 6 doubles
    
    Set line points in world coordinate system
    
    Parameter: x1  X coordinate of start point
               y1  Y coordinate of start point
               z1  Z coordinate of start point
               x2  X coordinate of end point
               y2  Y coordinate of end point
               z2  Z coordinate of end point
 
Set( (Line3D)arg1, (Line3D)line) -> None :
    Initialize line from line.
    
    Parameter: line  Line3D.
 
Set( (Line3D)arg1, (Point3D)startPoint, (Point3D)endPoint) -> None :
    Initialize from two points.
    
    Set line points in world coordinate system.
    
    Parameter: startPoint  start point.
               endPoint    end point.
 
Set( (Line3D)arg1, (Point3D)refPoint, (Point3D)startPoint, (Point3D)endPoint) -> None :
    Initialize from 3 points.
    
    Set line points in local coordinate system.
    
    Parameter: refPoint    Reference point.
               startPoint  relative start point.
               endPoint    relative end point.
SetEndPoint(...)
SetEndPoint( (Line3D)arg1, (Point3D)endPoint) -> None :
    Set end point
    
    Set end point in world coordinate system.
    
    Parameter: endPoint  End point.
SetEndRelPoint(...)
SetEndRelPoint( (Line3D)arg1, (Point3D)endPoint) -> None :
    Set end point
    
    Set end point in Local coordinate system.
    
    Parameter: endPoint  End point.
SetRefPoint(...)
SetRefPoint( (Line3D)arg1, (Point3D)refPoint) -> None :
    Set the reference point.
    
    Parameter: refPoint  Reference point.
SetStartPoint(...)
SetStartPoint( (Line3D)arg1, (Point3D)startPoint) -> None :
    Set start point
    
    Set start point in world coordinate system.
    
    Parameter: startPoint  Start point.
SetStartRelPoint(...)
SetStartRelPoint( (Line3D)arg1, (Point3D)startPoint) -> None :
    Set start point
    
    Set start point in Local coordinate system.
    
    Parameter: startPoint  Start point.
TrimEnd(...)
TrimEnd( (Line3D)arg1, (float)ds) -> None :
    Trim line at the end
    
    Parameter: ds  dimension value the line is modified
                   A value >0 shortens the line
                   A value <0 extend the line
                   If the line is shorten larger than its actual length a exception is thrown
TrimStart(...)
TrimStart( (Line3D)arg1, (float)ds) -> None :
    Trim line at the start
    
    Parameter: ds  dimension value the line is modified
                   A value >0 shortens the line
                   A value <0 extend the line
                   If the line is shorten larger than its actual length a exception is thrown
__eq__(...)
__eq__( (Line3D)arg1, (Line3D)line) -> object :
    Comparison of lines without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: line  Compared line.
    
    Return: True when lines are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Line2D)line2D) -> None :
    Copy constructor.
    
    Copy Line2D to Line3D at z=0.0
    
    Parameter: line2D  Line2D which will be copied.
    
 
__init__( (object)arg1, (Line3D)line) -> None :
    Copy constructor.
    
    Copy Line3D
    
    Parameter: line  Line3D which will be copied.
    
 
__init__( (object)arg1, (Point3D)point1, (Point3D)point2) -> None :
    Constructor.
    
    Constructs a Line3D from point1 to point2 in world coordinates.
    
    Parameter: point1  start point of line.
               point2  end point of line.
 
__init__( (object)arg1, (Point3D)startPoint, (Vector3D)vec) -> None :
    Constructor.
    
    Constructs a Line3D from point1 to point1+vec in world coordinates.
    
    Parameter: startPoint  start point of line.
               vec         translation vector.
 
__init__( (object)arg1, (float)x1, (float)y1, (float)z1, (float)x2, (float)y2, (float)z2) -> None :
    Constructor.
    
    Constructs a Line3D from 6 doubles in world coordinates.
    
    Parameter: x1  X coordinate of start point.
               y1  Y coordinate of start point.
               z1  Z coordinate of start point.
               x2  X coordinate of end point.
               y2  Y coordinate of end point.
               z2  Z coordinate of end point.
 
__init__( (object)arg1, (Point3D)refPoint, (Point3D)startPoint, (Point3D)endPoint) -> None :
    Constructor.
    
    Constructs a Line3D in local coordinate system.
    
    Parameter: refPoint    Reference point.
               startPoint  relative start point.
               endPoint    relative end point.
__mul__(...)
__mul__( (Line3D)arg1, (Matrix2D)matrix) -> object :
    2D matrix transformation.
    
    Multiplies line start and end point with matrix.
    
    Parameter: matrix  2D transformation Matrix
    
    Return: Line3D.
 
__mul__( (Line3D)arg1, (Matrix3D)matrix) -> object :
    3D matrix transformation.
    
    Multiplies line start and end point with matrix.
    
    Parameter: matrix  3D transformation Matrix
    
    Return: Line3D.
__reduce__ = (...)
__repr__(...)
__repr__( (Line3D)arg1) -> str

Data descriptors defined here:
EndPoint
Get and set the end point as property
EndRelPoint
Get and set the end point in local coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Set and get the start point in local coordinate system as property

Data and other attributes defined here:
__instance_size__ = 88

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Line3DList(Boost.Python.instance)
    
Method resolution order:
Line3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Line3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Line3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Line3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Line3DList)arg1) -> str
__setitem__(...)
__setitem__( (Line3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Line3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Line3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Matrix2D(Boost.Python.instance)
    2D matrix
 
Matrix data organization in memory:
[0..8] indexes of array values
0,1,  3,4 - rotation, scaling and shrinking
6,7 - translation
 
0, 1, 2,  
3, 4, 5,  
6, 7, 8   
 
All operations are correct only in geometry calculation context and can not be used for calculating with regular 4x4 matrix.
 
 
Method resolution order:
Matrix2D
Boost.Python.instance
builtins.object

Methods defined here:
AddDimension(...)
AddDimension( (Matrix2D)arg1) -> Matrix3D :
    Create a 3D matrix from this 2D matrix
    
    Return: 3D Matrix from this matrix
Determinant(...)
Determinant( (Matrix2D)arg1) -> float :
    Calculate determinant
    
    Return: Determinant.
IsIdentity(...)
IsIdentity( (Matrix2D)arg1) -> bool :
    Check to identity matrix
    
    Return: Return true when is matrix identity, otherwise false.
Multiply(...)
Multiply( (Matrix2D)arg1, (Matrix2D)matrix) -> Matrix2D :
    Multiple matrix with given matrix
    
    calling  A.Multiply(B)  is identical with  A *= B 
    
    Parameter: matrix  Matrix to be multiple with
    
    Return: Product of matrices
Reflection(...)
Reflection( (Matrix2D)arg1, (Axis2D)axis) -> None :
    Reflection across a axis of given angle
    
    Parameter: axis  Reflection axis
Reverse(...)
Reverse( (Matrix2D)arg1) -> bool :
    Reverse matrix
    
    This method provide geometrical inverse matrix and
     can not be used with regular inverse 4x4 matrix calculations.
    
    Geometrical representation: Point3D = { Point3D * Matrix } * Matrix.Reverse()
    
    Return: True when operation is successful, otherwise false.
Rotation(...)
Rotation( (Matrix2D)arg1, (Point2D)point, (Angle)angle) -> None :
    Rotate the matrix
    
    Parameter: point  Point of rotation
               angle  Angle of rotation.
Scaling(...)
Scaling( (Matrix2D)arg1, (float)scaleX, (float)scaleY) -> None :
    Scale the matrix
    
    Parameter: scaleX  Scale in X axis.
               scaleY  Scale in Y axis.
SetIdentity(...)
SetIdentity( (Matrix2D)arg1) -> None :
    Initialize identity matrix
SetReflection(...)
SetReflection( (Matrix2D)arg1, (Axis2D)axis) -> None :
    Initialize matrix only with reflection
    
    Parameter: axis  Reflection axis
SetRotation(...)
SetRotation( (Matrix2D)arg1, (Point2D)point, (Angle)angle) -> None :
    Initialize matrix only with rotation
    
    Parameter: point  Point of rotation.
               angle  Angle of rotation.
SetScaling(...)
SetScaling( (Matrix2D)arg1, (float)scaleX, (float)scaleY) -> None :
    Initialize matrix only with scaling factors
    
    Parameter: scaleX  Scale in X axis.
               scaleY  Scale in Y axis.
SetTranslation(...)
SetTranslation( (Matrix2D)arg1, (Vector2D)vec) -> None :
    Initialize matrix only with translation
    
    Parameter: vec  Vector of translation.
SetValue(...)
SetValue( (Matrix2D)arg1, (int)index, (float)value) -> bool :
    Set the matrix element at a specified position
    
    Use this method when you don't want to catch exception by operator[].
    
    Parameter: index  Position index <0..9>
               value  Value for set
    
    Return: True when operation successful (index is not out of range), otherwise false.
Translate(...)
Translate( (Matrix2D)arg1, (Vector2D)vec) -> None :
    Translate the matrix
    
    Parameter: vec  Vector of translation.
__add__(...)
__add__( (Matrix2D)arg1, (Matrix2D)matrix) -> object :
    Matrix addition
    
    Formula: Result(new matrix) = A+B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices
__getitem__(...)
__getitem__( (Matrix2D)arg1, (int)index) -> float :
    Get the matrix element at a specified position
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  Position index <0..9>
    
    Return: Returns a reference to the matrix element at a specified position.
__iadd__(...)
__iadd__( (object)arg1, (Matrix2D)matrix) -> object :
    Matrix addition
    
    Formula: A += B  or A = A+B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices
__imul__(...)
__imul__( (object)arg1, (Matrix2D)matrix) -> object :
    Matrix multiplication
    
    Formula: A *= B  or A = A*B
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Product of matrices
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Matrix2D)matrix) -> None :
    Copy constructor
    
    Parameter: matrix  Matrix which will be copied.
__isub__(...)
__isub__( (object)arg1, (Matrix2D)matrix) -> object :
    Matrix addition
    
    Formula: A -= B  or A = A-B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices
__mul__(...)
__mul__( (Matrix2D)arg1, (Matrix2D)matrix) -> object :
    Matrix multiplication
    
    Formula: Result(new matrix) = A*B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Product of matrices
__reduce__ = (...)
__repr__(...)
__repr__( (Matrix2D)arg1) -> str
__sub__(...)
__sub__( (Matrix2D)arg1, (Matrix2D)matrix) -> object :
    Matrix addition
    
    Formula: Result(new matrix) = A-B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices

Data and other attributes defined here:
__instance_size__ = 88

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Matrix3D(Boost.Python.instance)
    3D matrix,
 
Matrix data organization in memory:
[0..15] indexes of array values
0,1,2,  4,5,6,  8,9,10 - rotation, scaling and shrinking
12,13,14 - translation
 
0, 1, 2, 3   
4, 5, 6, 7   
8, 9, 10,11  
12,13,14,15  
 
All operations are correct only in geometry calculation context and can not be used for calculating with regular 4x4 matrix.
 
 
Method resolution order:
Matrix3D
Boost.Python.instance
builtins.object

Methods defined here:
Determinant(...)
Determinant( (Matrix3D)arg1) -> float :
    Calculate determinant
    
    Return: Determinant.
GaussInvert(...)
GaussInvert( (Matrix3D)arg1) -> bool :
    Inverse matrix by Gauss
    
    Return: True when operation is successful, otherwise false.
GetScaleX(...)
GetScaleX( (Matrix3D)arg1) -> float :
    Get scale X
    
    Return:  scale X
GetScaleY(...)
GetScaleY( (Matrix3D)arg1) -> float :
    Get scale Y
    
    Return:  scale Y
GetScaleZ(...)
GetScaleZ( (Matrix3D)arg1) -> float :
    Get scale Z
    
    Return:  scale Z
GetScaling(...)
GetScaling( (Matrix3D)arg1) -> tuple :
    Calculates the scaling factors from the matrix
    
    Return: Scale in X axis.,
            Scale in Y axis.,
            Scale in Z axis.
GetTranslationVector(...)
GetTranslationVector( (Matrix3D)arg1) -> Vector3D :
    Get translation part of a matrix
    
    Return: The vector of translation
GetVectorX(...)
GetVectorX( (Matrix3D)arg1) -> Vector3D :
    Get vector X
    
    Return:  Vector X
GetVectorY(...)
GetVectorY( (Matrix3D)arg1) -> Vector3D :
    Get vector Y
    
    Return:  Vector Y
GetVectorZ(...)
GetVectorZ( (Matrix3D)arg1) -> Vector3D :
    Get vector Z
    
    Return:  Vector Z
IsIdentity(...)
IsIdentity( (Matrix3D)arg1) -> bool :
    Check to identity matrix
    
    Return: Return true when is matrix identity, otherwise false.
LaplaceTransform(...)
LaplaceTransform( (Matrix3D)arg1) -> None :
    Transformation matrix by Laplace
Multiply(...)
Multiply( (Matrix3D)arg1, (Matrix3D)matrix) -> Matrix3D :
    Matrix multiplication
    
    Formula: A *= B  or A = A*B
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Product of matrices
ReduceZDimension(...)
ReduceZDimension( (Matrix3D)arg1) -> Matrix2D :
    Create a 2D matrix from this 3D matrix
    
    Return: a 2D matrix from this 3D matrix
Reflection(...)
Reflection( (Matrix3D)arg1, (Plane3D)plane) -> None :
    Reflection across a plane
    
    Parameter: plane  Reflection plane
Reverse(...)
Reverse( (Matrix3D)arg1) -> bool :
    Reverse matrix
    
    This method provide geometrical inverse matrix and
     can not be used with regular inverse 4x4 matrix calculations.
    
    Geometrical representation: Point3D = { Point3D * Matrix } * Matrix.Reverse()
    
    Return: True when operation is successful, otherwise false.
Rotation(...)
Rotation( (Matrix3D)arg1, (Line3D)line, (Angle)angle) -> bool :
    Rotate the matrix
    
    Rotate current matrix, not created new one.
    
    Parameter: line   Axis of rotation.
               angle  Angle of rotation.
    
    Return: True when successful, otherwise false.
Scaling(...)
Scaling( (Matrix3D)arg1, (float)scaleX, (float)scaleY, (float)scaleZ) -> None :
    Scale the matrix
    
    Scale current matrix, not created new one.
    
    Parameter: scaleX  Scale in X axis.
               scaleY  Scale in Y axis.
               scaleZ  Scale in Z axis.
SetIdentity(...)
SetIdentity( (Matrix3D)arg1) -> None :
    Initialize identity matrix
SetProjection(...)
SetProjection( (Matrix3D)arg1, (eProjectionMatrixType)proj) -> None :
    Create a matrix for the required projection
    
    Method throw THROW_GEO_EXCEPTION_INCORRECT_PARAMETERS_ geometry exception in case of invalid  proj.
    
    Parameter: proj  The required projection
SetReflection(...)
SetReflection( (Matrix3D)arg1, (Plane3D)plane) -> None :
    Initialize matrix only with reflection
    
    Parameter: plane  Reflection plane
SetRotation(...)
SetRotation( (Matrix3D)arg1, (Line3D)axis, (Angle)angle) -> bool :
    Initialize matrix only with rotation
    
    Parameter: axis   Axis of rotation.
               angle  Angle of rotation.
    
    Return: True when successful, otherwise false.
SetScaling(...)
SetScaling( (Matrix3D)arg1, (float)scaleX, (float)scaleY, (float)scaleZ) -> None :
    Initialize matrix only with scaling factors
    
    Parameter: scaleX  Scale in X axis.
               scaleY  Scale in Y axis.
               scaleZ  Scale in Z axis.
SetTranslation(...)
SetTranslation( (Matrix3D)arg1, (Vector3D)vec) -> None :
    Initialize matrix only with translation
    
    Parameter: vec  Vector of translation.
SetValue(...)
SetValue( (Matrix3D)arg1, (int)index, (float)value) -> bool :
    Set the matrix element at a specified position
    
    Use this method when you don't want to catch exception by operator[].
    
    Parameter: index  Position index <0..15>
               value  Value for set
    
    Return: True when operation successful (index is not out of range), otherwise false.
SetValues(...)
SetValues( (Matrix3D)arg1, (float)v00, (float)v01, (float)v02, (float)v03, (float)v10, (float)v11, (float)v12, (float)v13, (float)v20, (float)v21, (float)v22, (float)v23, (float)v30, (float)v31, (float)v32, (float)v33) -> None :
    Sets explicit each matrix-element
    
    Parameter: v00  first row, first element
               v01  first row, second element
               v02  first row, third element
               v03  first row, fourth element
               v10  second row, first element
               v11  second row, second element
               v12  second row, third element
               v13  second row, fourth element
               v20  third row, first element
               v21  third row, second element
               v22  third row, third element
               v23  third row, fourth element
               v30  fourth row, first element
               v31  fourth row, second element
               v32  fourth row, third element
               v33  fourth row, fourth element
Translate(...)
Translate( (Matrix3D)arg1, (Vector3D)vec) -> None :
    Translate the matrix
    
    Parameter: vec  Vector of translation.
Transpose(...)
Transpose( (Matrix3D)arg1) -> None :
    Transpose matrix
    
    All transform-services multiply transformation-matrix from the right side:
    If you need the result as it would be multiplication from the left side you
    need the transposed Matrix
    
    [x,y,z,1.0] x /  0, 1, 2, 3 \         /  0, 1, 2, 3 \      / x \
                  |  4, 5, 6, 7 |         |  4, 5, 6, 7 |  x   | y |
                  |  8, 9,10,11 |         |  8, 9,10,11 |      | z |
                  \ 12,13,14,15 /         \ 12,13,14,15 /      \1.0/
        moving-part: 12,13,14              moving-part: 3, 7, 11
__add__(...)
__add__( (Matrix3D)arg1, (Matrix3D)matrix) -> object :
    Matrix addition
    
    Formula: Result(new matrix) = A+B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices
__eq__(...)
__eq__( (Matrix3D)arg1, (Matrix3D)mat) -> object :
    Comparison of matrices without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: arc  Compared arc.
    
    Return: True when matrices are equal, otherwise false.
__getitem__(...)
__getitem__( (Matrix3D)arg1, (int)index) -> float :
    Get the matrix element at a specified position
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  Position index <0..9>
    
    Return: Returns a reference to the matrix element at a specified position.
__iadd__(...)
__iadd__( (object)arg1, (Matrix3D)matrix) -> object :
    Matrix addition
    
    Formula: A += B  or A = A+B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices
__imul__(...)
__imul__( (object)arg1, (Matrix3D)matrix) -> object :
    Matrix multiplication
    
    Formula: A *= B  or A = A*B. 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Product of matrices
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (eProjectionMatrixType)proj) -> None :
    Constructor
    
    Create a matrix for the required projection.
    
    Parameter: proj  The required projection
 
__init__( (object)arg1, (Matrix3D)matrix) -> None :
    Copy constructor
    
    Parameter: matrix  Matrix which will be copied.
 
__init__( (object)arg1, (float)v00, (float)v01, (float)v02, (float)v03, (float)v10, (float)v11, (float)v12, (float)v13, (float)v20, (float)v21, (float)v22, (float)v23, (float)v30, (float)v31, (float)v32, (float)v33) -> None :
    Constructor setting explicit each matrix-element
    
    Parameter: v00  first row, first element
               v01  first row, second element
               v02  first row, third element
               v03  first row, fourth element
               v10  second row, first element
               v11  second row, second element
               v12  second row, third element
               v13  second row, fourth element
               v20  third row, first element
               v21  third row, second element
               v22  third row, third element
               v23  third row, fourth element
               v30  fourth row, first element
               v31  fourth row, second element
               v32  fourth row, third element
               v33  fourth row, fourth element
 
__init__( (object)arg1, (list)valuesinrows) -> object :
    Constructor
    
    Parameter: valuesinrows  matrix values by rows as Python list
__isub__(...)
__isub__( (object)arg1, (Matrix3D)matrix) -> object :
    Matrix addition
    
    Formula: A -= B  or A = A-B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices
__mul__(...)
__mul__( (Matrix3D)arg1, (Matrix3D)matrix) -> object :
    Matrix multiplication
    
    Formula: Result(new matrix) = A*B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Product of matrices
__reduce__ = (...)
__repr__(...)
__repr__( (Matrix3D)arg1) -> str
__sub__(...)
__sub__( (Matrix3D)arg1, (Matrix3D)matrix) -> object :
    Matrix addition
    
    Formula: Result(new matrix) = A-B 
    A is this matrix.
    
    Parameter: matrix  B matrix
    
    Return: Addition of matrices

Data and other attributes defined here:
__instance_size__ = 144
__safe_for_unpickling__ = True

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class MinMax2D(Boost.Python.instance)
    
Method resolution order:
MinMax2D
Boost.Python.instance
builtins.object

Methods defined here:
Deflate(...)
Deflate( (MinMax2D)arg1, (float)arg2) -> None :
    Deflate in x,y,z axis concurrently.
    Parameter: size  Size
    
 
Deflate( (MinMax2D)arg1, (float)arg2, (float)arg3) -> None :
    Deflate in  x and  y axis.
    Parameter: x  x factor
               y  y factor
Get(...)
Get( (MinMax2D)arg1) -> tuple :
    Get minimum and maximum point
    
    Return: minimum point,
            maximum point
GetCenter(...)
GetCenter( (MinMax2D)arg1) -> Point2D :
    Get box center point
    
    Return: center point
GetMax(...)
GetMax( (MinMax2D)arg1) -> Point2D :
    Get maximum point
    
    Return: maximum point
GetMin(...)
GetMin( (MinMax2D)arg1) -> Point2D :
    Get minimum point
    
    Return: minimum point
GetSizeX(...)
GetSizeX( (MinMax2D)arg1) -> float :
    Get the size of the box in the X direction
    
    Return: delta X value
GetSizeY(...)
GetSizeY( (MinMax2D)arg1) -> float :
    Get the size of the box in the Y direction
    
    Return: delta Y value
Inflate(...)
Inflate( (MinMax2D)arg1, (float)arg2, (float)arg3) -> None :
    Inflate and deflate minmax box
    
    Parameter: x  x factor
               y  y factor
    
    Inflate in x and y axis.
 
Inflate( (MinMax2D)arg1, (float)arg2) -> None :
    Inflate in x,y,z axis concurrently.
    Parameter: size  Size
IsContaining(...)
IsContaining( (MinMax2D)arg1, (MinMax2D)box) -> bool :
    Is box inside this box
    
    Parameter: box  Potentially contained box
    
    Return: true, if is inside, otherwise false
IsValid(...)
IsValid( (MinMax2D)arg1) -> bool :
    Test if box is valid
    
    Return: true, if box valid, otherwise false
Overlaps(...)
Overlaps( (MinMax2D)arg1, (MinMax2D)box) -> bool :
    Does box overlap this box
    
    Parameter: box  Box
    
    Return: true, if boxes overlap, otherwise false
Set(...)
Set( (MinMax2D)arg1, (Point2D)min, (Point2D)max) -> None :
    Set minimum and maximum point
    
    Parameter: min  minimum point
               max  maximum point
SetMax(...)
SetMax( (MinMax2D)arg1, (Point2D)max) -> None :
    Set maximum point
    
    Parameter: max  maximum point
SetMin(...)
SetMin( (MinMax2D)arg1, (Point2D)min) -> None :
    Set minimum point
    
    Parameter: min  minimum point
__add__(...)
__add__( (MinMax2D)arg1, (MinMax2D)minmax) -> object :
    Expand MinMax2D box.
    
    Expands the MinMax2D box by the box given in parameter minmax
    
    Parameter: minmax  MinMax2D to be added
    
    Return: minmax box.
__eq__(...)
__eq__( (MinMax2D)arg1, (MinMax2D)minmax) -> object :
    Comparison of minmax objects without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: minmax  Compared minmax.
    
    Return: True when minmax objects are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (MinMax2D)minmax) -> object :
    Expand MinMax2D box.
    
    Expands the MinMax2D box by the box given in parameter minmax
    
    Parameter: minmax  MinMax2D to be added
    
    Return: reference to minmax box.
 
__iadd__( (object)arg1, (Point2D)point) -> object :
    Expand MinMax2D box.
    
    Parameter: point  Point2D to be added
    
    Return: reference to minmax box.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point2D)min, (Point2D)max) -> None :
    Set constructor
    
    Initialize MinMax box with given MIN and MAX points.
    
    Parameter: min  minimum point
               max  maximum point
 
__init__( (object)arg1, (Point2D)point) -> None :
    Set constructor
    
    Initialize MinMax box with given point.
    
    Parameter: point  
 
__init__( (object)arg1, (MinMax2D)minmax) -> None :
    Copy constructor.
    
    Parameter: minmax  MinMax2D to be copied
__reduce__ = (...)
__repr__(...)
__repr__( (MinMax2D)arg1) -> str

Data descriptors defined here:
Max
Get the maximal point as property
Min
Get the minimal point as property
SizeX
Get the size in x direction as property
SizeY
Get the size in y direction as property

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class MinMax2DList(Boost.Python.instance)
    
Method resolution order:
MinMax2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (MinMax2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (MinMax2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (MinMax2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (MinMax2DList)arg1) -> str
__setitem__(...)
__setitem__( (MinMax2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (MinMax2DList)arg1, (object)arg2) -> None
extend(...)
extend( (MinMax2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class MinMax3D(Boost.Python.instance)
    
Method resolution order:
MinMax3D
Boost.Python.instance
builtins.object

Methods defined here:
Deflate(...)
Deflate( (MinMax3D)arg1, (float)arg2) -> None :
    Deflate in x,y,z axis concurrently.
    Parameter: size  Size
    
 
Deflate( (MinMax3D)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :
    Deflate in  x,  y and  z axis.
    Parameter: x  x factor
               y  y factor
               z  z factor
Get(...)
Get( (MinMax3D)arg1) -> tuple :
    Get minimum and maximum point
    
    Return: minimum point,
            maximum point
GetCenter(...)
GetCenter( (MinMax3D)arg1) -> Point3D :
    Get box center point
    
    Return: center point
GetMax(...)
GetMax( (MinMax3D)arg1) -> Point3D :
    Get maximum point
    
    Return: maximum point
GetMin(...)
GetMin( (MinMax3D)arg1) -> Point3D :
    Get minimum point
    
    Return: minimum point
GetSizeX(...)
GetSizeX( (MinMax3D)arg1) -> float :
    Get the size of the box in the X direction
    
    Return: delta X value
GetSizeY(...)
GetSizeY( (MinMax3D)arg1) -> float :
    Get the size of the box in the Y direction
    
    Return: delta Y value
GetSizeZ(...)
GetSizeZ( (MinMax3D)arg1) -> float :
    Get the size of the box in the Y direction
    
    Return: delta Y value
Inflate(...)
Inflate( (MinMax3D)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :
    Inflate and deflate minmax box
    
    Parameter: x  x factor
               y  y factor
               z  z factor
    
    Inflate in x, y and z axis.
 
Inflate( (MinMax3D)arg1, (float)arg2) -> None :
    Inflate in x,y,z axis concurrently.
    Parameter: size  Size
IsContaining(...)
IsContaining( (MinMax3D)arg1, (MinMax3D)box) -> bool :
    Is box inside this box
    
    Parameter: box  Potentially contained box
    
    Return: true, if is inside, otherwise false
IsValid(...)
IsValid( (MinMax3D)arg1) -> bool :
    Test if box is valid
    
    Return: true, if box valid, otherwise false
Overlaps(...)
Overlaps( (MinMax3D)arg1, (MinMax3D)box) -> bool :
    Does box overlap this box
    
    Parameter: box  Box
    
    Return: true, if boxes overlap, otherwise false
Set(...)
Set( (MinMax3D)arg1, (Point3D)min, (Point3D)max) -> None :
    Set minimum and maximum point
    
    Parameter: min  minimum point
               max  maximum point
SetMax(...)
SetMax( (MinMax3D)arg1, (Point3D)max) -> None :
    Set maximum point
    
    Parameter: max  maximum point
SetMin(...)
SetMin( (MinMax3D)arg1, (Point3D)min) -> None :
    Set minimum point
    
    Parameter: min  minimum point
__add__(...)
__add__( (MinMax3D)arg1, (MinMax3D)minmax) -> object :
    Expand MinMax3D box.
    
    Expands the MinMax3D box by the box given in parameter minmax
    
    Parameter: minmax  MinMax3D to be added
    
    Return: minmax box.
__eq__(...)
__eq__( (MinMax3D)arg1, (MinMax3D)minmax) -> object :
    Comparison of minmax objects without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: minmax  Compared minmax.
    
    Return: True when minmax objects are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (MinMax3D)minmax) -> object :
    Expand MinMax3D box.
    
    Expands the MinMax3D box by the box given in parameter minmax
    
    Parameter: minmax  MinMax3D to be added
    
    Return: reference to minmax box.
 
__iadd__( (object)arg1, (Point3D)point) -> object :
    Expand MinMax3D box.
    
    Parameter: point  Point3D to be added
    
    Return: reference to minmax box.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point3D)min, (Point3D)max) -> None :
    Set constructor
    
    Initialize MinMax box with given MIN and MAX points.
    
    Parameter: min  minimum point
               max  maximum point
 
__init__( (object)arg1, (Point3D)point) -> None :
    Set constructor
    
    Initialize MinMax box with given point.
    
    Parameter: point  
 
__init__( (object)arg1, (MinMax3D)minmax) -> None :
    Copy constructor.
    
    Parameter: minmax  MinMax3D to be copied
__reduce__ = (...)
__repr__(...)
__repr__( (MinMax3D)arg1) -> str

Data descriptors defined here:
Max
Get the maximal point as property
Min
Get the minimal point as property
SizeX
Get the size in x direction as property
SizeY
Get the size in y direction as property
SizeZ
Get the size in z direction as property

Data and other attributes defined here:
__instance_size__ = 64

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Offset3DPlane(Boost.Python.enum)
    Definition of plane on which offset of 3D elements will be calculated
 
 
Method resolution order:
Offset3DPlane
Boost.Python.enum
builtins.int
builtins.object

Data and other attributes defined here:
eNoPlane = NemAll_Python_Geometry.Offset3DPlane.eNoPlane
eXY = NemAll_Python_Geometry.Offset3DPlane.eXY
eXZ = NemAll_Python_Geometry.Offset3DPlane.eXZ
eYZ = NemAll_Python_Geometry.Offset3DPlane.eYZ
names = {'eNoPlane': NemAll_Python_Geometry.Offset3DPlane.eNoPlane, 'eXY': NemAll_Python_Geometry.Offset3DPlane.eXY, 'eXZ': NemAll_Python_Geometry.Offset3DPlane.eXZ, 'eYZ': NemAll_Python_Geometry.Offset3DPlane.eYZ}
values = {0: NemAll_Python_Geometry.Offset3DPlane.eNoPlane, 1: NemAll_Python_Geometry.Offset3DPlane.eXY, 2: NemAll_Python_Geometry.Offset3DPlane.eXZ, 3: NemAll_Python_Geometry.Offset3DPlane.eYZ}

Methods inherited from Boost.Python.enum:
__repr__(self, /)
Return repr(self).
__str__(self, /)
Return str(self).

Data descriptors inherited from Boost.Python.enum:
name

Methods inherited from builtins.int:
__abs__(self, /)
abs(self)
__add__(self, value, /)
Return self+value.
__and__(self, value, /)
Return self&value.
__bool__(self, /)
self != 0
__ceil__(...)
Ceiling of an Integral returns itself.
__divmod__(self, value, /)
Return divmod(self, value).
__eq__(self, value, /)
Return self==value.
__float__(self, /)
float(self)
__floor__(...)
Flooring an Integral returns itself.
__floordiv__(self, value, /)
Return self//value.
__format__(...)
default object formatter
__ge__(self, value, /)
Return self>=value.
__getattribute__(self, name, /)
Return getattr(self, name).
__getnewargs__(...)
__gt__(self, value, /)
Return self>value.
__hash__(self, /)
Return hash(self).
__index__(self, /)
Return self converted to an integer, if self is suitable for use as an index into a list.
__int__(self, /)
int(self)
__invert__(self, /)
~self
__le__(self, value, /)
Return self<=value.
__lshift__(self, value, /)
Return self<<value.
__lt__(self, value, /)
Return self<value.
__mod__(self, value, /)
Return self%value.
__mul__(self, value, /)
Return self*value.
__ne__(self, value, /)
Return self!=value.
__neg__(self, /)
-self
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__or__(self, value, /)
Return self|value.
__pos__(self, /)
+self
__pow__(self, value, mod=None, /)
Return pow(self, value, mod).
__radd__(self, value, /)
Return value+self.
__rand__(self, value, /)
Return value&self.
__rdivmod__(self, value, /)
Return divmod(value, self).
__rfloordiv__(self, value, /)
Return value//self.
__rlshift__(self, value, /)
Return value<<self.
__rmod__(self, value, /)
Return value%self.
__rmul__(self, value, /)
Return value*self.
__ror__(self, value, /)
Return value|self.
__round__(...)
Rounding an Integral returns itself.
Rounding with an ndigits argument also returns an integer.
__rpow__(self, value, mod=None, /)
Return pow(value, self, mod).
__rrshift__(self, value, /)
Return value>>self.
__rshift__(self, value, /)
Return self>>value.
__rsub__(self, value, /)
Return value-self.
__rtruediv__(self, value, /)
Return value/self.
__rxor__(self, value, /)
Return value^self.
__sizeof__(...)
Returns size in memory, in bytes
__sub__(self, value, /)
Return self-value.
__truediv__(self, value, /)
Return self/value.
__trunc__(...)
Truncating an Integral returns itself.
__xor__(self, value, /)
Return self^value.
bit_length(...)
int.bit_length() -> int
 
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
conjugate(...)
Returns self, the complex conjugate of any int.
from_bytes(...) from builtins.type
int.from_bytes(bytes, byteorder, *, signed=False) -> int
 
Return the integer represented by the given array of bytes.
 
The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
 
The byteorder argument determines the byte order used to represent the
integer.  If byteorder is 'big', the most significant byte is at the
beginning of the byte array.  If byteorder is 'little', the most
significant byte is at the end of the byte array.  To request the native
byte order of the host system, use `sys.byteorder' as the byte order value.
 
The signed keyword-only argument indicates whether two's complement is
used to represent the integer.
to_bytes(...)
int.to_bytes(length, byteorder, *, signed=False) -> bytes
 
Return an array of bytes representing an integer.
 
The integer is represented using length bytes.  An OverflowError is
raised if the integer is not representable with the given number of
bytes.
 
The byteorder argument determines the byte order used to represent the
integer.  If byteorder is 'big', the most significant byte is at the
beginning of the byte array.  If byteorder is 'little', the most
significant byte is at the end of the byte array.  To request the native
byte order of the host system, use `sys.byteorder' as the byte order value.
 
The signed keyword-only argument determines whether two's complement is
used to represent the integer.  If signed is False and a negative integer
is given, an OverflowError is raised.

Data descriptors inherited from builtins.int:
denominator
the denominator of a rational number in lowest terms
imag
the imaginary part of a complex number
numerator
the numerator of a rational number in lowest terms
real
the real part of a complex number

 
class OrientedEdge(Boost.Python.instance)
    Oriented edge
Identification of any edge via edge handle and orientation (positive, negative).
 
 
Method resolution order:
OrientedEdge
Boost.Python.instance
builtins.object

Methods defined here:
GetEdgeHandle(...)
GetEdgeHandle( (OrientedEdge)arg1) -> int :
    Get handle to the edge
    
    Return: Edge handle.
HasPositiveOrientation(...)
HasPositiveOrientation( (OrientedEdge)arg1) -> bool :
    Get the flag of positive orientation.
    
    Return: True when edge have positive orientation, otherwise false.
Set(...)
Set( (OrientedEdge)arg1, (OrientedEdge)orientedEdge) -> None :
    Initialize edge from old Allplan structure
    
    Parameter: orientedEdge  Edge which will be copied.
 
Set( (OrientedEdge)arg1, (int)edgeHandle, (bool)positiveOrientation) -> None :
    Set edge handle and orientation
    
    Handle is not checked, you set anything.
    
    Parameter: edgeHandle           Handle to the edge which will be set.
               positiveOrientation  Set true when orientation is positive, otherwise false.
SetEdgeHandle(...)
SetEdgeHandle( (OrientedEdge)arg1, (int)edgeHandle) -> None :
    Set handle to the edge
    
     edgeHandle is not checked, you set anything.
    
    Parameter: edgeHandle  Handle to the edge which will be set.
SetOrientation(...)
SetOrientation( (OrientedEdge)arg1, (bool)positiveOrientation) -> None :
    Set orientation
    
    Parameter: positiveOrientation  Set true when orientation is positive, otherwise false.
__eq__(...)
__eq__( (OrientedEdge)arg1, (OrientedEdge)orientedEdge) -> object :
    Equal operator
    
    Parameter: orientedEdge  Edge to comparison
    
    Return: True when both edges are equal.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (int)edgeHandle, (bool)positiveOrientation) -> None :
    Constructor
    
    Parameter: edgeHandle           Set edge handle.
               positiveOrientation  Set orientation, true for positive, false for negative
 
__init__( (object)arg1, (OrientedEdge)orientedEdge) -> None :
    Copy constructor
    
    Parameter: orientedEdge  Edge which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (OrientedEdge)arg1) -> str

Data descriptors defined here:
EdgeHandle
Get and set the edge handle property
Positive
Get and set the positive orientation property

Data and other attributes defined here:
__instance_size__ = 32

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class OrientedEdgeList(Boost.Python.instance)
    
Method resolution order:
OrientedEdgeList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (OrientedEdgeList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (OrientedEdgeList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (OrientedEdgeList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (OrientedEdgeList)arg1) -> str
__setitem__(...)
__setitem__( (OrientedEdgeList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (OrientedEdgeList)arg1, (object)arg2) -> None
extend(...)
extend( (OrientedEdgeList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Path(Boost.Python.instance)
    
Method resolution order:
Path
Boost.Python.instance
builtins.object

Methods defined here:
Clear(...)
Clear( (Path)arg1) -> None :
    Clear all geometries from path
Count(...)
Count( (Path)arg1) -> int :
    Count of geometries stored in path
    
    Return: Count of geometries.
IsEmpty(...)
IsEmpty( (Path)arg1) -> bool :
    Tests whether no elements are present
    
    Return: True for an empty, otherwise false.
Remove(...)
Remove( (Path)arg1, (int)position) -> object :
    Remove geometry at the specified position
    
    Parameter: position  Specified position of removed geometry.
    
    Return: Error code.
Reverse(...)
Reverse( (Path)arg1) -> None :
    Reverse orientation of the PathElement
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Path2D(Path)
    2D path
class for 2D path geometry
 
 
Method resolution order:
Path2D
Path
Boost.Python.instance
builtins.object

Methods defined here:
Add(...)
Add( (Path2D)arg1, (object)element) -> eGeometryErrorCode :
    Add element into path Path2D
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Pointer to geometry element to add
    
    Return: error code
 
Add( (Path2D)arg1, (Path2D)element) -> eGeometryErrorCode :
    Add element into path Path2D
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Path element to add
    
    Return: error code
GetEndPoint(...)
GetEndPoint( (Path2D)arg1) -> Point2D :
    Get path end point
    
    Throw  THROW_GEO_EXCEPTION_OUT_OF_RANGE_ if path is empty
    Throw  THROW_GEO_EXCEPTION_GENERAL_ERROR_ if internal error
    
    Return: const Point2D End point
GetEndRelPoint(...)
GetEndRelPoint( (Path2D)arg1) -> Point2D :
    Get relative end (last) point of the path
    
    Return: End point (relative)
GetStartPoint(...)
GetStartPoint( (Path2D)arg1) -> Point2D :
    Get path start point
    
    Throw  THROW_GEO_EXCEPTION_OUT_OF_RANGE_ if path is empty
    Throw  THROW_GEO_EXCEPTION_GENERAL_ERROR_ if internal error
    
    Return: const Point2D Start point
GetStartRelPoint(...)
GetStartRelPoint( (Path2D)arg1) -> Point2D :
    Get relative start (first) point of the path
    
    Return: Start point (relative)
IsClosed(...)
IsClosed( (Path2D)arg1) -> bool :
    Check for closed path, it mean that first point is same as last point
    
    Return: True when path is closed, otherwise false.
IsItPossibleToAddElement(...)
IsItPossibleToAddElement( (Path2D)arg1, (object)pGeometry) -> bool :
    Check if the geometry can be added into path Path2D
    
    Parameter: pGeometry  Pointer to geometry to check
IsValid(...)
IsValid( (Path2D)arg1) -> bool :
    Validity check
    
    warning Path doesn't have to be closed to be valid, you have to check this extra
IsValidCurveType(...)
IsValidCurveType( (object)pGeometry) -> bool :
    Check if the geometry is supported by Path2D
    
    Parameter: pGeometry  Pointer to geometry to check
SetEndPoint(...)
SetEndPoint( (Path2D)arg1, (Point2D)endpoint) -> None :
    Set end (last) point of the path
    
    Parameter: endpoint  E point
SetStartPoint(...)
SetStartPoint( (Path2D)arg1, (Point2D)startpoint) -> None :
    Set start (first) point of the path
    
    Parameter: startpoint  Start point
__eq__(...)
__eq__( (Path2D)arg1, (Path2D)path) -> object :
    Comparison of paths without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: path Compared path.
    
    Return: True when paths are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (Path2D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Element which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Line2D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Line2D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Polyline2D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Polyline2D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Spline2D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Spline2D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Clothoid2D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Clothoid2D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Arc2D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Arc2D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (object)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Geometry element which will be appended
    
    Return: Reference to path.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Path2D)path) -> None :
    Copy constructor
    
    Copy constructor is expensive because all data are cloned in new path.
    
    Parameter: path  Path which will be copied.
__reduce__ = (...)
__repr__(...)
__repr__( (Path2D)arg1) -> str

Data and other attributes defined here:
__instance_size__ = 40

Methods inherited from Path:
Clear(...)
Clear( (Path)arg1) -> None :
    Clear all geometries from path
Count(...)
Count( (Path)arg1) -> int :
    Count of geometries stored in path
    
    Return: Count of geometries.
IsEmpty(...)
IsEmpty( (Path)arg1) -> bool :
    Tests whether no elements are present
    
    Return: True for an empty, otherwise false.
Remove(...)
Remove( (Path)arg1, (int)position) -> object :
    Remove geometry at the specified position
    
    Parameter: position  Specified position of removed geometry.
    
    Return: Error code.
Reverse(...)
Reverse( (Path)arg1) -> None :
    Reverse orientation of the PathElement

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Path2DList(Boost.Python.instance)
    
Method resolution order:
Path2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Path2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Path2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Path2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Path2DList)arg1) -> str
__setitem__(...)
__setitem__( (Path2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Path2DList)arg1, (object)arg2) -> None
extend(...)
extend( (Path2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Path3D(Path)
    3D path
class for 3D path geometry
 
 
Method resolution order:
Path3D
Path
Boost.Python.instance
builtins.object

Methods defined here:
Add(...)
Add( (Path3D)arg1, (object)element) -> eGeometryErrorCode :
    Add element into path Path3D
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Pointer to element to add
    
    Return: error code
 
Add( (Path3D)arg1, (Path3D)element) -> eGeometryErrorCode :
    Add element into path Path3D
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Path element to add
    
    Return: error code
DefinitionPoints(...)
DefinitionPoints( (Path3D)arg1) -> Polyline3D :
    Extracts all definition points of the path.
    
    Return:  All definition points ( join points of sub curves in this path ) of this path as Polyline3D
FirstDefinitionPoint(...)
FirstDefinitionPoint( (Path3D)arg1) -> Point3D :
    Extracts the first definition point of the path.
    
    Return:  First definition point of this path as Point3D
GetEndPoint(...)
GetEndPoint( (Path3D)arg1) -> Point3D :
    Get path end point
    
    Throw  THROW_GEO_EXCEPTION_OUT_OF_RANGE_ if path is empty
    Throw  THROW_GEO_EXCEPTION_GENERAL_ERROR_ if internal error
    
    Return: const Point3D     End point
GetEndRelPoint(...)
GetEndRelPoint( (Path3D)arg1) -> Point3D :
    Get relative end (last) point of the path
    
    Return: End point (relative)
GetStartPoint(...)
GetStartPoint( (Path3D)arg1) -> Point3D :
    Get path start point
    
    Throw  THROW_GEO_EXCEPTION_OUT_OF_RANGE_ if path is empty
    Throw  THROW_GEO_EXCEPTION_GENERAL_ERROR_ if internal error
    
    Return: const Point3D     Start point
GetStartRelPoint(...)
GetStartRelPoint( (Path3D)arg1) -> Point3D :
    Get relative start (first) point of the path
    
    Return: Start point (relative)
IsClosed(...)
IsClosed( (Path3D)arg1) -> bool :
    Check for closed path, it mean that first point is same as last point
    
    Return: True when path is closed, otherwise false.
IsItPossibleToAddElement(...)
IsItPossibleToAddElement( (Path3D)arg1, (object)pGeometry) -> bool :
    Check if the geometry can be added into path Path3D
    
    Parameter: pGeometry  Pointer to geometry to check
 
IsItPossibleToAddElement( (Path3D)arg1, (object)pGeometry, (float)tolerance) -> bool :
    Check if the geometry can be added into path Path3D (with possible noncontinuous)
    
    Parameter: pGeometry  Pointer to geometry to check(are modified in case of non continuos geometries!)
               tolerance  Tolerance for non continuous geometries
IsValid(...)
IsValid( (Path3D)arg1) -> bool :
    Validity check
    
    warning Path doesn't have to be closed to be valid, you have to check this extra
IsValidCurveType(...)
IsValidCurveType( (object)pGeometry) -> bool :
    Check if the geometry is supported by Path3D
    
    Parameter: pGeometry  Pointer to geometry to check
SetEndPoint(...)
SetEndPoint( (Path3D)arg1, (Point3D)endpoint) -> None :
    Set end (last) point of the path
    
    Parameter: endpoint  E point
SetStartPoint(...)
SetStartPoint( (Path3D)arg1, (Point3D)startpoint) -> None :
    Set start (first) point of the path
    
    Parameter: startpoint  Start point
__eq__(...)
__eq__( (Path3D)arg1, (Path3D)path) -> object :
    Comparison of paths without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: path Compared path.
    
    Return: True when paths are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (Path3D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Element which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Line3D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Line3D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Polyline3D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Polyline3D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Arc3D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Arc3D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (Spline3D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  Spline3D which will be appended
    
    Return: Reference to path.
 
__iadd__( (object)arg1, (BSpline3D)element) -> object :
    Append operator
    Start or end point of appended element has to be equal to start or end point of path
    
    Parameter: element  BSpline3D which will be appended
    
    Return: Reference to path.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Path3D)path) -> None :
    Copy constructor
    
    Copy constructor is expensive because all data are cloned in new path.
    
    Parameter: path  Path which will be copied.
 
__init__( (object)arg1, (Point3D)point1, (Point3D)point2) -> None :
    Constructor defines a polyline of 2 points as path.
    
    Parameter: point1  First point of the polyline path
               point2  Second point of the polyline path
 
__init__( (object)arg1, (Point3D)point1, (Point3D)point2, (Point3D)point3) -> None :
    Constructor defines a polyline of 3 points as path.
    
    Parameter: point1  1. point of the polyline path
               point2  2. point of the polyline path
               point3  3. point of the polyline path
 
__init__( (object)arg1, (Point3D)point1, (Point3D)point2, (Point3D)point3, (Point3D)point4) -> None :
    Constructor defines a polyline of 4 points as path.
    
    Parameter: point1  1. point of the polyline path
               point2  2. point of the polyline path
               point3  3. point of the polyline path
               point4  4. point of the polyline path
 
__init__( (object)arg1, (Point3D)point1, (Point3D)point2, (Point3D)point3, (Point3D)point4, (Point3D)point5) -> None :
    Constructor defines a polyline of 5 points as path.
    
    Parameter: point1  1. point of the polyline path
               point2  2. point of the polyline path
               point3  3. point of the polyline path
               point4  4. point of the polyline path
               point5  5. point of the polyline path
__reduce__ = (...)
__repr__(...)
__repr__( (Path3D)arg1) -> str

Data and other attributes defined here:
__instance_size__ = 40

Methods inherited from Path:
Clear(...)
Clear( (Path)arg1) -> None :
    Clear all geometries from path
Count(...)
Count( (Path)arg1) -> int :
    Count of geometries stored in path
    
    Return: Count of geometries.
IsEmpty(...)
IsEmpty( (Path)arg1) -> bool :
    Tests whether no elements are present
    
    Return: True for an empty, otherwise false.
Remove(...)
Remove( (Path)arg1, (int)position) -> object :
    Remove geometry at the specified position
    
    Parameter: position  Specified position of removed geometry.
    
    Return: Error code.
Reverse(...)
Reverse( (Path)arg1) -> None :
    Reverse orientation of the PathElement

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Path3DList(Boost.Python.instance)
    
Method resolution order:
Path3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Path3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Path3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Path3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Path3DList)arg1) -> str
__setitem__(...)
__setitem__( (Path3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Path3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Path3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Plane3D(Boost.Python.instance)
    3D plane
 
 
Method resolution order:
Plane3D
Boost.Python.instance
builtins.object

Methods defined here:
CalcPlaneVectors(...)
CalcPlaneVectors( (Plane3D)arg1) -> tuple :
    Calc X and Y axis vectors for plane
    
    Return: Vector of X axis,
            Vector of Y axis
GetPoint(...)
GetPoint( (Plane3D)arg1) -> Point3D :
    Get 3D Plane reference point
    
    Return: Point3D.
GetTransformationMatrix(...)
GetTransformationMatrix( (Plane3D)arg1) -> Matrix3D :
    Get transformation matrix for given plane 3D
    
    Return: Matrix3D const reference
GetVector(...)
GetVector( (Plane3D)arg1) -> Vector3D :
    Get the Normal Vector
    
    Return: Vector3D.
Set(...)
Set( (Plane3D)arg1, (Point3D)point, (Vector3D)normalVector) -> None :
    Initialize Plane from point and vector
    
    Parameter: point         New point.
               normalVector  New vector.
SetPoint(...)
SetPoint( (Plane3D)arg1, (Point3D)point) -> None :
    Set reference point
    
    Parameter: point  New point.
SetVector(...)
SetVector( (Plane3D)arg1, (Vector3D)vec) -> None :
    Set the Normal Vector
    
    Parameter: vec  New vector.
__eq__(...)
__eq__( (Plane3D)arg1, (Plane3D)plane) -> object :
    Comparison of planes without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: plane Compared plane.
    
    Return: True when planes are equal, otherwise false.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Plane3D)plane) -> None :
    Copy constructor
    
    Parameter: plane  Plane which will be copied.
 
__init__( (object)arg1, (Point3D)point, (Vector3D)normalVector) -> None :
    Constructor
    
    Create 3D Plane with given point and vector
    
    Parameter: point         Init point of the plane.
               normalVector  Init vector of the plane.
 
__init__( (object)arg1, (Point3D)point1, (Point3D)point2, (Point3D)point3) -> None :
    Constructor
    
    Create 3D Plane from three points which lies on this plane.
    If plane can not be computed, then constructor throw geometry exception 'Plane3D Incorrect parameters'.
    
    Parameter: point1  1st point on the plane.
               point2  2nd point on the plane.
               point3  3rd point on the plane.
 
__init__( (object)arg1, (Axis3D)axis) -> None :
    Create a plane from a 3D axis
    
    Parameter: axis  Axis
__mul__(...)
__mul__( (Plane3D)arg1, (Matrix2D)matrix) -> object :
    2D matrix transformation.
    
    Parameter: matrix  2D transformation Matrix
    
    Return: Copy of transformed 3D plane.
 
__mul__( (Plane3D)arg1, (Matrix3D)matrix) -> object :
    3D matrix transformation.
    
    Parameter: matrix  3D transformation Matrix
    
    Return: Copy of transformed 3D plane.
__reduce__ = (...)
__repr__(...)
__repr__( (Plane3D)arg1) -> str

Data descriptors defined here:
Point
Get and set the point as property
Vector
Get and set the vector as property

Data and other attributes defined here:
__instance_size__ = 64

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Point2D(Boost.Python.instance)
    2D point
 
 
Method resolution order:
Point2D
Boost.Python.instance
builtins.object

Methods defined here:
GetCoords(...)
GetCoords( (Point2D)arg1) -> tuple :
    Get copy of X,Y coordinates.
    
    Return: X coordinate of point.,
            Y coordinate of point.
GetDistance(...)
GetDistance( (Point2D)arg1, (Point2D)point) -> float :
    Get distance.
    
    Formula: Result(double) = |A-B|.
    
    Parameter: point  Point2D.
    
    Return: double.
IsZero(...)
IsZero( (Point2D)arg1) -> bool :
    Check the coords [0.0,0.0].
    
    If the coords are zero, the return value is true.
    If the coords aren't zero, the return value is false.
    
    Return: bool.
Set(...)
Set( (Point2D)arg1, (Point2D)point) -> None :
    Initialize from point 2D.
    
    Parameter: point  Point.
 
Set( (Point2D)arg1, (float)x, (float)y) -> None :
    Initialize from x,y coordinates.
    
    Parameter: x  coordinate.
               y  coordinate.
SetX(...)
SetX( (Point2D)arg1, (float)x) -> None :
    Initialize from point 2D.
    
    Parameter: x  coordinate.
SetY(...)
SetY( (Point2D)arg1, (float)y) -> None :
    Initialize from point 2D.
    
    Parameter: y  coordinate.
Values(...)
Values( (Point2D)arg1) -> list :
    Get copy of X,Y coordinates as python list.
    
    Return: X coordinate of point.,
            Y coordinate of point.
__add__(...)
__add__( (Point2D)arg1, (Point2D)point) -> object :
    Point translation by point.
    
    Formula: Point(new) = Point(this) + Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in %Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector2D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
 
__add__( (Point2D)arg1, (Vector2D)vec) -> object :
    Move the point by vector
    
    Parameter: vec  Vector
    
    Return: New point
__eq__(...)
__eq__( (Point2D)arg1, (Point2D)point) -> object :
    Comparison of points without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: point  Compared point.
    
    Return: True when points are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (Point2D)point) -> object :
    Point translation by point.
    
    Formula: Point(this) = Point(this) + Point
    
    This is not standard math operation and is implemented only as practical use case
    for point moving in Allplan. In this case given operand point represent
    offset from Zero point.
    For standard move operation please use Service::Move method with Vector2D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
__idiv__(...)
__idiv__( (object)arg1, (float)divider) -> object :
    Divide operator.
    
    Formula:
         Point(this).X = Point(this).X / divider
         Point(this).Y = Point(this).Y / divider
    
    This method is checked and throwing Geometry::Exception when divider is zero.
    
    Parameter: divider  Divider.
    
    Return: Point.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point2D)point) -> None :
    Copy constructor.
    
    Parameter: point  Point which will be copied.
 
__init__( (object)arg1, (Point3D)point) -> None :
    Explicit copy constructor.
    
    Copy only X_COORD and Y_COORD from point
    
    Parameter: point  3D Point which will be copied to the 2D point.
 
__init__( (object)arg1, (float)x, (float)y) -> None :
    Constructor.
    
    Initialize point from single coordinates in world coordinate system.
    
    Parameter: x  X coordinate of point.
               y  Y coordinate of point.
 
__init__( (object)arg1, (Point2D)refPoint, (Point2D)point) -> None :
    Constructor.
    
    Initialize point from point in local coordinate system.
    Formula: Result = refPoint + point
    
    Parameter: refPoint  Reference point.
               point     Relative point.
__isub__(...)
__isub__( (object)arg1, (Point2D)point) -> object :
    Point translation by negative point
    
    Formula: Point(this) = Point(this) - Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in %Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector2D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
__mul__(...)
__mul__( (Point2D)arg1, (Matrix2D)matrix) -> object :
    Matrix transformation.
    
    Result = Point * matrix
    
    Parameter: matrix  Transformation Matrix.
    
    Return: Point.
__reduce__ = (...)
__repr__(...)
__repr__( (Point2D)arg1) -> str
__sub__(...)
__sub__( (Point2D)arg1, (Vector2D)vec) -> object :
    Move the point by reversed vector
    
    Parameter: vec  Vector
    
    Return: New point
 
__sub__( (Point2D)arg1, (Point2D)point) -> object :
    Point translation by negative point
    
    Formula: Point(new) = Point(this) - Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in %Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector2D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
__truediv__(...)
__truediv__( (Point2D)arg1, (float)divider) -> object :
    Divide operator.
    
    Formula:
         Point(new).X = Point(this).X / divider
         Point(new).Y = Point(this).Y / divider
    
    Parameter: divider  Divider.
    
    Return: Point.

Data descriptors defined here:
X
Property access for the x coordinate
Y
Property access for the y coordinate

Data and other attributes defined here:
__instance_size__ = 32

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Point2DList(Boost.Python.instance)
    
Method resolution order:
Point2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Point2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Point2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Point2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Point2DList)arg1) -> str
__setitem__(...)
__setitem__( (Point2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Point2DList)arg1, (object)arg2) -> None
extend(...)
extend( (Point2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Point3D(Boost.Python.instance)
    3D point
 
 
Method resolution order:
Point3D
Boost.Python.instance
builtins.object

Methods defined here:
GetCoords(...)
GetCoords( (Point3D)arg1) -> tuple :
    Get copy of X,Y,Z coordinates
    
    Return: X coordinate of point.,
            Y coordinate of point.,
            Z coordinate of point.
GetDistance(...)
GetDistance( (Point3D)arg1, (Point3D)point) -> float :
    Get distance
    
    Formula: Result(double) = |A-B|.
    
    Parameter: point  Point3D.
    
    Return: double.
IsZero(...)
IsZero( (Point3D)arg1) -> bool :
    Check the coords [0.0, 0.0, 0.0]
    
    If the coords are zero, the return value is true.
    If the coords aren't zero, the return value is false.
    
    Return: bool.
Set(...)
Set( (Point3D)arg1, (Point3D)point) -> None :
    Initialize from point 3D.
    
    Parameter: point  Point.
 
Set( (Point3D)arg1, (float)x, (float)y, (float)z) -> None :
    Initialize from x,y,z coordinates.
    
    Parameter: x  coordinate.
               y  coordinate.
               z  coordinate.
Values(...)
Values( (Point3D)arg1) -> list :
    Get copy of X,Y,Z coordinates as python list
    
    Return: X coordinate of point.,
            Y coordinate of point.,
            Z coordinate of point.
__add__(...)
__add__( (Point3D)arg1, (Vector3D)vec) -> object :
    Move the point by vector 3D
    
    Parameter: vec  Vector
    
    Return: New point
 
__add__( (Point3D)arg1, (Vector2D)vec) -> object :
    Move the point by vector 2D. Z axis will be ignored
    
    Parameter: vec  Vector
    
    Return: New point
 
__add__( (Point3D)arg1, (Point3D)point) -> object :
    Point translation by point
    
    Formula: Point(new) = Point(this) + Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector3D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
__eq__(...)
__eq__( (Point3D)arg1, (Point3D)point) -> object :
    Comparison of points without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: point  Compared point.
    
    Return: True when points are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (Point3D)point) -> object :
    Point translation by point
    
    Formula: Point(this) = Point(this) + Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector3D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
__idiv__(...)
__idiv__( (object)arg1, (float)divider) -> object :
    Divide operator.
    
    Formula:
         Point(this).X = Point(this).X / divider
         Point(this).Y = Point(this).Y / divider
         Point(this).Z = Point(this).Z / divider
    
    This method is checked and throwing Geometry::Exception when divider is zero.
    
    Parameter: divider  Divider.
    
    Return: Point.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Point3D)point) -> None :
    Copy constructor.
    
    Parameter: point  Point which will be copied.
 
__init__( (object)arg1, (Point2D)point) -> None :
    Explicit copy constructor.
    
    Copy only X_COORD and Y_COORD from point, Z_COORD is set to zero.
    
    Parameter: point  2D Point which will be copied to the 3D point.
 
__init__( (object)arg1, (Point3D)refPoint, (Point3D)point) -> None :
    Constructor.
    
    Initialize point from point in local coordinate system.
    Formula: Result = refPoint + point
    
    Parameter: refPoint  Reference point.
               point     Relative point
 
__init__( (object)arg1, (float)x, (float)y, (float)z) -> None :
    Constructor
    
    Initialize point from single coordinates in world coordinate system.
    
    Parameter: x  X coordinate of point
               y  Y coordinate of point
               z  Z coordinate of point
 
__init__( (object)arg1, (Point3D)arg2) -> None :
    Copy constructor
 
__init__( (object)arg1, (Point2D)arg2) -> None :
    Constructor to convert a 2D point
 
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :
    Constructor with x, y and z coordinate
__isub__(...)
__isub__( (object)arg1, (Point3D)point) -> object :
    Point translation by negative point
    
    Formula: Point(this) = Point(this) - Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector3D operand.
    
    Parameter: point  Point.
    
    Return: Reference to point.
__mul__(...)
__mul__( (Point3D)arg1, (Matrix2D)matrix) -> object :
    2D matrix transformation.
    
    Result = Point * matrix
    
    Parameter: matrix  2D transformation Matrix
    
    Return: Point.
 
__mul__( (Point3D)arg1, (Matrix3D)matrix) -> object :
    3D matrix transformation.
    
    Result = Point * matrix
    
    Parameter: matrix  3D transformation Matrix
    
    Return: Point.
 
__mul__( (Point3D)arg1, (float)scale) -> object :
    Scale point with constant
    
    Result = Point * scale
    
    Parameter: scale  - scale factor
    
    Return: scaled Point
__ne__(...)
__ne__( (Point3D)arg1, (Point3D)point) -> object :
    Comparison of points without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: point  Compared point.
    
    Return: True when points are not equal, otherwise false.
__reduce__ = (...)
__repr__(...)
__repr__( (Point3D)arg1) -> str
__sub__(...)
__sub__( (Point3D)arg1, (Vector3D)vec) -> object :
    Move the point by reversed vector 3D
    
    Parameter: vec  3D vector
    
    Return: New point
 
__sub__( (Point3D)arg1, (Vector2D)vec) -> object :
    Move the point by reversed vector 2D. Z coordinate stays unchanged.
    
    Parameter: vec  2D vector
    
    Return: New point
 
__sub__( (Point3D)arg1, (Point3D)point) -> object :
    Point translation by negative point
    
    Formula: Point(new) = Point(this) - Point
    n
    his is not standard math operation and is implemented only as practical use case
    or point moving in %Allplan. In this case given operand point represent
    ffset from Zero point.
    or standard move operation please use Service::Move method with Vector3D operand.
    
    Parameter: point  Point3D.
    
    Return: Reference to point.
__truediv__(...)
__truediv__( (Point3D)arg1, (float)divider) -> object :
    Divide operator.
    
    Formula:
         Point(new).X = Point(this).X / divider
         Point(new).Y = Point(this).Y / divider
         Point(new).Z = Point(this).Z / divider
    
    Parameter: divider  Divider.
    
    Return: Point.

Data descriptors defined here:
X
Property access for the x coordinate
Y
Property access for the y coordinate
Z
Property access for the z coordinate

Data and other attributes defined here:
__instance_size__ = 40

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Point3DList(Boost.Python.instance)
    
Method resolution order:
Point3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Point3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Point3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Point3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Point3DList)arg1) -> str
__setitem__(...)
__setitem__( (Point3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Point3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Point3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolyPoints2D(Boost.Python.instance)
    
Method resolution order:
PolyPoints2D
Boost.Python.instance
builtins.object

Methods defined here:
Clear(...)
Clear( (PolyPoints2D)arg1) -> None :
    Remove all points from vector.
Count(...)
Count( (PolyPoints2D)arg1) -> int :
    Get count of points.
    
    Return: bool.
Empty(...)
Empty( (PolyPoints2D)arg1) -> bool :
    Return true if no points, otherwise false.
    
    Return: bool.
EqualRef(...)
EqualRef( (PolyPoints2D)arg1, (PolyPoints2D)polyPoints) -> bool :
    Test if reference points are equal.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
    
    Return:  Reference points are equal: true/false
GetEndPoint(...)
GetEndPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the end point in world coordinate system.
    
    Return:  end point in world coordinate system
GetEndRelPoint(...)
GetEndRelPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the end point
    
    Return:  end point
GetLastPoint(...)
GetLastPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the last point in world coordinate system, copy of data.
    
    Return:  last point in world coordinate system
GetPoint(...)
GetPoint( (PolyPoints2D)arg1, (int)index) -> Point2D :
    Get point in world coordinate system, copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point point in world coordinate system.
GetPointIndex(...)
GetPointIndex( (PolyPoints2D)arg1, (Point2D)point) -> tuple :
    Get index of the given point
    
    Parameter: point  Searched point
    
    Return: True if a point was found,
            Found index
GetPointIndexes(...)
GetPointIndexes( (PolyPoints2D)arg1, (Point2D)point) -> tuple :
    Get indexes of the given point, in case that several points in the spline
    will have the same coordinates
    
    Parameter: point  Searched point
    
    Return: True if at least one point was found,
            Found indexes
GetRefPoint(...)
GetRefPoint( (PolyPoints2D)arg1) -> Point2D :
    Get reference point.
    
    Return: constant reference to the reference point in the world coordinate system.
GetRelPoint(...)
GetRelPoint( (PolyPoints2D)arg1, (int)index) -> Point2D :
    Get reference to point in Local coordinate system, no copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point constant reference to the point at position index.
GetStartPoint(...)
GetStartPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the start point in world coordinate system.
    
    Return:  start point in world coordinate system
GetStartRelPoint(...)
GetStartRelPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the start point
    
    Return:  start point
Insert(...)
Insert( (PolyPoints2D)arg1, (PolyPoints2D)polyPoints, (int)position) -> bool :
    Insert vector of points at specific position.
    
    If return false then points weren't inserted.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
               position    position where points will be inserted.
    
    Return: bool true if successful.
 
Insert( (PolyPoints2D)arg1, (Point2D)point, (int)position) -> bool :
    Insert point at specific position. Used world coordinates.
    
    If return false then points weren't Inserted.
    
    Parameter: point     constant reference to the Point.
               position  position where points will be inserted.
    
    Return: bool true if successful.
Remove(...)
Remove( (PolyPoints2D)arg1, (int)position) -> bool :
    Remove point from specific position.
    
    If return false then points weren't removed.
    
    Parameter: position  position of point which will be removed.
    
    Return: return false;
RemoveLastPoint(...)
RemoveLastPoint( (PolyPoints2D)arg1) -> bool :
    Remove the last point
    
    Return:  Point removed: true/false
Reserve(...)
Reserve( (PolyPoints2D)arg1, (int)newCount) -> None :
    Reserve container capacity
    
    Parameter: newCount  Expected size of container [count of points]
Resize(...)
Resize( (PolyPoints2D)arg1, (int)newSize) -> None :
    Specifies a new size for the points vector.
    
    Parameter: newSize  The new size of the points vector.
Reverse(...)
Reverse( (PolyPoints2D)arg1) -> None :
    Reverse the point order.
SetEndPoint(...)
SetEndPoint( (PolyPoints2D)arg1, (Point2D)endpoint) -> None :
    Set the end point in world coordinates
    
    Parameter: endpoint  new end point
SetPoint(...)
SetPoint( (PolyPoints2D)arg1, (Point2D)point, (int)index) -> None :
    Set point at given position in world coordinate system.
    
    Parameter: point  point in the world coordinate system.
               index  index of point which will be set
SetRefPoint(...)
SetRefPoint( (PolyPoints2D)arg1, (Point2D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Parameter: refPoint  reference point in the world coordinate system.
SetRelPoint(...)
SetRelPoint( (PolyPoints2D)arg1, (Point2D)point, (int)index) -> None :
    Set point at given position in relative coordinate system.
    
    Parameter: point  point in the relative coordinate system.
               index  index of point which will be set
SetStartPoint(...)
SetStartPoint( (PolyPoints2D)arg1, (Point2D)startpoint) -> None :
    Set the start point in world coordinates
    
    Parameter: startpoint  new start point
ToLineChain(...)
ToLineChain( (PolyPoints2D)arg1) -> Point2DList :
    Get polyline as a chain of lines composed from 2 points.
    
    Return: vector of lines composed from 2 points (start and end point of a line)
__getitem__(...)
__getitem__( (PolyPoints2D)arg1, (int)arg2) -> Point2D :
    Get point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
    
    Return: copy of point.
__iadd__(...)
__iadd__( (object)arg1, (Point2D)point) -> object :
    Add point in world coordinates.
    
    Parameter: point  adding point.
    
    Return:  New point
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)
__setitem__(...)
__setitem__( (PolyPoints2D)arg1, (int)arg2, (Point2D)arg3) -> None :
    Set point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
               pnt    Point

Data descriptors defined here:
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolyPoints3D(Boost.Python.instance)
    
Method resolution order:
PolyPoints3D
Boost.Python.instance
builtins.object

Methods defined here:
Clear(...)
Clear( (PolyPoints3D)arg1) -> None :
    Remove all points from vector.
Count(...)
Count( (PolyPoints3D)arg1) -> int :
    Get count of points.
    
    Return: bool.
Empty(...)
Empty( (PolyPoints3D)arg1) -> bool :
    Return true if no points, otherwise false.
    
    Return: bool.
EqualRef(...)
EqualRef( (PolyPoints3D)arg1, (PolyPoints3D)polyPoints) -> bool :
    Test if reference points are equal.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
    
    Return:  Reference points are equal: true/false
GetEndPoint(...)
GetEndPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the end point in world coordinate system.
    
    Return:  end point in world coordinate system
GetEndRelPoint(...)
GetEndRelPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the end point
    
    Return:  end point
GetLastPoint(...)
GetLastPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the last point in world coordinate system, copy of data.
    
    Return:  last point in world coordinate system
GetPoint(...)
GetPoint( (PolyPoints3D)arg1, (int)index) -> Point3D :
    Get point in world coordinate system, copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point point in world coordinate system.
GetPointIndex(...)
GetPointIndex( (PolyPoints3D)arg1, (Point3D)point) -> tuple :
    Get index of the given point
    
    Parameter: point  Searched point
    
    Return: True if a point was found,
            Found index
GetPointIndexes(...)
GetPointIndexes( (PolyPoints3D)arg1, (Point3D)point) -> tuple :
    Get indexes of the given point, in case that several points in the spline
    will have the same coordinates
    
    Parameter: point  Searched point
    
    Return: True if at least one point was found,
            Found indexes
GetRefPoint(...)
GetRefPoint( (PolyPoints3D)arg1) -> Point3D :
    Get reference point.
    
    Return: constant reference to the reference point in the world coordinate system.
GetRelPoint(...)
GetRelPoint( (PolyPoints3D)arg1, (int)index) -> Point3D :
    Get reference to point in Local coordinate system, no copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point constant reference to the point at position index.
GetStartPoint(...)
GetStartPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the start point in world coordinate system.
    
    Return:  start point in world coordinate system
GetStartRelPoint(...)
GetStartRelPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the start point
    
    Return:  start point
Insert(...)
Insert( (PolyPoints3D)arg1, (PolyPoints3D)polyPoints, (int)position) -> bool :
    Insert vector of points at specific position.
    
    If return false then points weren't inserted.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
               position    position where points will be inserted.
    
    Return: bool true if successful.
 
Insert( (PolyPoints3D)arg1, (Point3D)point, (int)position) -> bool :
    Insert point at specific position. Used world coordinates.
    
    If return false then points weren't Inserted.
    
    Parameter: point     constant reference to the Point.
               position  position where points will be inserted.
    
    Return: bool true if successful.
Remove(...)
Remove( (PolyPoints3D)arg1, (int)position) -> bool :
    Remove point from specific position.
    
    If return false then points weren't removed.
    
    Parameter: position  position of point which will be removed.
    
    Return: return false;
RemoveLastPoint(...)
RemoveLastPoint( (PolyPoints3D)arg1) -> bool :
    Remove the last point
    
    Return:  Point removed: true/false
Reserve(...)
Reserve( (PolyPoints3D)arg1, (int)newCount) -> None :
    Reserve container capacity
    
    Parameter: newCount  Expected size of container [count of points]
Resize(...)
Resize( (PolyPoints3D)arg1, (int)newSize) -> None :
    Specifies a new size for the points vector.
    
    Parameter: newSize  The new size of the points vector.
Reverse(...)
Reverse( (PolyPoints3D)arg1) -> None :
    Reverse the point order.
SetEndPoint(...)
SetEndPoint( (PolyPoints3D)arg1, (Point3D)endpoint) -> None :
    Set the end point in world coordinates
    
    Parameter: endpoint  new end point
SetPoint(...)
SetPoint( (PolyPoints3D)arg1, (Point3D)point, (int)index) -> None :
    Set point at given position in world coordinate system.
    
    Parameter: point  point in the world coordinate system.
               index  index of point which will be set
SetRefPoint(...)
SetRefPoint( (PolyPoints3D)arg1, (Point3D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Parameter: refPoint  reference point in the world coordinate system.
SetRelPoint(...)
SetRelPoint( (PolyPoints3D)arg1, (Point3D)point, (int)index) -> None :
    Set point at given position in relative coordinate system.
    
    Parameter: point  point in the relative coordinate system.
               index  index of point which will be set
SetStartPoint(...)
SetStartPoint( (PolyPoints3D)arg1, (Point3D)startpoint) -> None :
    Set the start point in world coordinates
    
    Parameter: startpoint  new start point
ToLineChain(...)
ToLineChain( (PolyPoints3D)arg1) -> Point3DList :
    Get polyline as a chain of lines composed from 2 points.
    
    Return: vector of lines composed from 2 points (start and end point of a line)
__getitem__(...)
__getitem__( (PolyPoints3D)arg1, (int)arg2) -> Point3D :
    Get point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
    
    Return: copy of point.
__iadd__(...)
__iadd__( (object)arg1, (Point3D)point) -> object :
    Add point in world coordinates.
    
    Parameter: point  adding point.
    
    Return:  New point
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)
__setitem__(...)
__setitem__( (PolyPoints3D)arg1, (int)arg2, (Point3D)arg3) -> None :
    Set point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
               pnt    Point

Data descriptors defined here:
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Polygon2D(PolyPoints2D)
    2D polygon
For constructing a polygon from a bunch of points, the following rules must be fulfilled:
This class does not 'auto-close' polygons. A quadratic shape 
with '4' edges has to be defined by passing 5 points to a constructor. For such an object, the Count()
method will return '5' accordingly.
The orientation of points must be monotonous. It can be either clockwise or counter-clockwise.
The polygon must not self-intersect itself. You can create instances of polygons that self-intersects
or have alternating orientation, but in those cases some methods will report errors, throw or return 
wrong calculation results.
 
Each polygon is compound from one or more components. Component is a loop. Component represent solid element
or hole element, it depend on orientation of loop (counter-clockwise is solid element, clockwise is hole).
When polygon is created from more compounds, then each compound must be closed (first and last point are equal) and
first and last point of hole polygon are equal too. 
 
For better polygon creation you can use Polygon2DBuilder class.
 
 
Method resolution order:
Polygon2D
PolyPoints2D
Boost.Python.instance
builtins.object

Methods defined here:
GetSegments(...)
GetSegments( (Polygon2D)arg1) -> tuple :
    Get polygon segments
    
    Return: error code,
            vector of polygon segments
IsValid(...)
IsValid( (Polygon2D)arg1) -> bool :
    Check if the polygon is valid ( has at least 3 points )
    
    For additional point validation use Service::Validate.
    
    Service::Validate
    
    Return: true if is valid
Normalize(...)
Normalize( (Polygon2D)arg1, (ePolygonNormalizeType)normalizeType, (bool)extra_smooth) -> None :
    Normalize Polygon2D.
    
    Using huge old algorithm, adding points at line crossings, reorganizing the lines, correcting gaps, ...
    This method is checked and throwing Allplan::Geometry::Exception when error occurs.
    
    Parameter: normalizeType  type of Polygon2D normalization
               extra_smooth   Including extra smooth: true/false
NormalizeNoThrow(...)
NormalizeNoThrow( (Polygon2D)arg1, (ePolygonNormalizeType)normalizeType, (bool)extra_smooth) -> object :
    Normalize Polygon2D.
    
    Normalize
    
    ame as Normalize, but method doesn't throw exception, just return error code
    
    Parameter: normalizeType  type of Polygon2D normalization
               extra_smooth   Including extra smooth: true/false
    
    Return:    Error code (eOK, eAllocError, eStructuralError)
Reverse(...)
Reverse( (Polygon2D)arg1) -> None :
    Reverse the point order in polygon, separatelly for every subpolygon
__eq__(...)
__eq__( (Polygon2D)arg1, (Polygon2D)polygon) -> object :
    Comparison of polygons without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: polygons Compared polygon.
    
    Return: True when polygons are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (Point2D)point) -> object :
    Addition assignment operator
    
    Parameter: point  Point which will be added
    
    Return: Reference to polygon
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Polygon2D)polygon) -> None :
    Copy constructor.
    
    Parameter: polygon  Polygon which will be copied
__reduce__ = (...)
__repr__(...)
__repr__( (Polygon2D)arg1) -> str
__setitem__(...)
__setitem__( (Polygon2D)arg1, (int)arg2, (Point2D)arg3) -> None :
    Set the point by ...[index]

Data and other attributes defined here:
__instance_size__ = 64

Methods inherited from PolyPoints2D:
Clear(...)
Clear( (PolyPoints2D)arg1) -> None :
    Remove all points from vector.
Count(...)
Count( (PolyPoints2D)arg1) -> int :
    Get count of points.
    
    Return: bool.
Empty(...)
Empty( (PolyPoints2D)arg1) -> bool :
    Return true if no points, otherwise false.
    
    Return: bool.
EqualRef(...)
EqualRef( (PolyPoints2D)arg1, (PolyPoints2D)polyPoints) -> bool :
    Test if reference points are equal.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
    
    Return:  Reference points are equal: true/false
GetEndPoint(...)
GetEndPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the end point in world coordinate system.
    
    Return:  end point in world coordinate system
GetEndRelPoint(...)
GetEndRelPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the end point
    
    Return:  end point
GetLastPoint(...)
GetLastPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the last point in world coordinate system, copy of data.
    
    Return:  last point in world coordinate system
GetPoint(...)
GetPoint( (PolyPoints2D)arg1, (int)index) -> Point2D :
    Get point in world coordinate system, copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point point in world coordinate system.
GetPointIndex(...)
GetPointIndex( (PolyPoints2D)arg1, (Point2D)point) -> tuple :
    Get index of the given point
    
    Parameter: point  Searched point
    
    Return: True if a point was found,
            Found index
GetPointIndexes(...)
GetPointIndexes( (PolyPoints2D)arg1, (Point2D)point) -> tuple :
    Get indexes of the given point, in case that several points in the spline
    will have the same coordinates
    
    Parameter: point  Searched point
    
    Return: True if at least one point was found,
            Found indexes
GetRefPoint(...)
GetRefPoint( (PolyPoints2D)arg1) -> Point2D :
    Get reference point.
    
    Return: constant reference to the reference point in the world coordinate system.
GetRelPoint(...)
GetRelPoint( (PolyPoints2D)arg1, (int)index) -> Point2D :
    Get reference to point in Local coordinate system, no copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point constant reference to the point at position index.
GetStartPoint(...)
GetStartPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the start point in world coordinate system.
    
    Return:  start point in world coordinate system
GetStartRelPoint(...)
GetStartRelPoint( (PolyPoints2D)arg1) -> Point2D :
    Get the start point
    
    Return:  start point
Insert(...)
Insert( (PolyPoints2D)arg1, (PolyPoints2D)polyPoints, (int)position) -> bool :
    Insert vector of points at specific position.
    
    If return false then points weren't inserted.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
               position    position where points will be inserted.
    
    Return: bool true if successful.
 
Insert( (PolyPoints2D)arg1, (Point2D)point, (int)position) -> bool :
    Insert point at specific position. Used world coordinates.
    
    If return false then points weren't Inserted.
    
    Parameter: point     constant reference to the Point.
               position  position where points will be inserted.
    
    Return: bool true if successful.
Remove(...)
Remove( (PolyPoints2D)arg1, (int)position) -> bool :
    Remove point from specific position.
    
    If return false then points weren't removed.
    
    Parameter: position  position of point which will be removed.
    
    Return: return false;
RemoveLastPoint(...)
RemoveLastPoint( (PolyPoints2D)arg1) -> bool :
    Remove the last point
    
    Return:  Point removed: true/false
Reserve(...)
Reserve( (PolyPoints2D)arg1, (int)newCount) -> None :
    Reserve container capacity
    
    Parameter: newCount  Expected size of container [count of points]
Resize(...)
Resize( (PolyPoints2D)arg1, (int)newSize) -> None :
    Specifies a new size for the points vector.
    
    Parameter: newSize  The new size of the points vector.
SetEndPoint(...)
SetEndPoint( (PolyPoints2D)arg1, (Point2D)endpoint) -> None :
    Set the end point in world coordinates
    
    Parameter: endpoint  new end point
SetPoint(...)
SetPoint( (PolyPoints2D)arg1, (Point2D)point, (int)index) -> None :
    Set point at given position in world coordinate system.
    
    Parameter: point  point in the world coordinate system.
               index  index of point which will be set
SetRefPoint(...)
SetRefPoint( (PolyPoints2D)arg1, (Point2D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Parameter: refPoint  reference point in the world coordinate system.
SetRelPoint(...)
SetRelPoint( (PolyPoints2D)arg1, (Point2D)point, (int)index) -> None :
    Set point at given position in relative coordinate system.
    
    Parameter: point  point in the relative coordinate system.
               index  index of point which will be set
SetStartPoint(...)
SetStartPoint( (PolyPoints2D)arg1, (Point2D)startpoint) -> None :
    Set the start point in world coordinates
    
    Parameter: startpoint  new start point
ToLineChain(...)
ToLineChain( (PolyPoints2D)arg1) -> Point2DList :
    Get polyline as a chain of lines composed from 2 points.
    
    Return: vector of lines composed from 2 points (start and end point of a line)
__getitem__(...)
__getitem__( (PolyPoints2D)arg1, (int)arg2) -> Point2D :
    Get point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
    
    Return: copy of point.

Data descriptors inherited from PolyPoints2D:
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Polygon2DList(Boost.Python.instance)
    
Method resolution order:
Polygon2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Polygon2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Polygon2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Polygon2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Polygon2DList)arg1) -> str
__setitem__(...)
__setitem__( (Polygon2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Polygon2DList)arg1, (object)arg2) -> None
extend(...)
extend( (Polygon2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Polygon3D(PolyPoints3D)
    3D Polygon
 
 
Method resolution order:
Polygon3D
PolyPoints3D
Boost.Python.instance
builtins.object

Methods defined here:
GetPlane(...)
GetPlane( (Polygon3D)arg1) -> tuple :
    Calculate plane
    
    Return: Plane where polygon is
IsValid(...)
IsValid( (Polygon3D)arg1) -> bool :
    Check polygon validity
    
    Return: true = valid, false = not valid
IsValidStatus(...)
IsValidStatus( (Polygon3D)arg1) -> tuple :
    Check polygon validity
    
    Return: true = valid, false = not valid,
            If polygon is invalid, here is the reason.
Normalize(...)
Normalize( (Polygon3D)arg1, (ePolygonNormalizeType)normalizeType, (bool)extra_smooth) -> None :
    Normalization of 3d polygon
    
    Parameter: normalizeType  Normalization type
               extra_smooth   Increase level of details
NormalizeNoThrow(...)
NormalizeNoThrow( (Polygon3D)arg1, (ePolygonNormalizeType)normalizeType, (bool)extra_smooth) -> object :
    Normalize Polygon3D.
    
    Same as Normalize, but method doesn't throw exception, just return error code
    
    Parameter: normalizeType  type of normalization
               extra_smooth   Including extra smooth: true/false
    
    Return:    Error code (eOK, eAllocError, eStructuralError, eWrongShape)
Reverse(...)
Reverse( (Polygon3D)arg1) -> None :
    Reverse the point order in polygon, separately for every sub-polygon
__eq__(...)
__eq__( (Polygon3D)arg1, (Polygon3D)polygon) -> object :
    Comparison of polygons without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: polygon  Compared polygon.
    
    Return: True when polygons are equal, otherwise false.
__iadd__(...)
__iadd__( (object)arg1, (Polygon3D)polygon) -> object :
    Addition assignment operator
    
    Parameter: polygon  Polygon which will be copied
    
    Return: Reference to polygon
 
__iadd__( (object)arg1, (Point3D)point) -> object :
    Addition assignment operator
    
    Parameter: point  New Point3D which will be added to the polygon
    
    Return: Reference to polygon
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (Polygon3D)polygon) -> None :
    Copy constructor.
    
    Parameter: polygon  Polygon which will be copied
__mul__(...)
__mul__( (Polygon3D)arg1, (Matrix3D)matrix) -> object :
    Matrix transformation
    
    Parameter: matrix  Transformation matrix
    
    Return: Reference to polygon
__reduce__ = (...)
__repr__(...)
__repr__( (Polygon3D)arg1) -> str

Data and other attributes defined here:
__instance_size__ = 72

Methods inherited from PolyPoints3D:
Clear(...)
Clear( (PolyPoints3D)arg1) -> None :
    Remove all points from vector.
Count(...)
Count( (PolyPoints3D)arg1) -> int :
    Get count of points.
    
    Return: bool.
Empty(...)
Empty( (PolyPoints3D)arg1) -> bool :
    Return true if no points, otherwise false.
    
    Return: bool.
EqualRef(...)
EqualRef( (PolyPoints3D)arg1, (PolyPoints3D)polyPoints) -> bool :
    Test if reference points are equal.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
    
    Return:  Reference points are equal: true/false
GetEndPoint(...)
GetEndPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the end point in world coordinate system.
    
    Return:  end point in world coordinate system
GetEndRelPoint(...)
GetEndRelPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the end point
    
    Return:  end point
GetLastPoint(...)
GetLastPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the last point in world coordinate system, copy of data.
    
    Return:  last point in world coordinate system
GetPoint(...)
GetPoint( (PolyPoints3D)arg1, (int)index) -> Point3D :
    Get point in world coordinate system, copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point point in world coordinate system.
GetPointIndex(...)
GetPointIndex( (PolyPoints3D)arg1, (Point3D)point) -> tuple :
    Get index of the given point
    
    Parameter: point  Searched point
    
    Return: True if a point was found,
            Found index
GetPointIndexes(...)
GetPointIndexes( (PolyPoints3D)arg1, (Point3D)point) -> tuple :
    Get indexes of the given point, in case that several points in the spline
    will have the same coordinates
    
    Parameter: point  Searched point
    
    Return: True if at least one point was found,
            Found indexes
GetRefPoint(...)
GetRefPoint( (PolyPoints3D)arg1) -> Point3D :
    Get reference point.
    
    Return: constant reference to the reference point in the world coordinate system.
GetRelPoint(...)
GetRelPoint( (PolyPoints3D)arg1, (int)index) -> Point3D :
    Get reference to point in Local coordinate system, no copy of data.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    
    Parameter: index  point index.
    
    Return: point constant reference to the point at position index.
GetStartPoint(...)
GetStartPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the start point in world coordinate system.
    
    Return:  start point in world coordinate system
GetStartRelPoint(...)
GetStartRelPoint( (PolyPoints3D)arg1) -> Point3D :
    Get the start point
    
    Return:  start point
Insert(...)
Insert( (PolyPoints3D)arg1, (PolyPoints3D)polyPoints, (int)position) -> bool :
    Insert vector of points at specific position.
    
    If return false then points weren't inserted.
    
    Parameter: polyPoints  constant reference to the PolyPoints.
               position    position where points will be inserted.
    
    Return: bool true if successful.
 
Insert( (PolyPoints3D)arg1, (Point3D)point, (int)position) -> bool :
    Insert point at specific position. Used world coordinates.
    
    If return false then points weren't Inserted.
    
    Parameter: point     constant reference to the Point.
               position  position where points will be inserted.
    
    Return: bool true if successful.
Remove(...)
Remove( (PolyPoints3D)arg1, (int)position) -> bool :
    Remove point from specific position.
    
    If return false then points weren't removed.
    
    Parameter: position  position of point which will be removed.
    
    Return: return false;
RemoveLastPoint(...)
RemoveLastPoint( (PolyPoints3D)arg1) -> bool :
    Remove the last point
    
    Return:  Point removed: true/false
Reserve(...)
Reserve( (PolyPoints3D)arg1, (int)newCount) -> None :
    Reserve container capacity
    
    Parameter: newCount  Expected size of container [count of points]
Resize(...)
Resize( (PolyPoints3D)arg1, (int)newSize) -> None :
    Specifies a new size for the points vector.
    
    Parameter: newSize  The new size of the points vector.
SetEndPoint(...)
SetEndPoint( (PolyPoints3D)arg1, (Point3D)endpoint) -> None :
    Set the end point in world coordinates
    
    Parameter: endpoint  new end point
SetPoint(...)
SetPoint( (PolyPoints3D)arg1, (Point3D)point, (int)index) -> None :
    Set point at given position in world coordinate system.
    
    Parameter: point  point in the world coordinate system.
               index  index of point which will be set
SetRefPoint(...)
SetRefPoint( (PolyPoints3D)arg1, (Point3D)refPoint) -> None :
    Set reference point in world coordinate system.
    
    Parameter: refPoint  reference point in the world coordinate system.
SetRelPoint(...)
SetRelPoint( (PolyPoints3D)arg1, (Point3D)point, (int)index) -> None :
    Set point at given position in relative coordinate system.
    
    Parameter: point  point in the relative coordinate system.
               index  index of point which will be set
SetStartPoint(...)
SetStartPoint( (PolyPoints3D)arg1, (Point3D)startpoint) -> None :
    Set the start point in world coordinates
    
    Parameter: startpoint  new start point
ToLineChain(...)
ToLineChain( (PolyPoints3D)arg1) -> Point3DList :
    Get polyline as a chain of lines composed from 2 points.
    
    Return: vector of lines composed from 2 points (start and end point of a line)
__getitem__(...)
__getitem__( (PolyPoints3D)arg1, (int)arg2) -> Point3D :
    Get point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
    
    Return: copy of point.
__setitem__(...)
__setitem__( (PolyPoints3D)arg1, (int)arg2, (Point3D)arg3) -> None :
    Set point at position from index. Used world coordinates.
    
    This method is checked and throwing Geometry::Exception when index is out of range.
    Parameter: index  Specified position
               pnt    Point

Data descriptors inherited from PolyPoints3D:
EndPoint
Get and set the end point as property
EndRelPoint
Get the end point in the relative coordinate system as property
RefPoint
Get and set the reference point in world coordinate system as property
StartPoint
Get and set the start point as property
StartRelPoint
Get the start point in the relative coordinate system as property

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Polygon3DList(Boost.Python.instance)
    
Method resolution order:
Polygon3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (Polygon3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (Polygon3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (Polygon3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (Polygon3DList)arg1) -> str
__setitem__(...)
__setitem__( (Polygon3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (Polygon3DList)arg1, (object)arg2) -> None
extend(...)
extend( (Polygon3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolygonalArea(Boost.Python.instance)
    
Method resolution order:
PolygonalArea
Boost.Python.instance
builtins.object

Methods defined here:
AppendEdge(...)
AppendEdge( (PolygonalArea)arg1, (GeometryEdge)edge) -> object :
    Append edge (appendPolygonEdge).
    
    Parameter: edge  Appended edge.
    
    Return: Error code.
GetComponentsCount(...)
GetComponentsCount( (PolygonalArea)arg1) -> int :
    Get count of components.
    
    Return: Count of component.
GetEdge(...)
GetEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get edge.
    
    Parameter: edgeIndex  index of the edge.
    
    Return: Error code.,
            edge of polygon.
GetEdges(...)
GetEdges( (PolygonalArea)arg1) -> tuple :
    Get copy of all edges.
    
    Return: Error code.,
            vector of all edges.
GetEdgesCount(...)
GetEdgesCount( (PolygonalArea)arg1) -> int :
    Get count of edges.
    
    Return: Count of edges.
GetLoopEndEdgeIndex(...)
GetLoopEndEdgeIndex( (PolygonalArea)arg1, (int)loopIndex) -> int :
    Get the index of last edge of a loop.
    
    Parameter: loopIndex  index of loop.
    
    Return: Index of the last edge of the loop identified by the loopIndex value.
GetLoopsCount(...)
GetLoopsCount( (PolygonalArea)arg1) -> int :
    Get Count of loops.
    
    Return: Count of loops.
GetNeighborEdges(...)
GetNeighborEdges( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get neighbor edges.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            previous edge (edge which is before edge[index] in the chain).,
            next edge (edge which is after edge[index] in the chain).
GetNextEdge(...)
GetNextEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get next edge.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            next edge (edge which is after edge[index] in the chain).
GetPlane(...)
GetPlane( (PolygonalArea)arg1) -> tuple :
    Get plane if polygon is plane.
    
    Return: Error code.,
            polygon plane.
GetPrevEdge(...)
GetPrevEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get previous edge.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            previous edge (edge which is before edge[index] in the chain).
GetVector(...)
GetVector( (PolygonalArea)arg1) -> tuple :
    Get Normal vector if polygon is plane.
    
    Return: Error code.,
            normal vector to the polygon plane.
GetVerticesCount(...)
GetVerticesCount( (PolygonalArea)arg1) -> int :
    Get count of vertices.
    
    Return: Count of vertices.
SetPlane(...)
SetPlane( (PolygonalArea)arg1, (Plane3D)plane) -> None :
    Set plane.
    
    Parameter: plane  plane which will be set.
SetVector(...)
SetVector( (PolygonalArea)arg1, (Vector3D)vec) -> object :
    Set normal vector.
    
    Parameter: vec  vector which will be set.
    
    Return: Error code.
__init__(...)
Raises an exception
This class cannot be instantiated from Python
__reduce__ = (...)

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolygonalArea2D(PolygonalArea)
    2D polygonal area
class for 2D polygonal area geometry
 
 
Method resolution order:
PolygonalArea2D
PolygonalArea
Boost.Python.instance
builtins.object

Methods defined here:
AppendRelVertex(...)
AppendRelVertex( (PolygonalArea2D)arg1, (Point2D)vertex) -> tuple :
    Append vertex in local coordinate system.
    
    Warning: method does not update edges.
    
    Parameter: vertex  vertex in local coordinate system which will be appended.
    
    Return: Error code.,
            index of vertex
AppendVertex(...)
AppendVertex( (PolygonalArea2D)arg1, (Point2D)vertex) -> tuple :
    Append vertex in World coordinate system.
    
    Warning: method does not update edges.
    
    Parameter: vertex  vertex in world coordinate system which will be appended.
    
    Return: Error code.,
            index of vertex
EqualRef(...)
EqualRef( (PolygonalArea2D)arg1, (PolygonalArea2D)polygon) -> bool :
    Test for equal reference points.
    
    Parameter: polygon  polygon for comparision.
    
    Return: True if reference points are equal else return false.
GetEdgeVertices(...)
GetEdgeVertices( (PolygonalArea2D)arg1, (int)edgeIndex) -> tuple :
    Get edge vertices.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            start point of the edge in world coordinate system.,
            end point of the edge in world coordinate system.
GetPolygon(...)
GetPolygon( (PolygonalArea2D)arg1) -> tuple :
    Get polygon.
    
    Old interface: pgon_to_punkte
    
    Return: Error code.,
            polygon.
GetRefPoint(...)
GetRefPoint( (PolygonalArea2D)arg1) -> Point2D :
    Get the reference point.
    
    Return: constant reference to point.
GetRelVertex(...)
GetRelVertex( (PolygonalArea2D)arg1, (int)vertexIndex) -> tuple :
    Get vertex in Local coordinate system.
    
    Parameter: vertexIndex  vertex index.
    
    Return: Error code.,
            vertex in local coordinate system.
GetVertex(...)
GetVertex( (PolygonalArea2D)arg1, (int)vertexIndex) -> tuple :
    Get vertex in World coordinate system.
    
    Parameter: vertexIndex  vertex index.
    
    Return: Error code.,
            vertex in world coordinate system.
SetRefPoint(...)
SetRefPoint( (PolygonalArea2D)arg1, (Point2D)refPoint) -> object :
    Set reference point in world coordinate system.
    
    Coordinates of points will be recalculated with new reference point.
    
    Parameter: refPoint  new reference point.
    
    Return: Error code.
__eq__(...)
__eq__( (PolygonalArea2D)arg1, (PolygonalArea2D)polygonalArea) -> object :
    Comparison of polygonalAreas without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: polygonalArea Compared polygonalArea.
    
    Return: True when polygonalAreas are equal, otherwise false.
__getitem__(...)
__getitem__( (PolygonalArea2D)arg1, (int)vertexIndex) -> Point2D :
    Get point at position from index. Used world coordinates.
    
    Parameter: vertexIndex  vertex index.
    
    Return: Copy of vertex[vertexIndex] in world coordinates.
__iadd__(...)
__iadd__( (object)arg1, (PolygonalArea2D)polygonalarea) -> object :
    Append polygon.
    
    Parameter: polygonalarea  polygonal area which will be appended.
    
    Return: Reference to PolygonalArea2D.
 
__iadd__( (object)arg1, (Polygon2D)polygon) -> object :
    Append loop.
    
    Parameter: polygon  polygon which will be appended.
    
    Return: Reference to PolygonalArea2D.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (int)verticesCount, (int)edgesCount) -> None :
    Default constructor.
    
    Create initialized 2D polygonal area with expected vertices and edges count.
 
__init__( (object)arg1, (Point2D)refPoint, (int)verticesCount, (int)edgesCount) -> None :
    Default constructor.
    
    Create initialized 2D polygonal area with expected vertices and edges count.
 
__init__( (object)arg1, (PolygonalArea2D)polygon) -> None :
    Copy constructor.
    
    Parameter: polygon  2D polygon which will be copied.
__mul__(...)
__mul__( (PolygonalArea2D)arg1, (Matrix2D)matrix) -> object :
    Matrix transformation.
    
    Parameter: matrix  point index.
    
    Return: Transformed 2D polygonal area.
__reduce__ = (...)
__repr__(...)
__repr__( (PolygonalArea2D)arg1) -> str

Data descriptors defined here:
RefPoint
Get and set the reference point in world coordinate system as property

Data and other attributes defined here:
__instance_size__ = 40

Methods inherited from PolygonalArea:
AppendEdge(...)
AppendEdge( (PolygonalArea)arg1, (GeometryEdge)edge) -> object :
    Append edge (appendPolygonEdge).
    
    Parameter: edge  Appended edge.
    
    Return: Error code.
GetComponentsCount(...)
GetComponentsCount( (PolygonalArea)arg1) -> int :
    Get count of components.
    
    Return: Count of component.
GetEdge(...)
GetEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get edge.
    
    Parameter: edgeIndex  index of the edge.
    
    Return: Error code.,
            edge of polygon.
GetEdges(...)
GetEdges( (PolygonalArea)arg1) -> tuple :
    Get copy of all edges.
    
    Return: Error code.,
            vector of all edges.
GetEdgesCount(...)
GetEdgesCount( (PolygonalArea)arg1) -> int :
    Get count of edges.
    
    Return: Count of edges.
GetLoopEndEdgeIndex(...)
GetLoopEndEdgeIndex( (PolygonalArea)arg1, (int)loopIndex) -> int :
    Get the index of last edge of a loop.
    
    Parameter: loopIndex  index of loop.
    
    Return: Index of the last edge of the loop identified by the loopIndex value.
GetLoopsCount(...)
GetLoopsCount( (PolygonalArea)arg1) -> int :
    Get Count of loops.
    
    Return: Count of loops.
GetNeighborEdges(...)
GetNeighborEdges( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get neighbor edges.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            previous edge (edge which is before edge[index] in the chain).,
            next edge (edge which is after edge[index] in the chain).
GetNextEdge(...)
GetNextEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get next edge.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            next edge (edge which is after edge[index] in the chain).
GetPlane(...)
GetPlane( (PolygonalArea)arg1) -> tuple :
    Get plane if polygon is plane.
    
    Return: Error code.,
            polygon plane.
GetPrevEdge(...)
GetPrevEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get previous edge.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            previous edge (edge which is before edge[index] in the chain).
GetVector(...)
GetVector( (PolygonalArea)arg1) -> tuple :
    Get Normal vector if polygon is plane.
    
    Return: Error code.,
            normal vector to the polygon plane.
GetVerticesCount(...)
GetVerticesCount( (PolygonalArea)arg1) -> int :
    Get count of vertices.
    
    Return: Count of vertices.
SetPlane(...)
SetPlane( (PolygonalArea)arg1, (Plane3D)plane) -> None :
    Set plane.
    
    Parameter: plane  plane which will be set.
SetVector(...)
SetVector( (PolygonalArea)arg1, (Vector3D)vec) -> object :
    Set normal vector.
    
    Parameter: vec  vector which will be set.
    
    Return: Error code.

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolygonalArea2DList(Boost.Python.instance)
    
Method resolution order:
PolygonalArea2DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (PolygonalArea2DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (PolygonalArea2DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (PolygonalArea2DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (PolygonalArea2DList)arg1) -> str
__setitem__(...)
__setitem__( (PolygonalArea2DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (PolygonalArea2DList)arg1, (object)arg2) -> None
extend(...)
extend( (PolygonalArea2DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolygonalArea3D(PolygonalArea)
    3D polygonal area
class for 3D polygonal area geometry
 
 
Method resolution order:
PolygonalArea3D
PolygonalArea
Boost.Python.instance
builtins.object

Methods defined here:
AppendRelVertex(...)
AppendRelVertex( (PolygonalArea3D)arg1, (Point3D)vertex) -> tuple :
    Append vertex in local coordinate system.
    
    Warning: method does not update edges.
    
    Parameter: vertex  vertex in local coordinate system which will be appended.
    
    Return: Error code.,
            index of vertex
AppendVertex(...)
AppendVertex( (PolygonalArea3D)arg1, (Point3D)vertex) -> tuple :
    Append vertex in World coordinate system.
    
    Warning: method does not update edges.
    
    Parameter: vertex  vertex in world coordinate system which will be appended.
    
    Return: Error code.,
            index of vertex
EqualRef(...)
EqualRef( (PolygonalArea3D)arg1, (PolygonalArea3D)polygon) -> bool :
    Test for equal reference points.
    
    Parameter: polygon  polygonal area for comparision.
    
    Return: True if reference points are equal else return false.
GetEdgeVertices(...)
GetEdgeVertices( (PolygonalArea3D)arg1, (int)edgeIndex) -> tuple :
    Get edge vertices.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            start point of the edge in world coordinate system.,
            end point of the edge in world coordinate system.
GetPolygon(...)
GetPolygon( (PolygonalArea3D)arg1) -> tuple :
    Get polygon.
    
    Returns empty polygon, if it has zero edges.
    
    Return: Error code.,
            polygon.
GetRefPoint(...)
GetRefPoint( (PolygonalArea3D)arg1) -> Point3D :
    Get the reference point.
    
    Return: constant reference to point.
GetRelVertex(...)
GetRelVertex( (PolygonalArea3D)arg1, (int)vertexIndex) -> tuple :
    Get vertex in Local coordinate system.
    
    Parameter: vertexIndex  vertex index.
    
    Return: vertex in local coordinate system.
GetVertex(...)
GetVertex( (PolygonalArea3D)arg1, (int)vertexIndex) -> tuple :
    Get vertex in World coordinate system.
    
    Parameter: vertexIndex  vertex index.
    
    Return: Error code.,
            vertex in world coordinate system.
Reverse(...)
Reverse( (PolygonalArea3D)arg1) -> object :
    Reverse the point order of boundary polygons of the area.
    
    Return:  Error code.
SetRefPoint(...)
SetRefPoint( (PolygonalArea3D)arg1, (Point3D)refPoint) -> object :
    Set reference point in world coordinate system.
    
    Coordinates of points will be recalculated with new reference point.
    
    Parameter: refPoint  new reference point.
    Return: Error code.
__eq__(...)
__eq__( (PolygonalArea3D)arg1, (PolygonalArea3D)polygonalArea) -> object :
    Comparison of polygonalAreas without tolerance.
    
    Be careful, this method work without tolerance!
    
    Parameter: polygonalArea Compared polygonalArea.
    
    Return: True when polygonalAreas are equal, otherwise false.
__getitem__(...)
__getitem__( (PolygonalArea3D)arg1, (int)arg2) -> Point3D :
    Get point at position from index. Used world coordinates.
    
    Parameter: vertexIndex  vertex index.
    
    Return: Copy of vertex[vertexIndex] in world coordinates.
__iadd__(...)
__iadd__( (object)arg1, (PolygonalArea3D)polygonalarea) -> object :
    Append polygon.
    
    Parameter: polygonalarea  polygonal area which will be appended.
    
    Return: Reference to PolygonalArea3D.
 
__iadd__( (object)arg1, (Polygon3D)polygon) -> object :
    Append loop.
    
    Parameter: polygon  polygonal area which will be appended.
    
    Return: Reference to PolygonalArea3D.
__init__(...)
__init__( (object)arg1) -> None
 
__init__( (object)arg1, (int)verticesCount, (int)edgesCount) -> None :
    Default constructor.
    
    Create initialized 3D polygonal area with expected vertices and edges count.
 
__init__( (object)arg1, (Point3D)refPoint, (int)verticesCount, (int)edgesCount) -> None :
    Default constructor.
    
    Create initialized 3D polygonal area with expected vertices and edges count.
 
__init__( (object)arg1, (PolygonalArea3D)polygon) -> None :
    Copy constructor.
    
    Parameter: polygon  3D polygonal area which will be copied.
__mul__(...)
__mul__( (PolygonalArea3D)arg1, (Matrix2D)matrix) -> object :
    2D matrix transformation.
    
    Parameter: matrix  2D transformation matrix.
    
    Return: Transformed 3D polygon area.
 
__mul__( (PolygonalArea3D)arg1, (Matrix3D)matrix) -> object :
    3D matrix transformation.
    
    Parameter: matrix  3D transformation matrix.
    
    Return: Transformed 3D polygon area.
__reduce__ = (...)
__repr__(...)
__repr__( (PolygonalArea3D)arg1) -> str

Data descriptors defined here:
RefPoint
Get and set the reference point in world coordinate system as property

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from PolygonalArea:
AppendEdge(...)
AppendEdge( (PolygonalArea)arg1, (GeometryEdge)edge) -> object :
    Append edge (appendPolygonEdge).
    
    Parameter: edge  Appended edge.
    
    Return: Error code.
GetComponentsCount(...)
GetComponentsCount( (PolygonalArea)arg1) -> int :
    Get count of components.
    
    Return: Count of component.
GetEdge(...)
GetEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get edge.
    
    Parameter: edgeIndex  index of the edge.
    
    Return: Error code.,
            edge of polygon.
GetEdges(...)
GetEdges( (PolygonalArea)arg1) -> tuple :
    Get copy of all edges.
    
    Return: Error code.,
            vector of all edges.
GetEdgesCount(...)
GetEdgesCount( (PolygonalArea)arg1) -> int :
    Get count of edges.
    
    Return: Count of edges.
GetLoopEndEdgeIndex(...)
GetLoopEndEdgeIndex( (PolygonalArea)arg1, (int)loopIndex) -> int :
    Get the index of last edge of a loop.
    
    Parameter: loopIndex  index of loop.
    
    Return: Index of the last edge of the loop identified by the loopIndex value.
GetLoopsCount(...)
GetLoopsCount( (PolygonalArea)arg1) -> int :
    Get Count of loops.
    
    Return: Count of loops.
GetNeighborEdges(...)
GetNeighborEdges( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get neighbor edges.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            previous edge (edge which is before edge[index] in the chain).,
            next edge (edge which is after edge[index] in the chain).
GetNextEdge(...)
GetNextEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get next edge.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            next edge (edge which is after edge[index] in the chain).
GetPlane(...)
GetPlane( (PolygonalArea)arg1) -> tuple :
    Get plane if polygon is plane.
    
    Return: Error code.,
            polygon plane.
GetPrevEdge(...)
GetPrevEdge( (PolygonalArea)arg1, (int)edgeIndex) -> tuple :
    Get previous edge.
    
    Parameter: edgeIndex  edge index.
    
    Return: Error code.,
            previous edge (edge which is before edge[index] in the chain).
GetVector(...)
GetVector( (PolygonalArea)arg1) -> tuple :
    Get Normal vector if polygon is plane.
    
    Return: Error code.,
            normal vector to the polygon plane.
GetVerticesCount(...)
GetVerticesCount( (PolygonalArea)arg1) -> int :
    Get count of vertices.
    
    Return: Count of vertices.
SetPlane(...)
SetPlane( (PolygonalArea)arg1, (Plane3D)plane) -> None :
    Set plane.
    
    Parameter: plane  plane which will be set.
SetVector(...)
SetVector( (PolygonalArea)arg1, (Vector3D)vec) -> object :
    Set normal vector.
    
    Parameter: vec  vector which will be set.
    
    Return: Error code.

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class PolygonalArea3DList(Boost.Python.instance)
    
Method resolution order:
PolygonalArea3DList
Boost.Python.instance
builtins.object

Methods defined here:
__contains__(...)
__contains__( (PolygonalArea3DList)arg1, (object)arg2) -> bool
__delitem__(...)
__delitem__( (PolygonalArea3DList)arg1, (object)arg2) -> None
__getitem__(...)
__getitem__( (object)arg1, (object)arg2) -> object
__init__(...)
__init__( (object)arg1) -> None
__iter__(...)
__iter__( (object)arg1) -> object
__len__(...)
__len__( (PolygonalArea3DList)arg1) -> int
__reduce__ = (...)
__repr__(...)
__repr__( (PolygonalArea3DList)arg1) -> str
__setitem__(...)
__setitem__( (PolygonalArea3DList)arg1, (object)arg2, (object)arg3) -> None
append(...)
append( (PolygonalArea3DList)arg1, (object)arg2) -> None
extend(...)
extend( (PolygonalArea3DList)arg1, (object)arg2) -> None

Data and other attributes defined here:
__instance_size__ = 48

Methods inherited from Boost.Python.instance:
__new__(*args, **kwargs) from Boost.Python.class
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

 
class Polyhedron3D(Boost.Python.instance)
    3D polyhedronPolyhedron3D represents a 3D solid defined by vertices, edges and faces.
Polyhedron includes table of vertices, table of edges and table of faces.
Each table is zero based indexed. Edge is defined via GeometryEdge as
two indices into vertices table. Geometry edge is default oriented from 
start to end index.
Face is defined via PolyhedronFace as a vector of oriented edges.
Oriented edge (OrientedEdge) has EdgeHandle and orientation flag.
EdgeHandle is index into polyhedron table of all edges, it mean that values
of EdgeHandle can be from range [0..EdgesCount-1]. This handle can be
increased and decreased in standard way. When orientation flag is true,
then orientation is same as GeometryEdge (from Start to End index), if flag is false then
orientation is backward (from End to Start index).
 
 
Sample of code
 
Polyhedron3D polyhedron(tEdges, 4/vertices/, 4/edges/, 1/faces/, false/positive orientation/);
 
//APPEND VERTICES
int err = polyhedron.AppendVertex(Point3D(0., 0., 0.));
assert(err==eOK);
err = polyhedron.AppendVertex(Point3D(10., 0., 0.));
assert(err==eOK);
// append next vertices ...
 
// APPEND EDGES
GeometryEdge edge1(0,1), edge2(1,2), edge3(2,3);
err = polyhedron.AppendEdge(edge1);
assert(err==eOK);
// append next edges ...
 
// APPEND FACES
PolyhedronFace face = polyhedron.CreateFace(3/expected edges/);
face.AppendEdge(OrientedEdge(0/EdgeHandle/, true /orientation from start to end index/
// append next edges into face ...
 
 
Method resolution order:
Polyhedron3D
Boost.Python.instance
builtins.object

Methods defined here:
AppendEdge(...)
AppendEdge( (Polyhedron3D)arg1, (GeometryEdge)edge) -> object :
    Append edge
    
    Method throw exception if object is not initialized.
    
    Parameter: edge  Appended edge.
    
    Return: Error code.
Clear(...)
Clear( (Polyhedron3D)arg1) -> None :
    Clear all vertices, edges and faces
    
    Type and vertices,edges,faces preallocation size of polyhedron will be preserved
 
Clear( (Polyhedron3D)arg1, (int)verticesCount, (int)edgesCount, (int)facesCount, (bool)negativeOrientation) -> None :
    Clear all vertices, edges and faces
    
    The Count parameters have sense only for appropriate polyhedron type and
    specified a memory allocation size - performance optimization. 
    In case of any error, constructor throw an exception.
    
    Parameter: verticesCount        Count of expected vertices.
               edgesCount           Count of expected edges.
               facesCount           Count of expected faces.
               negativeOrientation  True for negative orientation.
CreateCuboid(...)
CreateCuboid( (Point3D)p1, (Point3D)p2) -> Polyhedron3D :
    static constructor for cuboid
    
    Parameter: p1  lower point of min/max box that states the cuboid's size
               p2  lower point of min/max box that states the cuboid's size
 
CreateCuboid( (MinMax3D)box) -> Polyhedron3D :
    static constructor for cuboid
    
    Parameter: box  min/max box that states the cuboid's size
 
CreateCuboid( (float)dx, (float)dy, (float)dz) -> Polyhedron3D :
    Create the cuboid from the three size values
    
    Parameter: dx  cuboid's size in x direction
               dy  cuboid's size in y direction
               dz  cuboid's size in z direction
CreateFace(...)
CreateFace( (Polyhedron3D)arg1, (int)expectedEdges) -> PolyhedronFace :
    Create face and append it to polyhedron
    
    Method throw exception if object is not initialized.
    
    Parameter: expectedEdges  Appended face.
    
    Return: Created face.
DeleteEdge(...)
DeleteEdge( (Polyhedron3D)arg1, (int)edgeHandle) -> object :
    Delete edge
    
    Method throw exception if object is not initialized.
    
    Parameter: edgeHandle  Edge to delete
    
    Return: Error code.
DeleteFace(...)
DeleteFace( (Polyhedron3D)arg1, (int)faceIndex) -> object :
    Delete face at specified position
    
    Method throw exception in case of any error.
    
    Parameter: faceIndex  Position of the deleted face. Zero based.
    
    Return: Error code.
EqualRef(...)
EqualRef( (Polyhedron3D)arg1, (Polyhedron3D)polyhedron) -> bool :
    Test for equal reference point
    
    Parameter: polyhedron  Tested polyhedron.
    
    Return: True when both polyhedrons has the same reference point.
GetEdge(...)
GetEdge( (Polyhedron3D)arg1, (int)edgeHandle) -> tuple :
    Get edge at the specified position
    
    
    Parameter: edgeHandle  Specified position of the edge.
    
    Return: Error code.,
            Filled edge.
 
GetEdge( (Polyhedron3D)arg1, (OrientedEdge)orientedEdge) -> tuple :
    Get edge at the specified position with orientation
    
    Parameter: orientedEdge  Specified position and orientation of the edge.
    
    Return: Error code.,
            Filled edge.
GetEdgeVertices(...)
GetEdgeVertices( (Polyhedron3D)arg1, (OrientedEdge)orientedEdge) -> tuple :
    Get points on specified edge from specified face
    
    Method throw exception in case of any error.
    
    Parameter: orientedEdge  Oriented edge.
    
    Return: Error code.,
            StartVertex.,
            EndVertex.
GetEdges(...)
GetEdges( (Polyhedron3D)arg1) -> tuple :
    Get copy of all edges
    
    
    Return: Error code.,
            in List of edges.
GetEdgesCount(...)
GetEdgesCount( (Polyhedron3D)arg1) -> int :
    Get count of edges
    
    Method throw exception in case of any error.
    
    Return: Count of edges.
GetFace(...)
GetFace( (Polyhedron3D)arg1, (int)faceIndex) -> PolyhedronFace :
    Get face at the specified position
    
    In case of error, method throw an exception.
    Old interface: getPolyederFaceP
    
    Parameter: faceIndex  Specified position of the face.
    
    Return: Face.
GetFacesCount(...)
GetFacesCount( (Polyhedron3D)arg1) -> int :
    Get count of faces
    
    Method throw exception in case of any error.
    
    Return: Count of faces.
GetNormalVectorOfFace(...)
GetNormalVectorOfFace( (Polyhedron3D)arg1, (int)faceIndex) -> tuple :
    Get normal vector of the face
    
    Parameter: faceIndex  face index
    
    Return:  error code,
            result normal vector
GetParts(...)
GetParts( (Polyhedron3D)arg1) -> tuple :
    Get separated parts (continuos shells)
    
    Return:  error code,
             List of separated bodies
GetPartsCount(...)
GetPartsCount( (Polyhedron3D)arg1) -> int :
    Get number of parts in this polyhedron
    
    Return:  number of parts
GetRefPoint(...)
GetRefPoint( (Polyhedron3D)arg1) -> Point3D :
    Get the reference point
    
    Return: Constant reference to reference point.
GetRelVertex(...)
GetRelVertex( (Polyhedron3D)arg1, (int)index) -> tuple :
    Get relative vertex at specified position
    
    Method throw exception in case of any error. (usually out of range)
    
    Parameter: index  Specified position.
    
    Return: Error code,
            out Vertex in Local coordinate system.
GetType(...)
GetType( (Polyhedron3D)arg1) -> PolyhedronType :
    Get polyhedron type
    
    Exception: Allplan::Geometry::Exception
    
    In case of error, method return tEdges.
    
    Return: Type.
GetVertex(...)
GetVertex( (Polyhedron3D)arg1, (int)vertexIndex) -> tuple :
    Get vertex at specified position
    
    Method throw exception in case of any error.
    
    Parameter: vertexIndex  Specified position of vertex.
    
    Return: Error code.,
            Vertex at specified position in World coordinate system.
GetVertices(...)
GetVertices( (Polyhedron3D)arg1) ->