// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#include "SALOME_Exception.idl"
#include "SALOME_Component.idl"
#include "SALOMEDS.idl"
+#include "SALOMEDS_Attributes.idl"
#include "SALOME_GenericObj.idl"
* Topological types of shapes (like Open Cascade types)
*/
enum shape_type { COMPOUND, COMPSOLID, SOLID, SHELL,
- FACE, WIRE, EDGE, VERTEX, SHAPE };
+ FACE, WIRE, EDGE, VERTEX, SHAPE };
/*!
ST_ONIN
};
+ /*!
+ * Kind of method to find inside one main shape some subshapes,
+ * corresponding to other given shape (its argument)
+ * Is used in functions GEOM_Gen.RestoreSubShapes<xxx>()
+ */
+ enum find_shape_method
+ {
+ /*! Use GetInPlace functionality. Suits all cases, except transformations */
+ FSM_GetInPlace,
+
+ /*! To be used only for transformation result, to find subshapes of argument.
+ * Only this method can be used after transformation.
+ */
+ FSM_Transformed,
+
+ /*! To find only shared subshapes, not modified by the operation */
+ FSM_GetSame,
+
+ /*! Use GetShapesOnShape method (can work only on solids) */
+ FSM_GetShapesOnShape,
+
+ /*! Use GetInPlaceByHistory method (can work only after Partition) */
+ FSM_GetInPlaceByHistory
+ };
+
+
typedef sequence<string> string_array;
typedef sequence<short> short_array;
typedef sequence<long> ListOfLong;
*/
string GetName();
+ /*!
+ * Set color of the object.
+ * \param theColor is a color of the object.
+ */
+ void SetColor(in SALOMEDS::Color theColor);
+
+ /*!
+ * Get color of the object.
+ */
+ SALOMEDS::Color GetColor();
+
+ /*!
+ * Toggle auto color mode on the object.
+ * \param theAtoColor is a flag which toggles auto color mode.
+ */
+ void SetAutoColor(in boolean theAutoColor);
+
+ /*!
+ * Get flag of object's auto color mode.
+ */
+ boolean GetAutoColor();
+
/*!
* Set a Study entry where this object was published.
*/
/*!
* Get the TopoDS_Shape, for colocated case only.
*/
- long getShape();
+ long long getShape();
/*!
######################################################################
GEOM_Object MakePointOnCurve (in GEOM_Object theRefCurve,
in double theParameter);
-
+ /*!
+ * Create a point, corresponding to the given parameters on the
+ * given surface.
+ * \param theRefSurf The referenced surface.
+ * \param theUParameter Value of U-parameter on the referenced surface.
+ * \param theVParameter Value of V-parameter on the referenced surface.
+ * \return New GEOM_Object, containing the created point.
+ */
+ GEOM_Object MakePointOnSurface (in GEOM_Object theRefSurf,
+ in double theUParameter,
+ in double theVParameter);
+
+ /*!
+ * Create a point, on two lines intersection.
+ * \param theRefLine1, theRefLine2 The referenced lines.
+ * \return New GEOM_Object, containing the created point.
+ */
+ GEOM_Object MakePointOnLinesIntersection (in GEOM_Object theRefLine1,
+ in GEOM_Object theRefLine2);
+
/*!
* Create a vector, corresponding to tangent to the given parameter on the given curve.
* \param theRefCurve The referenced curve.
* \param theParameter Value of parameter on the referenced curve.This value should be have value
* \between 0. and 1.. Value of 0. corresponds first parameter of curve value 1. corresponds
- * \last parameter of curve.
+ * \last parameter of curve.
* \return New GEOM_Object, containing the created point.
*/
GEOM_Object MakeTangentOnCurve (in GEOM_Object theRefCurve,
*/
GEOM_Object MakeLineTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
+ /*!
+ * Create a line, given by two faces intersection.
+ * \param theFace1 First of two faces, defining the line.
+ * \param theFace2 Second of two faces, defining the line.
+ * \return New GEOM_Object, containing the created line.
+ */
+ GEOM_Object MakeLineTwoFaces (in GEOM_Object theFace1, in GEOM_Object theFace2);
+
/*!
* Create a plane, passing through the three given points
* \param thePnt1 First of three points, defining the plane.
GEOM_Object MakeMarker (in double theOX , in double theOY , in double theOZ,
in double theXDX, in double theXDY, in double theXDZ,
in double theYDX, in double theYDY, in double theYDZ);
-
+
/*!
* Create a tangent plane to specified face in the point with specified parameters.
* Values of parameters should be between 0. and 1.0
- * \param theFace - face for which tangent plane shuold be built.
+ * \param theFace - face for which tangent plane shuold be built.
* \param theParameterU - value of parameter by U
* \param theParameterV - value of parameter Vthe
* \param theTrimSize - defines sizes of created face
GEOM_Object TranslateVectorCopy (in GEOM_Object theObject,
in GEOM_Object theVector);
+ /*!
+ * Translate the given object along the given vector on given distance,
+ * creating its copy before the translation.
+ * \param theObject The object to be translated.
+ * \param theVector Translation vector, giving a direction.
+ * \param theDistance Translation distance, giving a distance.
+ * \param theCope Translation copy, creating its copy if true.
+ * \return New GEOM_Object, containing the translated object.
+ */
+ GEOM_Object TranslateVectorDistance (in GEOM_Object theObject,
+ in GEOM_Object theVector,
+ in double theDistance,
+ in boolean theCopy);
+
/*!
* Translate the given object along the given vector a given number times
* \param theObject The object to be translated.
GEOM_Object ScaleShapeCopy (in GEOM_Object theObject, in GEOM_Object thePoint,
in double theFactor);
+ /*!
+ * Scale the given object by different factors along coordinate axes.
+ * \param theObject The object to be scaled.
+ * \param thePoint Center point for scaling.
+ * \param theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
+ * \return theObject.
+ */
+ GEOM_Object ScaleShapeAlongAxes (in GEOM_Object theObject,
+ in GEOM_Object thePoint,
+ in double theFactorX,
+ in double theFactorY,
+ in double theFactorZ);
+
+ /*!
+ * Scale the given object by different factors along coordinate axes,
+ * creating its copy before the scaling.
+ * \param theObject The object to be scaled.
+ * \param thePoint Center point for scaling.
+ * \param theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
+ * \return New GEOM_Object, containing the scaled shape.
+ */
+ GEOM_Object ScaleShapeAlongAxesCopy (in GEOM_Object theObject,
+ in GEOM_Object thePoint,
+ in double theFactorX,
+ in double theFactorY,
+ in double theFactorZ);
+
/*!
* Modify the Location of the given object by LCS.
* \param theObject The object to be displaced.
*/
GEOM_Object MakeBoxTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
+ /*!
+ * Create a face specified dimensions along OX-OY coordinate axes,
+ * with edges parallel to the coordinate axes.
+ * Center of the face will be at point (0, 0, 0).
+ * \param theH Height of the Face.
+ * \param theW Width of the Face.
+ * \param theOrientation Orientation belong axis OXY OYZ OZX
+ * \return New GEOM_Object, containing the created face.
+ */
+ GEOM_Object MakeFaceHW (in double theH, in double theW, in short theOrientation);
+ /*!
+ * Create a face by normale vector or edge and two specified sizes,
+ * vertical (H) and horisontal (W).
+ * \param theVec defines plane.
+ * \param theH vertical size (height).
+ * \param theW horisontal size (width).
+ * \return New GEOM_Object, containing the created face.
+ */
+ GEOM_Object MakeFaceObjHW (in GEOM_Object theObj, in double theH, in double theW);
+ /*!
+ * Create a Disk (circular face) with given center, normal vector and radius.
+ * \param thePnt disk center.
+ * \param theVec Vector, normal to the plane of the disk.
+ * \param theR Disk radius.
+ * \return New GEOM_Object, containing the created disk.
+ */
+ GEOM_Object MakeDiskPntVecR (in GEOM_Object thePnt,
+ in GEOM_Object theVec,
+ in double theR);
+ /*!
+ * Create a disk (circular face), passing through three given points
+ * \param thePnt1, thePnt2, thePnt3 Points, defining the disk.
+ * \return New GEOM_Object, containing the created disk.
+ */
+ GEOM_Object MakeDiskThreePnt (in GEOM_Object thePnt1,
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3);
+
+ /*!
+ * Create a disk specified dimensions along OX-OY coordinate axes,
+ * Center of the disk at point (0, 0, 0).
+ * \param theR of the Disk.
+ * \param theOrientation Orientation belong axis OXY OYZ OZX
+ * \return New GEOM_Object, containing the created disk.
+ */
+ GEOM_Object MakeDiskR (in double theR, in short theOrientation);
+
/*!
* Create a cylinder with given radius and height at
* the origin of coordinate system. Axis of the cylinder
GEOM_Object MakePrismVecH (in GEOM_Object theBase,
in GEOM_Object theVec,
in double theH);
+ /* The Same Prism but in 2 directions (forward&backward) */
+ GEOM_Object MakePrismVecH2Ways (in GEOM_Object theBase,
+ in GEOM_Object theVec,
+ in double theH);
/*!
* Create a shape by extrusion of the base shape along a vector, defined by two points.
GEOM_Object MakePrismTwoPnt (in GEOM_Object theBase,
in GEOM_Object thePoint1,
in GEOM_Object thePoint2);
+ /* The same prism but in two directions forward&backward */
+ GEOM_Object MakePrismTwoPnt2Ways (in GEOM_Object theBase,
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
+
+ /*!
+ * Create a shape by extrusion of the base shape along a vector, defined by DX DY DZ.
+ * \param theBase Base shape to be extruded.
+ * \param DX, DY, DZ end of extrusion vector.
+ * \return New GEOM_Object, containing the created prism.
+ */
+ GEOM_Object MakePrismDXDYDZ (in GEOM_Object theBase,
+ in double theDX, in double theDY, in double theDZ);
+ /* The same prism but in two directions forward&backward */
+ GEOM_Object MakePrismDXDYDZ2Ways (in GEOM_Object theBase,
+ in double theDX, in double theDY, in double theDZ);
/*!
* Create a shape by extrusion of the base shape along
GEOM_Object MakeRevolutionAxisAngle (in GEOM_Object theBase,
in GEOM_Object theAxis,
in double theAngle);
+ /* The Same Revolution but in both ways forward&backward */
+ GEOM_Object MakeRevolutionAxisAngle2Ways (in GEOM_Object theBase,
+ in GEOM_Object theAxis,
+ in double theAngle);
/*!
* Create a filling from the given compound of contours.
- * \param theMinDeg a minimal degree
- * \param theMaxDeg a maximal degree
- * \param theTol2D a 2d tolerance
- * \param theTol3D a 3d tolerance
- * \param theNbIter a number of iteration
+ * \param theMinDeg a minimal degree of BSpline surface to create
+ * \param theMaxDeg a maximal degree of BSpline surface to create
+ * \param theTol2D a 2d tolerance to be reached
+ * \param theTol3D a 3d tolerance to be reached
+ * \param theNbIter a number of iteration of approximation algorithm
* \return New GEOM_Object, containing the created filling surface.
*/
GEOM_Object MakeFilling (in GEOM_Object theShape,
in long theMinDeg, in long theMaxDeg,
in double theTol2D, in double theTol3D,
- in long theNbIter);
+ in long theNbIter, in boolean theApprox);
/*!
* Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
in GEOM_Object thePath,
in boolean theWithContact ,
in boolean theWithCorrection );
-
+
+ /*!
+ * Create a shape by extrusion of the profile shape along
+ * the path shape. The path shape can be a shell or a face.
+ * the several profiles can be specified in the several locations of path.
+ * \param theSeqBases - list of Bases shape to be extruded.
+ * \param theSeqSubBases - list of corresponding subshapes of section shapes.
+ * \param theLocations - list of locations on the path corresponding
+ * specified list of the Bases shapes. Number of locations
+ * should be equal to number of bases.
+ * \param thePath - Path shape to extrude the base shape along it.
+ * \param theWithContact - the mode defining that the section is translated to be in
+ * contact with the spine.
+ * \param - WithCorrection - defining that the section is rotated to be
+ * orthogonal to the spine tangent in the correspondent point
+ * \return New GEOM_Object, containing the created pipe.
+ */
+ GEOM_Object MakePipeWithShellSections (in ListOfGO theSeqBases,
+ in ListOfGO theSeqSubBases,
+ in ListOfGO theLocations,
+ in GEOM_Object thePath,
+ in boolean theWithContact ,
+ in boolean theWithCorrection );
+
+ /*!
+ * Create solids between given sections
+ * \param theSeqBases - list of sections (shell or face).
+ * \param theLocations - list of corresponding vertexes
+ * \return New GEOM_Object, containing the created solids.
+ */
+ GEOM_Object MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
+ in ListOfGO theLocations);
+
+ /*!
+ * Create a shape by extrusion of the base shape along
+ * the path shape with constant bi-normal direction along the given vector.
+ * The path shape can be a wire or an edge.
+ * \param theBase Base shape to be extruded.
+ * \param thePath Path shape to extrude the base shape along it.
+ * \param theVec Vector defines a constant binormal direction to keep the
+ * same angle beetween the Direction and the sections
+ * along the sweep surface.
+ * \return New GEOM_Object, containing the created pipe.
+ */
+ GEOM_Object MakePipeBiNormalAlongVector (in GEOM_Object theBase,
+ in GEOM_Object thePath,
+ in GEOM_Object theVec);
+
};
/*!
* Replace coincident faces in theShape by one face.
* \param theShape Initial shape.
* \param theTolerance Maximum distance between faces, which can be considered as coincident.
+ * \param doKeepNonSolids If FALSE, only solids will present in the result, otherwise all initial shapes.
* \return New GEOM_Object, containing a copy of theShape without coincident faces.
*/
- GEOM_Object MakeGlueFaces (in GEOM_Object theShape, in double theTolerance);
+ GEOM_Object MakeGlueFaces (in GEOM_Object theShape, in double theTolerance, in boolean doKeepNonSolids);
+
+ /*!
+ * Find coincident faces in theShape for possible gluing.
+ * \param theShape Initial shape.
+ * \param theTolerance Maximum distance between faces, which can be considered as coincident.
+ * \return ListOfGO
+ */
+ ListOfGO GetGlueFaces (in GEOM_Object theShape, in double theTolerance);
+
+ /*!
+ * Replace coincident faces in theShape by one face
+ * in compliance with given list of faces
+ * \param theShape Initial shape.
+ * \param theTolerance Maximum distance between faces, which can be considered as coincident.
+ * \param theFaces List of faces for gluing.
+ * \param doKeepNonSolids If FALSE, only solids will present in the result, otherwise all initial shapes.
+ * \return New GEOM_Object, containing a copy of theShape without some faces.
+ */
+ GEOM_Object MakeGlueFacesByList (in GEOM_Object theShape, in double theTolerance,
+ in ListOfGO theFaces, in boolean doKeepNonSolids);
/*!
* Explode a shape on subshapes of a given type.
in long theShapeType,
in GEOM_Object theAx1,
in shape_state theState);
-
+
/*!
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified plane by the certain way, defined through \a theState parameter.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theAx1 Vector (or line, or linear edge), specifying normal
* direction of the plane to find shapes on.
- * \param thePnt Point specifying location of the plane to find shapes on.
+ * \param thePnt Point specifying location of the plane to find shapes on.
* \param theState The state of the subshapes to find.
* \return List of IDs of all found sub-shapes.
*/
in shape_state theState);
/*!
- * Get sub-shape(s) of theShapeWhere, which are
+ * \brief Find subshapes complying with given status
+ * \param theCheckShape - the shape to check state of subshapes against
+ * \param theShape - the shape to explore
+ * \param theShapeType - type of subshape of theShape
+ * \param theState - required state
+ * \return List of IDs of all found sub-shapes.
+ */
+ ListOfLong GetShapesOnShapeIDs (in GEOM_Object theCheckShape,
+ in GEOM_Object theShape,
+ in short theShapeType,
+ in shape_state theState);
+
+ /*!
+ * \brief Find subshapes complying with given status
+ * \param theCheckShape - the shape to check state of subshapes against
+ * \param theShape - the shape to explore
+ * \param theShapeType - type of subshape of theShape
+ * \param theState - required state
+ * \return List of all found sub-shapes.
+ */
+ ListOfGO GetShapesOnShape (in GEOM_Object theCheckShape,
+ in GEOM_Object theShape,
+ in short theShapeType,
+ in shape_state theState);
+
+ /*!
+ * \brief Find subshapes complying with given status
+ * \param theCheckShape - the shape to check state of subshapes against
+ * \param theShape - the shape to explore
+ * \param theShapeType - type of subshape of theShape
+ * \param theState - required state
+ * \return compound includes all found sub-shapes.
+ */
+ GEOM_Object GetShapesOnShapeAsCompound (in GEOM_Object theCheckShape,
+ in GEOM_Object theShape,
+ in short theShapeType,
+ in shape_state theState);
+
+ /*!
+ * Get sub-shape(s) of \a theShapeWhere, which are
* coincident with \a theShapeWhat or could be a part of it.
* \param theShapeWhere Shape to find sub-shapes of.
* \param theShapeWhat Shape, specifying what to find.
GEOM_Object GetInPlace (in GEOM_Object theShapeWhere,
in GEOM_Object theShapeWhat);
+ /*!
+ * Get sub-shape(s) of \a theShapeWhere, which are
+ * coincident with \a theShapeWhat or could be a part of it.
+ *
+ * Implementation of this method is based on a saved history of an operation,
+ * produced \a theShapeWhere. The \a theShapeWhat must be among this operation's
+ * arguments (an argument shape or a sub-shape of an argument shape).
+ * The operation could be the Partition or one of boolean operations,
+ * performed on simple shapes (not on compounds).
+ *
+ * \param theShapeWhere Shape to find sub-shapes of.
+ * \param theShapeWhat Shape, specifying what to find.
+ * \return Group of all found sub-shapes or a single found sub-shape.
+ */
+ GEOM_Object GetInPlaceByHistory (in GEOM_Object theShapeWhere,
+ in GEOM_Object theShapeWhat);
+
/*!
* Get sub-shape of theShapeWhere, which are
* coincident with \a theShapeWhat that can either SOLID, FACE, EDGE or VERTEX.
* \note Each compound from ListShapes and ListTools will be exploded in order
* to avoid possible intersection between shapes from this compound.
* \param theLimit Type of resulting shapes (corresponding to TopAbs_ShapeEnum).
+ # \param KeepNonlimitShapes: if this parameter == 0 - only shapes with
+ # type <= Limit are kept in the result,
+ # else - shapes with type > Limit are kept
+ # also (if they exist)
*
* After implementation new version of PartitionAlgo (October 2006)
* other parameters are ignored by current functionality. They are kept
in ListOfGO theRemoveInside,
in short theLimit,
in boolean theRemoveWebs,
- in ListOfLong theMaterials);
+ in ListOfLong theMaterials,
+ in short theKeepNonlimitShapes);
/*!
* Perform partition operation.
in ListOfGO theRemoveInside,
in short theLimit,
in boolean theRemoveWebs,
- in ListOfLong theMaterials);
+ in ListOfLong theMaterials,
+ in short theKeepNonlimitShapes);
/*!
* Perform partition of the Shape with the Plane
GEOM_Object MakeCircleThreePnt (in GEOM_Object thePnt1,
in GEOM_Object thePnt2,
in GEOM_Object thePnt3);
-
+ /*!
+ * Create a circle with given center, with a radius equals the distance from center to Point1
+ * and on a plane defined by all of three points.
+ * \param thePnt1,thePnt2,thePnt3 Points, defining the circle.
+ * \return New GEOM_Object, containing the created circle.
+ */
+ GEOM_Object MakeCircleCenter2Pnt (in GEOM_Object thePnt1,
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3);
/*!
* Create an ellipse with given center, normal vector and radiuses.
* \param thePnt Ellipse center.
in GEOM_Object thePnt2,
in GEOM_Object thePnt3);
+ /*!
+ * Create an arc of circle of center C from one point to another
+ * \param theCenter Center point of the arc.
+ * \param thePnt1 Start point of the arc.
+ * \param thePnt2 End point of the arc.
+ * \param theSense Orientation of the arc
+ * \return New GEOM_Object, containing the created arc.
+ */
+ GEOM_Object MakeArcCenter (in GEOM_Object theCenter,
+ in GEOM_Object thePnt1,
+ in GEOM_Object thePnt2,
+ in boolean theSense);
+
+
/*!
* Create a polyline on the set of points.
* \param thePoints Sequence of points for the polyline.
GEOM_Object MakeFilletEdges (in GEOM_Object theShape,
in double theR,
in ListOfLong theEdges);
+ GEOM_Object MakeFilletEdgesR1R2 (in GEOM_Object theShape,
+ in double theR1,
+ in double theR2,
+ in ListOfLong theEdges);
/*!
* Perform a fillet on all edges of the specified faces of the given shape.
GEOM_Object MakeFilletFaces (in GEOM_Object theShape,
in double theR,
in ListOfLong theFaces);
+ GEOM_Object MakeFilletFacesR1R2 (in GEOM_Object theShape,
+ in double theR1,
+ in double theR2,
+ in ListOfLong theFaces);
/*!
* Perform a symmetric chamfer on all edges of the given shape.
GEOM_Object MakeChamferEdge (in GEOM_Object theShape,
in double theD1, in double theD2,
in long theFace1, in long theFace2);
+ /*!
+ * The Same but with params theD = Chamfer Lenght
+ * and theAngle = Chamfer Angle (Angle in radians)
+ */
+ GEOM_Object MakeChamferEdgeAD (in GEOM_Object theShape,
+ in double theD, in double theAngle,
+ in long theFace1, in long theFace2);
/*!
* Perform a chamfer on all edges of the specified faces.
GEOM_Object MakeChamferFaces (in GEOM_Object theShape,
in double theD1, in double theD2,
in ListOfLong theFaces);
+ /*!
+ * The Same but with params theD = Chamfer Lenght
+ * and theAngle = Chamfer Angle (Angle in radians)
+ */
+ GEOM_Object MakeChamferFacesAD (in GEOM_Object theShape,
+ in double theD, in double theAngle,
+ in ListOfLong theFaces);
+
+ /*!
+ * Perform a chamfer on edges,
+ * with distance D1 on the first specified face (if several for one edge)
+ * \param theShape Shape, to perform chamfer on.
+ * \param theD1 theD2 Chamfer size
+ * \param theEdges Sequence of edges of \a theShape.
+ * \return New GEOM_Object, containing the result shape.
+ */
+ GEOM_Object MakeChamferEdges (in GEOM_Object theShape,
+ in double theD1, in double theD2,
+ in ListOfLong theEdges);
+ /*!
+ * The Same but with params theD = Chamfer Lenght
+ * and theAngle = Chamfer Angle (Angle in radians)
+ */
+ GEOM_Object MakeChamferEdgesAD (in GEOM_Object theShape,
+ in double theD, in double theAngle,
+ in ListOfLong theEdges);
/*!
* Perform an Archimde operation on the given shape with given parameters.
out string_array thePatterns);
};
+ /*!
+ * GEOM_IKindOfShape: namespace for shape_kind enumeration.
+ */
+ interface GEOM_IKindOfShape
+ {
+ enum shape_kind {
+ NO_SHAPE,
+ // COMPOSITEs
+ COMPOUND,
+ COMPSOLID,
+ SHELL,
+ WIRE,
+ // SOLIDs
+ SPHERE, // full sphere
+ CYLINDER, // cylinder
+ BOX, // box with faces, parallel to global coordinate planes
+ ROTATED_BOX, // other box
+ TORUS, // full torus
+ CONE, // cone
+ POLYHEDRON, // solid, bounded by polygons
+ SOLID, // other solid
+ // FACEs
+ SPHERE2D, // spherical face (closed)
+ CYLINDER2D, // cylindrical face with defined height
+ TORUS2D, // toroidal face (closed)
+ CONE2D, // conical face with defined height
+ DISK_CIRCLE, // planar, bounded by circle
+ DISK_ELLIPSE, // planar, bounded by ellipse
+ POLYGON, // planar, bounded by segments
+ PLANE, // infinite planar
+ PLANAR, // other planar
+ FACE, // other face
+ // EDGEs
+ CIRCLE, // full circle
+ ARC_CIRCLE, // arc of circle
+ ELLIPSE, // full ellipse
+ ARC_ELLIPSE, // arc of ellipse
+ LINE, // infinite segment
+ SEGMENT, // segment
+ EDGE, // other edge
+ // VERTEX
+ VERTEX
+ };
+ };
+
+
/*!
* GEOM_IMeasureOperations: Interface for measurement (distance, whatis) and
* properties calculation (like Centre of Mass, Inertia, etc.).
*/
interface GEOM_IMeasureOperations : GEOM_IOperations
{
+ /*!
+ * Get kind of theShape.
+ * \param theShape Shape to get a kind of.
+ * \param theIntegers Output. Integer and enumerated shape's parameters
+ * (kind of surface, closed/unclosed, number of edges, etc.)
+ * \param theDoubles Output. Double shape's parameters (coordinates, dimensions, etc.)
+ * \note Concrete meaning of each value, returned via \a theIntegers
+ * or \a theDoubles list depends on the kind of the shape.
+ * \return Returns a kind of shape in terms of <VAR>GEOM_IKindOfShape.shape_kind</VAR> enumeration.
+ */
+ //short KindOfShape (in GEOM_Object theShape,
+ GEOM_IKindOfShape::shape_kind KindOfShape (in GEOM_Object theShape,
+ out ListOfLong theIntegers,
+ out ListOfDouble theDoubles);
+
/*!
* Get position (LCS) of theShape.
* \param theShape Shape to calculate position of.
*/
GEOM_Object GetCentreOfMass (in GEOM_Object theShape);
+ /*!
+ * Get a vector, representing the normal of theFace.
+ * If the face is not planar, theOptionalPoint is obligatory.
+ * \param theFace Shape (face) to define the normal of.
+ * \param theOptionalPoint Shape (point) to define the normal at.
+ * Can be NULL in case of planar face.
+ * \return New GEOM_Object, containing the created normal vector.
+ */
+ GEOM_Object GetNormal (in GEOM_Object theFace,
+ in GEOM_Object theOptionalPoint);
+
/*!
* Get inertia matrix and moments of inertia of theShape.
* \param theShape Shape to calculate inertia of.
out double X1, out double Y1, out double Z1,
out double X2, out double Y2, out double Z2);
+ /*!
+ * Get angle between the given lines or linear edges.
+ * \param theShape1,theShape2 Shapes to find angle between. Lines or linear edges.
+ * \return Value of the angle between the given shapes.
+ */
+ double GetAngle (in GEOM_Object theShape1, in GEOM_Object theShape2);
/*!
* Get point coordinates
*/
void PointCoordinates (in GEOM_Object theShape, out double X, out double Y, out double Z);
+
+ /*!
+ * Get radius of curvature of curve in the point determinated by param
+ * \param theShape - curve.
+ * \param theParam - parameter on curve
+ * \return Value of curvature.
+ */
+ double CurveCurvatureByParam (in GEOM_Object theShape, in double theParam);
+
+ /*!
+ * Get radius of curvature of curve in the given point
+ * \param theShape - curve.
+ * \param thePoint - point
+ * \return Value of curvature.
+ */
+ double CurveCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
+
+ /*!
+ * Get max radius of curvature of surface in the point determinated by params
+ * \param theShape - surface.
+ * \param theUParam - U-parameter on surface
+ * \param theVParam - V-parameter on surface
+ * \return Value of curvature.
+ */
+ double MaxSurfaceCurvatureByParam (in GEOM_Object theShape, in double theUParam,
+ in double theVParam);
+
+ /*!
+ * Get max radius of curvature of surface in the given point
+ * \param theShape - surface.
+ * \param thePoint - point
+ * \return Value of curvature.
+ */
+ double MaxSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
+
+ /*!
+ * Get min radius of curvature of surface in the point determinated by params
+ * \param theShape - surface.
+ * \param theUParam - U-parameter on surface
+ * \param theVParam - V-parameter on surface
+ * \return Value of curvature.
+ */
+ double MinSurfaceCurvatureByParam (in GEOM_Object theShape, in double theUParam,
+ in double theVParam);
+
+ /*!
+ * Get min radius of curvature of surface in the given point
+ * \param theShape - surface.
+ * \param thePoint - point
+ * \return Value of curvature.
+ */
+ double MinSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
+
};
void Redo (in long theStudyID);
/*!
- * Publishing manangement
+ * Publishing management
* Adds in theStudy a object theObject under with a name theName,
* if theFather is not NULL the object is placed under thFather's SObject.
* Returns a SObject where theObject is placed
in string theName,
in GEOM_Object theFather);
+ /*!
+ * Publish sub-shapes, standing for arguments and sub-shapes of arguments
+ * To be used from python scripts out of geompy.addToStudy (non-default usage)
+ * \param theStudy the study, in which theObject is published already,
+ * and in which the arguments will be published
+ * \param theObject published GEOM object, arguments of which will be published
+ * \param theArgs list of GEOM_Object, operation arguments to be published.
+ * If this list is empty, all operation arguments will be published
+ * \param theFindMethod method to search subshapes, corresponding to arguments and
+ * their subshapes. Value from enumeration GEOM::find_shape_method.
+ * \param theInheritFirstArg set properties of the first argument for \a theObject.
+ * Do not publish subshapes in place of arguments, but only
+ * in place of subshapes of the first argument,
+ * because the whole shape corresponds to the first argument.
+ * Mainly to be used after transformations, but it also can be
+ * usefull after partition with one object shape, and some other
+ * operations, where only the first argument has to be considered.
+ * If theObject has only one argument shape, this flag is automatically
+ * considered as True, not regarding really passed value.
+ * \return True in case of success, False otherwise.
+ */
+ boolean RestoreSubShapesO (in SALOMEDS::Study theStudy,
+ in GEOM_Object theObject,
+ in ListOfGO theArgs,
+ in find_shape_method theFindMethod,
+ in boolean theInheritFirstArg);
+
+ /*!
+ * Publish sub-shapes, standing for arguments and sub-shapes of arguments
+ * To be used from GUI and from geompy.addToStudy.
+ * Work like the above method, but accepts study object theSObject instead of GEOM_Object.
+ * \param theSObject study object, referencing GEOM object, arguments of which will be published
+ */
+ boolean RestoreSubShapesSO (in SALOMEDS::Study theStudy,
+ in SALOMEDS::SObject theSObject,
+ in ListOfGO theArgs,
+ in find_shape_method theFindMethod,
+ in boolean theInheritFirstArg);
+
/*!
* Methods to access interfaces for objects creation and transformation
*/
