Vectors and positions

class geom.Pos2d

Bases: geom.ProtoGeom

dist((Pos2d)arg1, (Pos2d)arg2) → float :

distance to a point.

C++ signature :
double dist(Pos2d {lvalue},Pos2d)
dist( (Pos2d)arg1, (Line2d)arg2) -> float :

distance to a straight line.

C++ signature :
double dist(Pos2d {lvalue},Line2d)
dist( (Pos2d)arg1, (Ray2d)arg2) -> float :

distance to a ray.

C++ signature :
double dist(Pos2d {lvalue},Ray2d)
dist( (Pos2d)arg1, (Segment2d)arg2) -> float :

distance to a segment.

C++ signature :
double dist(Pos2d {lvalue},Segment2d)
dist2((Pos2d)arg1, (Pos2d)arg2) → float :

squared distance to a point.

C++ signature :
double dist2(Pos2d {lvalue},Pos2d)
dist2( (Pos2d)arg1, (Line2d)arg2) -> float :

squared distance to a straight line.

C++ signature :
double dist2(Pos2d {lvalue},Line2d)
dist2( (Pos2d)arg1, (Ray2d)arg2) -> float :

squared distance to a ray.

C++ signature :
double dist2(Pos2d {lvalue},Ray2d)
dist2( (Pos2d)arg1, (Segment2d)arg2) -> float :

squared distance to a segment.

C++ signature :
double dist2(Pos2d {lvalue},Segment2d)
getDimension((Pos2d)arg1) → int :

return the dimension of the object.

C++ signature :
unsigned long getDimension(Pos2d {lvalue})
getPositionVector((Pos2d)arg1) → Vector2d :

return position vector of the point.

C++ signature :
Vector2d getPositionVector(Pos2d {lvalue})
class geom.mt_pos2d

Bases: xc_base.ProtoMatrix

size((mt_pos2d)arg1) → int :
C++ signature :
unsigned long size(TMatrix<Pos2d, std::vector<Pos2d, std::allocator<Pos2d> > > {lvalue})
class geom.m_pos2d

Bases: geom.mt_pos2d

class geom.MatrixPos2d

Bases: geom.m_pos2d

In((MatrixPos2d)arg1, (Pos2d)arg2, (float)arg3) → bool :
C++ signature :
bool In(Pos2dArray {lvalue},Pos2d,double)
Ix((MatrixPos2d)arg1) → float :
C++ signature :
double Ix(Pos2dArray {lvalue})
Iy((MatrixPos2d)arg1) → float :
C++ signature :
double Iy(Pos2dArray {lvalue})
Lagrange((MatrixPos2d)arg1, (float)arg2) → float :
C++ signature :
double Lagrange(Pos2dArray {lvalue},double)
Pxy((MatrixPos2d)arg1) → float :
C++ signature :
double Pxy(Pos2dArray {lvalue})
Transform((MatrixPos2d)arg1, (Trf2d)arg2) → None :
C++ signature :
void Transform(Pos2dArray {lvalue},Trf2d)
getArea((MatrixPos2d)arg1) → float :

Return the total area.

C++ signature :
double getArea(Pos2dArray {lvalue})
getAreaQuad((MatrixPos2d)arg1, (int)arg2, (int)arg3) → float :
C++ signature :
double getAreaQuad(Pos2dArray {lvalue},unsigned long,unsigned long)
getCenter((MatrixPos2d)arg1) → Pos2d :
C++ signature :
Pos2d getCenter(Pos2dArray {lvalue})
getCenterOfMass((MatrixPos2d)arg1) → Pos2d :
C++ signature :
Pos2d getCenterOfMass(Pos2dArray {lvalue})
getIx((MatrixPos2d)arg1) → float :
C++ signature :
double getIx(Pos2dArray {lvalue})
getIy((MatrixPos2d)arg1) → float :
C++ signature :
double getIy(Pos2dArray {lvalue})
getMax((MatrixPos2d)arg1, (int)arg2) → float :
C++ signature :
double getMax(Pos2dArray {lvalue},unsigned short)
getMin((MatrixPos2d)arg1, (int)arg2) → float :
C++ signature :
double getMin(Pos2dArray {lvalue},unsigned short)
getNumPoints((MatrixPos2d)arg1) → int :
C++ signature :
unsigned long getNumPoints(Pos2dArray {lvalue})
getNumQuads((MatrixPos2d)arg1) → int :
C++ signature :
unsigned long getNumQuads(Pos2dArray {lvalue})
getPoint((MatrixPos2d)arg1, (int)arg2, (int)arg3) → Pos2d :
C++ signature :
Pos2d getPoint(Pos2dArray {lvalue},unsigned long,unsigned long)
getPxy((MatrixPos2d)arg1) → float :
C++ signature :
double getPxy(Pos2dArray {lvalue})
getQuad((MatrixPos2d)arg1, (int)arg2, (int)arg3) → Quadrilateral2d :

