Back to index

salome-geom  6.5.0
Modules | Functions
Creating Basic Geometric Objects
Creating geometrical objects
Collaboration diagram for Creating Basic Geometric Objects:

Modules

 Creating Curves

Functions

def geompyDC.geompyDC.MakeVertex
 Create point by three coordinates.
def geompyDC.geompyDC.MakeVertexWithRef
 Create a point, distant from the referenced point on the given distances along the coordinate axes.
def geompyDC.geompyDC.MakeVertexOnCurve
 Create a point, corresponding to the given parameter on the given curve.
def geompyDC.geompyDC.MakeVertexOnCurveByCoord
 Create a point by projection give coordinates on the given curve.
def geompyDC.geompyDC.MakeVertexOnCurveByLength
 Create a point, corresponding to the given length on the given curve.
def geompyDC.geompyDC.MakeVertexOnSurface
 Create a point, corresponding to the given parameters on the given surface.
def geompyDC.geompyDC.MakeVertexOnSurfaceByCoord
 Create a point by projection give coordinates on the given surface.
def geompyDC.geompyDC.MakeVertexOnLinesIntersection
 Create a point on intersection of two lines.
def geompyDC.geompyDC.MakeTangentOnCurve
 Create a tangent, corresponding to the given parameter on the given curve.
def geompyDC.geompyDC.MakeTangentPlaneOnFace
 Create a tangent plane, corresponding to the given parameter on the given face.
def geompyDC.geompyDC.MakeVectorDXDYDZ
 Create a vector with the given components.
def geompyDC.geompyDC.MakeVector
 Create a vector between two points.
def geompyDC.geompyDC.MakeLine
 Create a line, passing through the given point and parrallel to the given direction.
def geompyDC.geompyDC.MakeLineTwoPnt
 Create a line, passing through the given points.
def geompyDC.geompyDC.MakeLineTwoFaces
 Create a line on two faces intersection.
def geompyDC.geompyDC.MakePlane
 Create a plane, passing through the given point and normal to the given vector.
def geompyDC.geompyDC.MakePlaneThreePnt
 Create a plane, passing through the three given points.
def geompyDC.geompyDC.MakePlaneFace
 Create a plane, similar to the existing one, but with another size of representing face.
def geompyDC.geompyDC.MakePlane2Vec
 Create a plane, passing through the 2 vectors with center in a start point of the first vector.
def geompyDC.geompyDC.MakePlaneLCS
 Create a plane, based on a Local coordinate system.
def geompyDC.geompyDC.MakeMarker
 Create a local coordinate system.
def geompyDC.geompyDC.MakeMarkerFromShape
 Create a local coordinate system from shape.
def geompyDC.geompyDC.MakeMarkerPntTwoVec
 Create a local coordinate system from point and two vectors.

Function Documentation

def geompyDC.geompyDC.MakeLine (   self,
  thePnt,
  theDir 
)

Create a line, passing through the given point and parrallel to the given direction.

Parameters:
thePntPoint. The resulting line will pass through it.
theDirDirection. The resulting line will be parallel to it.
Returns:
New GEOM.GEOM_Object, containing the created line.

Example

Create a line, passing through the given point
and parrallel to the given direction

Parameters:
    thePnt Point. The resulting line will pass through it.
    theDir Direction. The resulting line will be parallel to it.

Returns:
    New GEOM.GEOM_Object, containing the created line.

Definition at line 983 of file geompyDC.py.

00983 
00984         def MakeLine(self,thePnt, theDir):
00985             """
00986             Create a line, passing through the given point
00987             and parrallel to the given direction
00988 
00989             Parameters:
00990                 thePnt Point. The resulting line will pass through it.
00991                 theDir Direction. The resulting line will be parallel to it.
00992 
00993             Returns:
00994                 New GEOM.GEOM_Object, containing the created line.
00995             """
00996             # Example: see GEOM_TestAll.py
00997             anObj = self.BasicOp.MakeLine(thePnt, theDir)
00998             RaiseIfFailed("MakeLine", self.BasicOp)
00999             return anObj

Here is the call graph for this function:

Here is the caller graph for this function:

def geompyDC.geompyDC.MakeLineTwoFaces (   self,
  theFace1,
  theFace2 
)

Create a line on two faces intersection.

Parameters:
theFace1First of two faces, defining the line.
theFace2Second of two faces, defining the line.
Returns:
New GEOM.GEOM_Object, containing the created line.

Example

Create a line on two faces intersection.

Parameters:
    theFace1 First of two faces, defining the line.
    theFace2 Second of two faces, defining the line.

Returns:
    New GEOM.GEOM_Object, containing the created line.

Definition at line 1028 of file geompyDC.py.