Return the area of the (i,j) quad.

C++ signature :
Quadrilateral2d getQuad(Pos2dArray {lvalue},unsigned long,unsigned long)
getQuadCentroid((MatrixPos2d)arg1, (int)arg2, (int)arg3) → Pos2d :
C++ signature :
Pos2d getQuadCentroid(Pos2dArray {lvalue},unsigned long,unsigned long)
getTriangle1((MatrixPos2d)arg1, (int)arg2, (int)arg3) → Triangle2d :
C++ signature :
Triangle2d getTriangle1(Pos2dArray {lvalue},unsigned long,unsigned long)
getTriangle2((MatrixPos2d)arg1, (int)arg2, (int)arg3) → Triangle2d :
C++ signature :
Triangle2d getTriangle2(Pos2dArray {lvalue},unsigned long,unsigned long)
getX((MatrixPos2d)arg1, (int)arg2, (int)arg3) → float :
C++ signature :
double getX(Pos2dArray {lvalue},unsigned long,unsigned long)
getY((MatrixPos2d)arg1, (int)arg2, (int)arg3) → float :
C++ signature :
double getY(Pos2dArray {lvalue},unsigned long,unsigned long)
class geom.Vector2d

Bases: geom.ProtoGeom

dot((Vector2d)arg1, (Vector2d)arg2) → float :

Returns scalar product.

C++ signature :
double dot(Vector2d {lvalue},Vector2d)
getAngle((Vector2d)arg1, (Vector2d)arg2) → float :

Return the angle with the vector argumnet (order is important)

C++ signature :
double getAngle(Vector2d {lvalue},Vector2d)
getModulus((Vector2d)arg1) → float :

Return the modulus of the vector.

C++ signature :
double getModulus(Vector2d {lvalue})
getNormalVector((Vector2d)arg1) → Vector2d :

Return a vector normal to this one.

C++ signature :
Vector2d getNormalVector(Vector2d {lvalue})
getXAxisAngle((Vector2d)arg1) → float :
C++ signature :
double getXAxisAngle(Vector2d {lvalue})
getYAxisAngle((Vector2d)arg1) → float :
C++ signature :
double getYAxisAngle(Vector2d {lvalue})
normalized((Vector2d)arg1) → Vector2d :

Return the normalized vector (vector with norm 1).

C++ signature :
Vector2d normalized(Vector2d {lvalue})
class geom.Dir3d

Bases: Boost.Python.instance

class geom.Vector3d

Bases: geom.ProtoGeom

cross((Vector3d)arg1, (Vector3d)arg2) → Vector3d :
C++ signature :
Vector3d cross(Vector3d {lvalue},Vector3d)
dot((Vector3d)arg1, (Vector3d)arg2) → float :

Returns scalar product.

C++ signature :
double dot(Vector3d {lvalue},Vector3d)
getAngle((Vector3d)arg1, (Vector3d)arg2) → float :

Return the angle with the vector argument (order is important)

C++ signature :
double getAngle(Vector3d {lvalue},Vector3d)
getAzimuthalAngle((Vector3d)arg1) → float :

Return the azimuthal angle (spherical coordinates)

C++ signature :
double getAzimuthalAngle(Vector3d {lvalue})
getModulus((Vector3d)arg1) → float :
C++ signature :
double getModulus(Vector3d {lvalue})
getPolarAngle((Vector3d)arg1) → float :

Return the polar angle (spherical coordinates)

C++ signature :
double getPolarAngle(Vector3d {lvalue})
normalized((Vector3d)arg1) → Vector3d :

Return the normalized vector (vector with norm 1).

C++ signature :
Vector3d normalized(Vector3d {lvalue})
perpendicular((Vector3d)arg1, (Vector3d)arg2) → Vector3d :
C++ signature :
Vector3d perpendicular(Vector3d {lvalue},Vector3d)
class geom.Pos3d

Bases: geom.ProtoGeom

dist((Pos3d)arg1, (Pos3d)arg2) → float :
C++ signature :
double dist(Pos3d {lvalue},Pos3d)

dist( (Pos3d)arg1, (Line3d)arg2) -> float :

C++ signature :
double dist(Pos3d {lvalue},Line3d)

dist( (Pos3d)arg1, (Ray3d)arg2) -> float :

C++ signature :
double dist(Pos3d {lvalue},Ray3d)

dist( (Pos3d)arg1, (Segment3d)arg2) -> float :

C++ signature :
double dist(Pos3d {lvalue},Segment3d)

dist( (Pos3d)arg1, (Plane3d)arg2) -> float :

C++ signature :
double dist(Pos3d {lvalue},Plane)