01028 
01029         def MakeLineTwoFaces(self, theFace1, theFace2):
01030             """
01031             Create a line on two faces intersection.
01032 
01033             Parameters:
01034                 theFace1 First of two faces, defining the line.
01035                 theFace2 Second of two faces, defining the line.
01036 
01037             Returns:
01038                 New GEOM.GEOM_Object, containing the created line.
01039             """
01040             # Example: see GEOM_TestAll.py
01041             anObj = self.BasicOp.MakeLineTwoFaces(theFace1, theFace2)
01042             RaiseIfFailed("MakeLineTwoFaces", self.BasicOp)
01043             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeLineTwoPnt (   self,
  thePnt1,
  thePnt2 
)

Create a line, passing through the given points.

Parameters:
thePnt1First of two points, defining the line.
thePnt2Second of two points, defining the line.
Returns:
New GEOM.GEOM_Object, containing the created line.

Example

Create a line, passing through the given points

Parameters:
    thePnt1 First of two points, defining the line.
    thePnt2 Second of two points, defining the line.

Returns:
    New GEOM.GEOM_Object, containing the created line.

Definition at line 1006 of file geompyDC.py.

01006 
01007         def MakeLineTwoPnt(self,thePnt1, thePnt2):
01008             """
01009             Create a line, passing through the given points
01010 
01011             Parameters:
01012                 thePnt1 First of two points, defining the line.
01013                 thePnt2 Second of two points, defining the line.
01014 
01015             Returns:
01016                 New GEOM.GEOM_Object, containing the created line.
01017             """
01018             # Example: see GEOM_TestAll.py
01019             anObj = self.BasicOp.MakeLineTwoPnt(thePnt1, thePnt2)
01020             RaiseIfFailed("MakeLineTwoPnt", self.BasicOp)
01021             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeMarker (   self,
  OX,
  OY,
  OZ,
  XDX,
  XDY,
  XDZ,
  YDX,
  YDY,
  YDZ 
)

Create a local coordinate system.

Parameters:
OX,OY,OZThree coordinates of coordinate system origin.
XDX,XDY,XDZThree components of OX direction
YDX,YDY,YDZThree components of OY direction
Returns:
New GEOM.GEOM_Object, containing the created coordinate system.

Example

Create a local coordinate system.

Parameters: 
    OX,OY,OZ Three coordinates of coordinate system origin.
    XDX,XDY,XDZ Three components of OX direction
    YDX,YDY,YDZ Three components of OY direction

Returns: 
    New GEOM.GEOM_Object, containing the created coordinate system.

Definition at line 1185 of file geompyDC.py.

01185 
01186         def MakeMarker(self, OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ):
01187             """
01188             Create a local coordinate system.
01189 
01190             Parameters: 
01191                 OX,OY,OZ Three coordinates of coordinate system origin.
01192                 XDX,XDY,XDZ Three components of OX direction
01193                 YDX,YDY,YDZ Three components of OY direction
01194 
01195             Returns: 
01196                 New GEOM.GEOM_Object, containing the created coordinate system.
01197             """
01198             # Example: see GEOM_TestAll.py
01199             OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ, Parameters = ParseParameters(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ);
01200             anObj = self.BasicOp.MakeMarker(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ)
01201             RaiseIfFailed("MakeMarker", self.BasicOp)
01202             anObj.SetParameters(Parameters)
01203             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeMarkerFromShape (   self,
  theShape 
)

Create a local coordinate system from shape.

Parameters:
theShapeThe initial shape to detect the coordinate system.
Returns:
New GEOM.GEOM_Object, containing the created coordinate system.

Example

Create a local coordinate system from shape.

Parameters:
    theShape The initial shape to detect the coordinate system.
    
Returns: 
    New GEOM.GEOM_Object, containing the created coordinate system.

Definition at line 1209 of file geompyDC.py.

01209 
01210         def MakeMarkerFromShape(self, theShape):
01211             """
01212             Create a local coordinate system from shape.
01213 
01214             Parameters:
01215                 theShape The initial shape to detect the coordinate system.
01216                 
01217             Returns: 
01218                 New GEOM.GEOM_Object, containing the created coordinate system.
01219             """
01220             anObj = self.BasicOp.MakeMarkerFromShape(theShape)
01221             RaiseIfFailed("MakeMarkerFromShape", self.BasicOp)
01222             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeMarkerPntTwoVec (   self,
  theOrigin,
  theXVec,
  theYVec 
)

Create a local coordinate system from point and two vectors.

Parameters:
theOriginPoint of coordinate system origin.
theXVecVector of X direction
theYVecVector of Y direction
Returns:
New GEOM.GEOM_Object, containing the created coordinate system.

Example

Create a local coordinate system from point and two vectors.

Parameters:
    theOrigin Point of coordinate system origin.
    theXVec Vector of X direction
    theYVec Vector of Y direction

Returns: 
    New GEOM.GEOM_Object, containing the created coordinate system.

Definition at line 1230 of file geompyDC.py.

01230 
01231         def MakeMarkerPntTwoVec(self, theOrigin, theXVec, theYVec):
01232             """
01233             Create a local coordinate system from point and two vectors.
01234 
01235             Parameters:
01236                 theOrigin Point of coordinate system origin.
01237                 theXVec Vector of X direction
01238                 theYVec Vector of Y direction
01239 
01240             Returns: 
01241                 New GEOM.GEOM_Object, containing the created coordinate system.
01242 
01243             """
01244             anObj = self.BasicOp.MakeMarkerPntTwoVec(theOrigin, theXVec, theYVec)
01245             RaiseIfFailed("MakeMarkerPntTwoVec", self.BasicOp)
01246             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakePlane (   self,
  thePnt,
  theVec,
  theTrimSize 
)

Create a plane, passing through the given point and normal to the given vector.

Parameters:
thePntPoint, the plane has to pass through.
theVecVector, defining the plane normal direction.
theTrimSizeHalf size of a side of quadrangle face, representing the plane.
Returns:
New GEOM.GEOM_Object, containing the created plane.

Example

Create a plane, passing through the given point
and normal to the given vector.

Parameters:
    thePnt Point, the plane has to pass through.
    theVec Vector, defining the plane normal direction.
    theTrimSize Half size of a side of quadrangle face, representing the plane.

Returns:    
    New GEOM.GEOM_Object, containing the created plane.

Definition at line 1052 of file geompyDC.py.

01052 
01053         def MakePlane(self,thePnt, theVec, theTrimSize):
01054             """
01055             Create a plane, passing through the given point
01056             and normal to the given vector.
01057 
01058             Parameters:
01059                 thePnt Point, the plane has to pass through.
01060                 theVec Vector, defining the plane normal direction.
01061                 theTrimSize Half size of a side of quadrangle face, representing the plane.
01062 
01063             Returns:    
01064                 New GEOM.GEOM_Object, containing the created plane.
01065             """
01066             # Example: see GEOM_TestAll.py
01067             theTrimSize, Parameters = ParseParameters(theTrimSize);
01068             anObj = self.BasicOp.MakePlanePntVec(thePnt, theVec, theTrimSize)
01069             RaiseIfFailed("MakePlanePntVec", self.BasicOp)
01070             anObj.SetParameters(Parameters)
01071             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakePlane2Vec (   self,
  theVec1,
  theVec2,
  theTrimSize 
)

Create a plane, passing through the 2 vectors with center in a start point of the first vector.

Parameters:
theVec1Vector, defining center point and plane direction.
theVec2Vector, defining the plane normal direction.
theTrimSizeHalf size of a side of quadrangle face, representing the plane.
Returns:
New GEOM.GEOM_Object, containing the created plane.

Example

Create a plane, passing through the 2 vectors
with center in a start point of the first vector.

Parameters:
    theVec1 Vector, defining center point and plane direction.
    theVec2 Vector, defining the plane normal direction.
    theTrimSize Half size of a side of quadrangle face, representing the plane.

Returns: 
    New GEOM.GEOM_Object, containing the created plane.

Definition at line 1132 of file geompyDC.py.

01132 
01133         def MakePlane2Vec(self,theVec1, theVec2, theTrimSize):
01134             """
01135             Create a plane, passing through the 2 vectors
01136             with center in a start point of the first vector.
01137 
01138             Parameters:
01139                 theVec1 Vector, defining center point and plane direction.
01140                 theVec2 Vector, defining the plane normal direction.
01141                 theTrimSize Half size of a side of quadrangle face, representing the plane.
01142 
01143             Returns: 
01144                 New GEOM.GEOM_Object, containing the created plane.
01145             """
01146             # Example: see GEOM_TestAll.py
01147             theTrimSize, Parameters = ParseParameters(theTrimSize);
01148             anObj = self.BasicOp.MakePlane2Vec(theVec1, theVec2, theTrimSize)
01149             RaiseIfFailed("MakePlane2Vec", self.BasicOp)
01150             anObj.SetParameters(Parameters)
01151             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakePlaneFace (   self,
  theFace,
  theTrimSize 
)

Create a plane, similar to the existing one, but with another size of representing face.

Parameters:
theFaceReferenced plane or LCS(Marker).
theTrimSizeNew half size of a side of quadrangle face, representing the plane.
Returns:
New GEOM.GEOM_Object, containing the created plane.

Example

Create a plane, similar to the existing one, but with another size of representing face.

Parameters:
    theFace Referenced plane or LCS(Marker).
    theTrimSize New half size of a side of quadrangle face, representing the plane.