dist( (Pos3d)arg1, (HalfSpace3d)arg2) -> float :

C++ signature :
double dist(Pos3d {lvalue},HalfSpace3d)
dist2((Pos3d)arg1, (Pos3d)arg2) → float :
C++ signature :
double dist2(Pos3d {lvalue},Pos3d)

dist2( (Pos3d)arg1, (Line3d)arg2) -> float :

C++ signature :
double dist2(Pos3d {lvalue},Line3d)

dist2( (Pos3d)arg1, (Ray3d)arg2) -> float :

C++ signature :
double dist2(Pos3d {lvalue},Ray3d)

dist2( (Pos3d)arg1, (Segment3d)arg2) -> float :

C++ signature :
double dist2(Pos3d {lvalue},Segment3d)

dist2( (Pos3d)arg1, (Plane3d)arg2) -> float :

C++ signature :
double dist2(Pos3d {lvalue},Plane)

dist2( (Pos3d)arg1, (HalfSpace3d)arg2) -> float :

C++ signature :
double dist2(Pos3d {lvalue},HalfSpace3d)
getDimension((Pos3d)arg1) → int :
C++ signature :
unsigned long getDimension(Pos3d {lvalue})
getPositionVector((Pos3d)arg1) → Vector3d :
C++ signature :
Vector3d getPositionVector(Pos3d {lvalue})
class geom.v_pos3d

Bases: Boost.Python.instance

append((v_pos3d)arg1, (object)arg2) → None :
C++ signature :
void append(std::vector<Pos3d, std::allocator<Pos3d> > {lvalue},boost::python::api::object)
extend((v_pos3d)arg1, (object)arg2) → None :
C++ signature :
void extend(std::vector<Pos3d, std::allocator<Pos3d> > {lvalue},boost::python::api::object)
class geom.mt_pos3d

Bases: xc_base.ProtoMatrix, geom.v_pos3d

class geom.m_pos3d

Bases: geom.mt_pos3d

class geom.ttz_pos3d

Bases: Boost.Python.instance

append((ttz_pos3d)arg1, (object)arg2) → None :
C++ signature :
void append(std::vector<PosArray<Pos3d>, std::allocator<PosArray<Pos3d> > > {lvalue},boost::python::api::object)
extend((ttz_pos3d)arg1, (object)arg2) → None :
C++ signature :
void extend(std::vector<PosArray<Pos3d>, std::allocator<PosArray<Pos3d> > > {lvalue},boost::python::api::object)
class geom.t_pos3d

Bases: geom.ttz_pos3d

class geom.ListPos2d

Bases: geom.GeomObj2d

appendPoint((ListPos2d)arg1, (Pos2d)arg2) → Pos2d :

appends a point to the end of the list.

C++ signature :
Pos2d const* appendPoint(Pos2dList {lvalue},Pos2d)
getArea((ListPos2d)arg1) → float :

returns enclosed area.

C++ signature :
double getArea(Pos2dList {lvalue})
getCenterOfMass((ListPos2d)arg1) → Pos2d :

returns center of gravity.

C++ signature :
Pos2d getCenterOfMass(Pos2dList {lvalue})
getNumberOfVertices((ListPos2d)arg1) → int :

returns the number of vertices.

C++ signature :
unsigned long getNumberOfVertices(Pos2dList {lvalue})
class geom.ListPos3d

Bases: geom.GeomObj3d

appendPoint((ListPos3d)arg1, (Pos3d)arg2) → Pos3d :

appends a point to the end of the list.

C++ signature :
Pos3d const* appendPoint(Pos3dList {lvalue},Pos3d)
clockwise((ListPos3d)arg1, (Pos3d)arg2) → bool :

clockwise(vPoint) return true if the point list is clockwise oriented with respect to the point of view argument.

C++ signature :
bool clockwise(Pos3dList {lvalue},Pos3d)
counterclockwise((ListPos3d)arg1, (Pos3d)arg2) → bool :

counterclockwise(vPoint) return true if the point list is counterclockwise oriented with respect to the point of view argument.

C++ signature :
bool counterclockwise(Pos3dList {lvalue},Pos3d)
getAvgKVector((ListPos3d)arg1) → Vector3d :

Return the average K vector of the point sequence.

C++ signature :
Vector3d getAvgKVector(Pos3dList {lvalue})
getCenterOfMass((ListPos3d)arg1) → Pos3d :

Return the centroid of the point sequence.

C++ signature :
Pos3d getCenterOfMass(Pos3dList {lvalue})
orientation((ListPos3d)arg1, (Pos3d)arg2) → str :

orientation(vPoint) return the orientation of the point list with respect to the point of view argument.

C++ signature :
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > orientation(Pos3dList {lvalue},Pos3d)