Returns:
    New GEOM.GEOM_Object, containing the created plane.

Definition at line 1106 of file geompyDC.py.

01106 
01107         def MakePlaneFace(self,theFace, theTrimSize):
01108             """
01109             Create a plane, similar to the existing one, but with another size of representing face.
01110 
01111             Parameters:
01112                 theFace Referenced plane or LCS(Marker).
01113                 theTrimSize New half size of a side of quadrangle face, representing the plane.
01114 
01115             Returns:
01116                 New GEOM.GEOM_Object, containing the created plane.
01117             """
01118             # Example: see GEOM_TestAll.py
01119             theTrimSize, Parameters = ParseParameters(theTrimSize);
01120             anObj = self.BasicOp.MakePlaneFace(theFace, theTrimSize)
01121             RaiseIfFailed("MakePlaneFace", self.BasicOp)
01122             anObj.SetParameters(Parameters)
01123             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakePlaneLCS (   self,
  theLCS,
  theTrimSize,
  theOrientation 
)

Create a plane, based on a Local coordinate system.

Parameters:
theLCScoordinate system, defining plane.
theTrimSizeHalf size of a side of quadrangle face, representing the plane.
theOrientationOXY, OYZ or OZX orientation - (1, 2 or 3)
Returns:
New GEOM.GEOM_Object, containing the created plane.

Example

Create a plane, based on a Local coordinate system.

           Parameters: 
    theLCS  coordinate system, defining plane.
    theTrimSize Half size of a side of quadrangle face, representing the plane.
    theOrientation OXY, OYZ or OZX orientation - (1, 2 or 3)

Returns: 
    New GEOM.GEOM_Object, containing the created plane.

Definition at line 1159 of file geompyDC.py.

01159 
01160         def MakePlaneLCS(self,theLCS, theTrimSize, theOrientation):
01161             """
01162             Create a plane, based on a Local coordinate system.
01163 
01164            Parameters: 
01165                 theLCS  coordinate system, defining plane.
01166                 theTrimSize Half size of a side of quadrangle face, representing the plane.
01167                 theOrientation OXY, OYZ or OZX orientation - (1, 2 or 3)
01168 
01169             Returns: 
01170                 New GEOM.GEOM_Object, containing the created plane.
01171             """
01172             # Example: see GEOM_TestAll.py
01173             theTrimSize, Parameters = ParseParameters(theTrimSize);
01174             anObj = self.BasicOp.MakePlaneLCS(theLCS, theTrimSize, theOrientation)
01175             RaiseIfFailed("MakePlaneLCS", self.BasicOp)
01176             anObj.SetParameters(Parameters)
01177             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakePlaneThreePnt (   self,
  thePnt1,
  thePnt2,
  thePnt3,
  theTrimSize 
)

Create a plane, passing through the three given points.

Parameters:
thePnt1First of three points, defining the plane.
thePnt2Second of three points, defining the plane.
thePnt3Fird of three points, defining the plane.
theTrimSizeHalf size of a side of quadrangle face, representing the plane.
Returns:
New GEOM.GEOM_Object, containing the created plane.

Example

Create a plane, passing through the three given points

Parameters:
    thePnt1 First of three points, defining the plane.
    thePnt2 Second of three points, defining the plane.
    thePnt3 Fird of three points, defining the plane.
    theTrimSize Half size of a side of quadrangle face, representing the plane.

Returns:
    New GEOM.GEOM_Object, containing the created plane.

Definition at line 1080 of file geompyDC.py.

01080 
01081         def MakePlaneThreePnt(self,thePnt1, thePnt2, thePnt3, theTrimSize):
01082             """
01083             Create a plane, passing through the three given points
01084 
01085             Parameters:
01086                 thePnt1 First of three points, defining the plane.
01087                 thePnt2 Second of three points, defining the plane.
01088                 thePnt3 Fird of three points, defining the plane.
01089                 theTrimSize Half size of a side of quadrangle face, representing the plane.
01090 
01091             Returns:
01092                 New GEOM.GEOM_Object, containing the created plane.
01093             """
01094             # Example: see GEOM_TestAll.py
01095             theTrimSize, Parameters = ParseParameters(theTrimSize);
01096             anObj = self.BasicOp.MakePlaneThreePnt(thePnt1, thePnt2, thePnt3, theTrimSize)
01097             RaiseIfFailed("MakePlaneThreePnt", self.BasicOp)
01098             anObj.SetParameters(Parameters)
01099             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeTangentOnCurve (   self,
  theRefCurve,
  theParameter 
)

Create a tangent, corresponding to the given parameter on the given curve.

Parameters:
theRefCurveThe referenced curve.
theParameterValue of parameter on the referenced curve.
Returns:
New GEOM.GEOM_Object, containing the created tangent.

Example

Create a tangent, corresponding to the given parameter on the given curve.

Parameters:
    theRefCurve The referenced curve.
    theParameter Value of parameter on the referenced curve.

Returns:
    New GEOM.GEOM_Object, containing the created tangent.

Example of usage:
    tan_on_arc = geompy.MakeTangentOnCurve(Arc, 0.7) #(GEOM_Object, Double)->GEOM_Object

Definition at line 882 of file geompyDC.py.

00882 
00883         def MakeTangentOnCurve(self, theRefCurve, theParameter):
00884             """
00885             Create a tangent, corresponding to the given parameter on the given curve.
00886 
00887             Parameters:
00888                 theRefCurve The referenced curve.
00889                 theParameter Value of parameter on the referenced curve.
00890 
00891             Returns:
00892                 New GEOM.GEOM_Object, containing the created tangent.
00893 
00894             Example of usage:
00895                 tan_on_arc = geompy.MakeTangentOnCurve(Arc, 0.7) #(GEOM_Object, Double)->GEOM_Object
00896             """
00897             anObj = self.BasicOp.MakeTangentOnCurve(theRefCurve, theParameter)
00898             RaiseIfFailed("MakeTangentOnCurve", self.BasicOp)
00899             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeTangentPlaneOnFace (   self,
  theFace,
  theParameterU,
  theParameterV,
  theTrimSize 
)

Create a tangent plane, corresponding to the given parameter on the given face.

Parameters:
theFaceThe face for which tangent plane should be built.
theParameterVvertical value of the center point (0.0 - 1.0).
theParameterUhorisontal value of the center point (0.0 - 1.0).
theTrimSizethe size of plane.
Returns:
New GEOM.GEOM_Object, containing the created tangent.

Example

Create a tangent plane, corresponding to the given parameter on the given face.

Parameters:
    theFace The face for which tangent plane should be built.
    theParameterV vertical value of the center point (0.0 - 1.0).
    theParameterU horisontal value of the center point (0.0 - 1.0).
    theTrimSize the size of plane.

           Returns: 
    New GEOM.GEOM_Object, containing the created tangent.

           Example of usage:
    an_on_face = geompy.MakeTangentPlaneOnFace(tan_extrusion, 0.7, 0.5, 150)

Definition at line 908 of file geompyDC.py.

00908 
00909         def MakeTangentPlaneOnFace(self, theFace, theParameterU, theParameterV, theTrimSize):
00910             """
00911             Create a tangent plane, corresponding to the given parameter on the given face.
00912 
00913             Parameters:
00914                 theFace The face for which tangent plane should be built.
00915                 theParameterV vertical value of the center point (0.0 - 1.0).
00916                 theParameterU horisontal value of the center point (0.0 - 1.0).
00917                 theTrimSize the size of plane.
00918 
00919            Returns: 
00920                 New GEOM.GEOM_Object, containing the created tangent.
00921 
00922            Example of usage:
00923                 an_on_face = geompy.MakeTangentPlaneOnFace(tan_extrusion, 0.7, 0.5, 150)
00924             """
00925             anObj = self.BasicOp.MakeTangentPlaneOnFace(theFace, theParameterU, theParameterV, theTrimSize)
00926             RaiseIfFailed("MakeTangentPlaneOnFace", self.BasicOp)
00927             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVector (   self,
  thePnt1,
  thePnt2 
)

Create a vector between two points.

Parameters:
thePnt1Start point for the vector.
thePnt2End point for the vector.
Returns:
New GEOM.GEOM_Object, containing the created vector.

Example

Create a vector between two points.

Parameters:
    thePnt1 Start point for the vector.
    thePnt2 End point for the vector.

Returns:        
    New GEOM.GEOM_Object, containing the created vector.

Definition at line 960 of file geompyDC.py.

00960 
00961         def MakeVector(self,thePnt1, thePnt2):
00962             """
00963             Create a vector between two points.
00964 
00965             Parameters:
00966                 thePnt1 Start point for the vector.
00967                 thePnt2 End point for the vector.
00968 
00969             Returns:        
00970                 New GEOM.GEOM_Object, containing the created vector.
00971             """
00972             # Example: see GEOM_TestAll.py
00973             anObj = self.BasicOp.MakeVectorTwoPnt(thePnt1, thePnt2)
00974             RaiseIfFailed("MakeVectorTwoPnt", self.BasicOp)
00975             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVectorDXDYDZ (   self,
  theDX,
  theDY,
  theDZ 
)

Create a vector with the given components.

Parameters:
theDXX component of the vector.
theDYY component of the vector.
theDZZ component of the vector.
Returns:
New GEOM.GEOM_Object, containing the created vector.

Example

Create a vector with the given components.

Parameters:
    theDX X component of the vector.
    theDY Y component of the vector.
    theDZ Z component of the vector.

Returns:     
    New GEOM.GEOM_Object, containing the created vector.

Definition at line 935 of file geompyDC.py.

00935 
00936         def MakeVectorDXDYDZ(self,theDX, theDY, theDZ):
00937             """
00938             Create a vector with the given components.
00939 
00940             Parameters:
00941                 theDX X component of the vector.
00942                 theDY Y component of the vector.
00943                 theDZ Z component of the vector.
00944 
00945             Returns:     
00946                 New GEOM.GEOM_Object, containing the created vector.
00947             """
00948             # Example: see GEOM_TestAll.py
00949             theDX,theDY,theDZ,Parameters = ParseParameters(theDX, theDY, theDZ)
00950             anObj = self.BasicOp.MakeVectorDXDYDZ(theDX, theDY, theDZ)
00951             RaiseIfFailed("MakeVectorDXDYDZ", self.BasicOp)
00952             anObj.SetParameters(Parameters)
00953             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertex (   self,
  theX,
  theY,
  theZ 
)

Create point by three coordinates.

Parameters:
theXThe X coordinate of the point.
theYThe Y coordinate of the point.
theZThe Z coordinate of the point.
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create point by three coordinates.

Parameters:
    theX The X coordinate of the point.
    theY The Y coordinate of the point.
    theZ The Z coordinate of the point.
    
Returns: 
    New GEOM.GEOM_Object, containing the created point.

Definition at line 659 of file geompyDC.py.

00659 
00660         def MakeVertex(self, theX, theY, theZ):
00661             """
00662             Create point by three coordinates.
00663 
00664             Parameters:
00665                 theX The X coordinate of the point.
00666                 theY The Y coordinate of the point.
00667                 theZ The Z coordinate of the point.
00668                 
00669             Returns: 
00670                 New GEOM.GEOM_Object, containing the created point.
00671             """
00672             # Example: see GEOM_TestAll.py
00673             theX,theY,theZ,Parameters = ParseParameters(theX, theY, theZ)
00674             anObj = self.BasicOp.MakePointXYZ(theX, theY, theZ)
00675             RaiseIfFailed("MakePointXYZ", self.BasicOp)
00676             anObj.SetParameters(Parameters)
00677             return anObj

Here is the call graph for this function:

Here is the caller graph for this function:

def geompyDC.geompyDC.MakeVertexOnCurve (   self,
  theRefCurve,
  theParameter 
)

Create a point, corresponding to the given parameter on the given curve.

Parameters:
theRefCurveThe referenced curve.
theParameterValue of parameter on the referenced curve.
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point, corresponding to the given parameter on the given curve.

Parameters:
    theRefCurve The referenced curve.
    theParameter Value of parameter on the referenced curve.

Returns:
    New GEOM.GEOM_Object, containing the created point.

Example of usage:
    p_on_arc = geompy.MakeVertexOnCurve(Arc, 0.25)

Definition at line 714 of file geompyDC.py.

00714 
00715         def MakeVertexOnCurve(self,theRefCurve, theParameter):
00716             """
00717             Create a point, corresponding to the given parameter on the given curve.
00718 
00719             Parameters:
00720                 theRefCurve The referenced curve.
00721                 theParameter Value of parameter on the referenced curve.
00722 
00723             Returns:
00724                 New GEOM.GEOM_Object, containing the created point.
00725 
00726             Example of usage:
00727                 p_on_arc = geompy.MakeVertexOnCurve(Arc, 0.25)
00728             """
00729             # Example: see GEOM_TestAll.py
00730             theParameter, Parameters = ParseParameters(theParameter)
00731             anObj = self.BasicOp.MakePointOnCurve(theRefCurve, theParameter)
00732             RaiseIfFailed("MakePointOnCurve", self.BasicOp)
00733             anObj.SetParameters(Parameters)
00734             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertexOnCurveByCoord (   self,
  theRefCurve,
  theX,
  theY,
  theZ 
)

Create a point by projection give coordinates on the given curve.

Parameters:
theRefCurveThe referenced curve.
theXX-coordinate in 3D space
theYY-coordinate in 3D space
theZZ-coordinate in 3D space
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point by projection give coordinates on the given curve

Parameters:
    theRefCurve The referenced curve.
    theX X-coordinate in 3D space
    theY Y-coordinate in 3D space
    theZ Z-coordinate in 3D space

Returns:
    New GEOM.GEOM_Object, containing the created point.

Example of usage:
    p_on_arc3 = geompy.MakeVertexOnCurveByCoord(Arc, 100, -10, 10)

Definition at line 743 of file geompyDC.py.

00743 
00744         def MakeVertexOnCurveByCoord(self,theRefCurve, theX, theY, theZ):
00745             """
00746             Create a point by projection give coordinates on the given curve
00747             
00748             Parameters:
00749                 theRefCurve The referenced curve.
00750                 theX X-coordinate in 3D space
00751                 theY Y-coordinate in 3D space
00752                 theZ Z-coordinate in 3D space
00753 
00754             Returns:
00755                 New GEOM.GEOM_Object, containing the created point.
00756 
00757             Example of usage:
00758                 p_on_arc3 = geompy.MakeVertexOnCurveByCoord(Arc, 100, -10, 10)
00759             """
00760             # Example: see GEOM_TestAll.py
00761             theX, theY, theZ, Parameters = ParseParameters(theX, theY, theZ)
00762             anObj = self.BasicOp.MakePointOnCurveByCoord(theRefCurve, theX, theY, theZ)
00763             RaiseIfFailed("MakeVertexOnCurveByCoord", self.BasicOp)
00764             anObj.SetParameters(Parameters)
00765             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertexOnCurveByLength (   self,
  theRefCurve,
  theLength,
  theStartPoint = None 
)

Create a point, corresponding to the given length on the given curve.

Parameters:
theRefCurveThe referenced curve.
theLengthLength on the referenced curve. It can be negative.
theStartPointPoint allowing to choose the direction for the calculation of the length. If None, start from the first point of theRefCurve.
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point, corresponding to the given length on the given curve.

Parameters:
    theRefCurve The referenced curve.
    theLength Length on the referenced curve. It can be negative.
    theStartPoint Point allowing to choose the direction for the calculation
      of the length. If None, start from the first point of theRefCurve.

Returns:
    New GEOM.GEOM_Object, containing the created point.

Definition at line 774 of file geompyDC.py.

00774 
00775         def MakeVertexOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None):
00776             """
00777             Create a point, corresponding to the given length on the given curve.
00778 
00779             Parameters:
00780                 theRefCurve The referenced curve.
00781                 theLength Length on the referenced curve. It can be negative.
00782                 theStartPoint Point allowing to choose the direction for the calculation
00783                               of the length. If None, start from the first point of theRefCurve.
00784 
00785             Returns:
00786                 New GEOM.GEOM_Object, containing the created point.
00787             """
00788             # Example: see GEOM_TestAll.py
00789             theLength, Parameters = ParseParameters(theLength)
00790             anObj = self.BasicOp.MakePointOnCurveByLength(theRefCurve, theLength, theStartPoint)
00791             RaiseIfFailed("MakePointOnCurveByLength", self.BasicOp)
00792             anObj.SetParameters(Parameters)
00793             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertexOnLinesIntersection (   self,
  theRefLine1,
  theRefLine2 
)

Create a point on intersection of two lines.

Parameters:
theRefLine1,theRefLine2The referenced lines.
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point on intersection of two lines.

Parameters:
    theRefLine1, theRefLine2 The referenced lines.

Returns:
    New GEOM.GEOM_Object, containing the created point.

Definition at line 861 of file geompyDC.py.

00861 
00862         def MakeVertexOnLinesIntersection(self, theRefLine1, theRefLine2):
00863             """
00864             Create a point on intersection of two lines.
00865 
00866             Parameters:
00867                 theRefLine1, theRefLine2 The referenced lines.
00868 
00869             Returns:
00870                 New GEOM.GEOM_Object, containing the created point.
00871             """
00872             # Example: see GEOM_TestAll.py
00873             anObj = self.BasicOp.MakePointOnLinesIntersection(theRefLine1, theRefLine2)
00874             RaiseIfFailed("MakePointOnLinesIntersection", self.BasicOp)
00875             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertexOnSurface (   self,
  theRefSurf,
  theUParameter,
  theVParameter 
)

Create a point, corresponding to the given parameters on the given surface.

Parameters:
theRefSurfThe referenced surface.
theUParameterValue of U-parameter on the referenced surface.
theVParameterValue of V-parameter on the referenced surface.
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point, corresponding to the given parameters on the
given surface.

Parameters:
    theRefSurf The referenced surface.
    theUParameter Value of U-parameter on the referenced surface.
    theVParameter Value of V-parameter on the referenced surface.

Returns:
    New GEOM.GEOM_Object, containing the created point.

Example of usage:
    p_on_face = geompy.MakeVertexOnSurface(Face, 0.1, 0.8) #(GEOM_Object, Double, Double)->GEOM_Object

Definition at line 802 of file geompyDC.py.

00802 
00803         def MakeVertexOnSurface(self, theRefSurf, theUParameter, theVParameter):
00804             """
00805             Create a point, corresponding to the given parameters on the
00806             given surface.
00807 
00808             Parameters:
00809                 theRefSurf The referenced surface.
00810                 theUParameter Value of U-parameter on the referenced surface.
00811                 theVParameter Value of V-parameter on the referenced surface.
00812 
00813             Returns:
00814                 New GEOM.GEOM_Object, containing the created point.
00815 
00816             Example of usage:
00817                 p_on_face = geompy.MakeVertexOnSurface(Face, 0.1, 0.8) #(GEOM_Object, Double, Double)->GEOM_Object
00818             """
00819             theUParameter, theVParameter, Parameters = ParseParameters(theUParameter, theVParameter)
00820             # Example: see GEOM_TestAll.py
00821             anObj = self.BasicOp.MakePointOnSurface(theRefSurf, theUParameter, theVParameter)
00822             RaiseIfFailed("MakePointOnSurface", self.BasicOp)
00823             anObj.SetParameters(Parameters);
00824             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertexOnSurfaceByCoord (   self,
  theRefSurf,
  theX,
  theY,
  theZ 
)

Create a point by projection give coordinates on the given surface.

Parameters:
theRefSurfThe referenced surface.
theXX-coordinate in 3D space
theYY-coordinate in 3D space
theZZ-coordinate in 3D space
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point by projection give coordinates on the given surface

Parameters:
    theRefSurf The referenced surface.
    theX X-coordinate in 3D space
    theY Y-coordinate in 3D space
    theZ Z-coordinate in 3D space

Returns:
    New GEOM.GEOM_Object, containing the created point.

Example of usage:
    p_on_face2 = geompy.MakeVertexOnSurfaceByCoord(Face, 0., 0., 0.) #(GEOM_Object, Double, Double, Double)->GEOM_Object

Definition at line 833 of file geompyDC.py.

00833 
00834         def MakeVertexOnSurfaceByCoord(self, theRefSurf, theX, theY, theZ):
00835             """
00836             Create a point by projection give coordinates on the given surface
00837 
00838             Parameters:
00839                 theRefSurf The referenced surface.
00840                 theX X-coordinate in 3D space
00841                 theY Y-coordinate in 3D space
00842                 theZ Z-coordinate in 3D space
00843 
00844             Returns:
00845                 New GEOM.GEOM_Object, containing the created point.
00846 
00847             Example of usage:
00848                 p_on_face2 = geompy.MakeVertexOnSurfaceByCoord(Face, 0., 0., 0.) #(GEOM_Object, Double, Double, Double)->GEOM_Object
00849             """
00850             theX, theY, theZ, Parameters = ParseParameters(theX, theY, theZ)
00851             # Example: see GEOM_TestAll.py
00852             anObj = self.BasicOp.MakePointOnSurfaceByCoord(theRefSurf, theX, theY, theZ)
00853             RaiseIfFailed("MakeVertexOnSurfaceByCoord", self.BasicOp)
00854             anObj.SetParameters(Parameters);
00855             return anObj

Here is the call graph for this function:

def geompyDC.geompyDC.MakeVertexWithRef (   self,
  theReference,
  theX,
  theY,
  theZ 
)

Create a point, distant from the referenced point on the given distances along the coordinate axes.

Parameters:
theReferenceThe referenced point.
theXDisplacement from the referenced point along OX axis.
theYDisplacement from the referenced point along OY axis.
theZDisplacement from the referenced point along OZ axis.
Returns:
New GEOM.GEOM_Object, containing the created point.

Example

Create a point, distant from the referenced point
on the given distances along the coordinate axes.

Parameters:
    theReference The referenced point.
    theX Displacement from the referenced point along OX axis.
    theY Displacement from the referenced point along OY axis.
    theZ Displacement from the referenced point along OZ axis.

Returns:
    New GEOM.GEOM_Object, containing the created point.

Definition at line 687 of file geompyDC.py.

00687 
00688         def MakeVertexWithRef(self,theReference, theX, theY, theZ):
00689             """
00690             Create a point, distant from the referenced point
00691             on the given distances along the coordinate axes.
00692 
00693             Parameters:
00694                 theReference The referenced point.
00695                 theX Displacement from the referenced point along OX axis.
00696                 theY Displacement from the referenced point along OY axis.
00697                 theZ Displacement from the referenced point along OZ axis.
00698 
00699             Returns:
00700                 New GEOM.GEOM_Object, containing the created point.
00701             """
00702             # Example: see GEOM_TestAll.py
00703             theX,theY,theZ,Parameters = ParseParameters(theX, theY, theZ)
00704             anObj = self.BasicOp.MakePointWithReference(theReference, theX, theY, theZ)
00705             RaiseIfFailed("MakePointWithReference", self.BasicOp)
00706             anObj.SetParameters(Parameters)
00707             return anObj

Here is the call graph for this function: