-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// 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
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : GEOM_Gen.idl
// Author : Sergey RUIN
module GEOM
{
/*!
- * Topological types of shapes (like Open Cascade types)
+ * \brief Topological types of shapes (like Open Cascade types)
*/
- enum shape_type { COMPOUND, COMPSOLID, SOLID, SHELL,
- FACE, WIRE, EDGE, VERTEX, SHAPE };
+ enum shape_type
+ {
+ /*! */
+ COMPOUND,
+ /*! A collection of solids */
+ COMPSOLID,
+ /*! A part of 3D space bound by a shell */
+ SOLID,
+ /*! A collection of faces connected by some edges of their wire boundaries */
+ SHELL,
+ /*! Part of a plane (in 2D geometry) or a surface (in 3D geometry) bounded by a close wire */
+ FACE,
+ /*! A sequence of edges connected by their vertices */
+ WIRE,
+ /*! Edge, a shape corresponding to a curve, and bound by a vertex at each extremity */
+ EDGE,
+ /*! A zero-dimensional shape corresponding to a point in geometry */
+ VERTEX,
+ /*! */
+ SHAPE };
+ /*!
+ * \brief Marker type
+ */
+ enum marker_type { MT_NONE, MT_POINT, MT_PLUS, MT_STAR, MT_O, MT_X, MT_O_POINT, MT_O_PLUS,
+ MT_O_STAR, MT_O_X, MT_BALL, MT_RING1, MT_RING2, MT_RING3, MT_USER };
+
+ /*!
+ * /brief Marker size
+ */
+ enum marker_size { MS_NONE, MS_10, MS_15, MS_20, MS_25, MS_30, MS_35,
+ MS_40, MS_45, MS_50, MS_55, MS_60, MS_65, MS_70 };
/*!
- * State of shape relatively geometrical surface like plane, sphere or cylinder.
+ * \brief State of shape relatively geometrical surface like plane, sphere or cylinder.
+ *
* Is used in functions GEOM_IShapesOperations.GetShapesOn<xxx>()
*/
enum shape_state
* For sphere and cylinder it means outside of volume, bounded by the surface.
*/
ST_OUT,
-
+
/*!
* Shape is in the direction defined by the normal and on surface.
* ONOUT = ON || OUT
};
/*!
- * Kind of method to find inside one main shape some subshapes,
+ * \brief Kind of method to find inside one main shape some sub-shapes,
* corresponding to other given shape (its argument)
- * Is used in functions GEOM_Gen.RestoreSubShapes<xxx>()
+ *
+ * Is used in functions GEOM_Gen.RestoreSubShapesO(), GEOM_Gen.RestoreSubShapesSO()
*/
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.
+ /*! To be used only for transformation result, to find sub-shapes of argument.
* Only this method can be used after transformation.
*/
FSM_Transformed,
- /*! To find only shared subshapes, not modified by the operation */
+ /*! To find only shared sub-shapes, 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
+ FSM_GetInPlaceByHistory,
+
+ /*! To be used only for multi-transformation result.
+ * Only this method can be used after multi-transformation.
+ */
+ FSM_MultiTransformed
+ };
+
+ /*!
+ * \brief Kind of method to perform filling operation
+ *
+ * Is used in functions GEOM_I3DPrimOperations.MakeFilling()
+ */
+ enum filling_oper_method
+ {
+ /*! Default (standard behaviour) */
+ FOM_Default,
+
+ /*! Use edges orientation - orientation of edges is used: if the edge is
+ * reversed, the curve from this edge is reversed before using it in
+ * the filling algorithm.
+ */
+ FOM_UseOri,
+
+ /*! Auto-correct edges orientation - changes the orientation of the curves
+ * using minimization of sum of distances between the end points of the edges.
+ */
+ FOM_AutoCorrect
+ };
+
+ /*!
+ * \brief Kind of the curves.
+ *
+ * Used in the functions GEOM_ICurvesOperations.MakeCurveParametric(), GEOM_ICurvesOperations.MakeCurveParametricNew()
+ */
+ enum curve_type {
+ /*! Polyline curve */
+ Polyline,
+
+ /*! Bezier curve */
+ Bezier,
+
+ /*! Interpolation, curve */
+ Interpolation
};
typedef sequence<string> string_array;
typedef sequence<short> short_array;
+ typedef sequence<boolean> ListOfBool;
typedef sequence<long> ListOfLong;
typedef sequence<double> ListOfDouble;
typedef sequence<GEOM_Object> ListOfGO;
+ //# GEOM_Object
/*!
- * GEOM_Object: interface of geometric object
+ * \brief Interface of geometric object
*/
interface GEOM_Object : SALOME::GenericObj
{
/*!
- * Get an entry of the object in GEOM component.
+ * \brief Get an entry of the object in GEOM component.
*/
string GetEntry();
/*!
- * Get ID of study, where the object is created.
+ * \brief Get ID of study, where the object is created.
*/
long GetStudyID();
/*!
- * Get internal type of the object (POINT, BOX, CYLINDER, EXTRUSION...).
+ * \brief Get internal type of the object (POINT, BOX, CYLINDER, EXTRUSION...).
*/
long GetType();
/*!
- * Get a <VAR>shape_type</VAR> of the object value.
+ * \brief Get a <VAR>shape_type</VAR> of the object value.
*/
shape_type GetShapeType();
/*!
- * Set name of the object.
+ * \brief Get the topology type of the object value.
+ *
+ * In contrast to the shape type, this function returns type of the most
+ * top-level sub-shape of the COMPOUND or COMPSOLID, if there is only one
+ * sub-shape there.
+ * \sa GetShapeType()
+ */
+ shape_type GetTopologyType();
+
+ /*!
+ * \brief Get a minimal type of the top-level shapes contained in the object.
+ *
+ * This function is useful for the compounds only; for simple shapes it
+ * exactly the same value as GetShapeType().
+ * Note, that compounds are procesed recursively.
+ *
+ * \sa GetShapeType(), GetTopologyType(), GetMaxShapeType()
+ */
+ shape_type GetMinShapeType();
+
+ /*!
+ * \brief Get a maximal type of the top-level shapes contained in the object.
+ *
+ * This function is useful for the compounds only; for simple shapes it
+ * exactly the same value as GetShapeType().
+ * Note, that compounds are procesed recursively.
+ *
+ * \sa GetShapeType(), GetTopologyType(), GetMinShapeType()
+ */
+ shape_type GetMaxShapeType();
+
+ /*!
+ * \brief Set name of the object.
+ *
* \param theName is a name which will be associated with this object.
*/
void SetName (in string theName);
/*!
- * Get name of the object associated with this object.
+ * \brief Get name of the object associated with this object.
*/
string GetName();
/*!
- * Set color of the object.
+ * \brief Set color of the object.
+ *
* \param theColor is a color of the object.
*/
void SetColor(in SALOMEDS::Color theColor);
/*!
* Toggle auto color mode on the object.
- * \param theAtoColor is a flag which toggles auto color mode.
+ * \param theAutoColor is a flag which toggles auto color mode.
*/
void SetAutoColor(in boolean theAutoColor);
/*!
- * Get flag of object's auto color mode.
+ * \brief Get flag of object's auto color mode.
*/
boolean GetAutoColor();
/*!
- * Set a Study entry where this object was published.
+ * \brief Set standard point marker for the object
+ * \param theType standard marker type
+ * \param theSize marker relative size
+ */
+ void SetMarkerStd(in marker_type theType, in marker_size theSize );
+
+ /*!
+ * \brief Set custom point marker for the object.
+ *
+ * The texture can be added by LoadTexture() or AddTexture() functions.
+ * \param theTextureId texture ID
+ */
+ void SetMarkerTexture(in long theTextureId);
+
+ /*!
+ * \brief Get type of the point marker assigned to the object
+ * \return current marker type (MT_NONE if no marker is set)
+ */
+ marker_type GetMarkerType();
+
+ /*!
+ * \brief Get size of the point marker assigned to the object
+ * \return current marker relative size (MS_NONE if no marker is set)
+ */
+ marker_size GetMarkerSize();
+
+ /*!
+ * \brief Get texture idenifier of the point marker assigned to the object
+ * \return marker texture ID (0 if no marker set)
+ */
+ long GetMarkerTexture();
+
+ /*!
+ * \brief Set a Study entry where this object was published.
*/
void SetStudyEntry (in string theEntry);
/*!
- * Get a Study entry where this object was published.
+ * \brief Get a Study entry where this object was published.
*/
string GetStudyEntry();
/*!
- * Get a list of all GEOM objects on which were the arguments
+ * \brief Get a list of all GEOM_Object on which were the arguments
* when this object was constructed and modified.
* \note This method is supposed to be used by GUI only.
*/
ListOfGO GetDependency();
/*!
- * Get a list of GEOM objects on which the last function that created or modified the object depends.
+ * \brief Get a list of GEOM_Object on which the last function that created or modified the object depends.
* \note This method is supposed to be used by GUI only.
*/
ListOfGO GetLastDependency();
/*!
- * Get the TopoDS_Shape, for colocated case only.
+ * \brief Get the TopoDS_Shape, for colocated case only.
*/
long long getShape();
+ // ######################################################################
+ // # Internal methods (For sub-shape identification)
+ // ######################################################################
/*!
- ######################################################################
- * Internal methods (For sub shape identification)
- ######################################################################
- */
-
- /*!
- * Get geometric shape of the object as a byte stream
+ * \brief Get geometric shape of the object as a byte stream
*/
SALOMEDS::TMPFile GetShapeStream();
/*
- * Returns True if this object is not a sub shape of another object.
+ * \brief Returns True if this object is not a sub-shape of another object.
*/
boolean IsMainShape();
/*
- * Get a list of ID's of sub shapes in the main shape.
+ * \brief Get a list of ID's of sub-shapes in the main shape.
* \note Internal method, suppopsed to be used only by GEOM_Client
*/
ListOfLong GetSubShapeIndices();
/*
- * Get a main shape object to which this object is a sub shape
+ * \brief Get a main shape object to which this object is a sub-shape
* \note Internal method, suppopsed to be used only by GEOM_Client
*/
GEOM_Object GetMainShape();
/*
- * Return true if geom object representes a shape.
+ * \brief Return true if geom object representes a shape.
+ *
* For example, method return false for GEOM_MARKER
*/
boolean IsShape();
+ /*
+ * \brief Return true if passed object is identical to this object
+ *
+ * \param other object being compared with this one
+ */
+ boolean IsSame(in GEOM_Object other);
+
/*!
* Set list of parameters
* \param theParameters is a string containing the notebook variables separated by ":" symbol,
* used for object creation
*/
void SetParameters (in string theParameters);
-
+
/*!
- * Return list of notebook variables used for object creation separated by ":" symbol
+ * \brief Return list of notebook variables used for object creation separated by ":" symbol
*/
string GetParameters();
};
-
+ // # GEOM_IOperations:
/*!
- * GEOM_IOperations: basic methods of all geometric operations
+ * \brief Basic methods of all geometric operations
*/
interface GEOM_IOperations : SALOME::GenericObj
{
/*!
- * To know, if the operation was successfully performed
+ * \brief To know, if the operation was successfully performed
*/
boolean IsDone();
/*!
- * Set the operation error code
+ * \brief Set the operation error code
* \param theErrorID is a string describing the error occured
* \note This method is supposed to be used only by interfaces inheriting from IOperations.
*/
void SetErrorCode (in string theErrorID);
/*!
- * Get the operation error code
+ * \brief Get the operation error code
*/
string GetErrorCode();
/*!
- * Get ID of study, where the operation is defined
+ * \brief Get ID of study, where the operation is defined
*/
long GetStudyID();
/*!
- * Opens a new transaction
+ * \brief Opens a new transaction
*/
void StartOperation();
/*!
- * Closes the previously opened trasaction
+ * \brief Closes the previously opened trasaction
*/
void FinishOperation();
/*!
- * Aborts the previously opened transaction
+ * \brief Aborts the previously opened transaction
*/
void AbortOperation();
};
-
+ //# GEOM_IBasicOperations:
/*!
- * GEOM_IBasicOperations: interface for basic geometry creation
+ * \brief Interface for basic geometry creation
+ *
* (Point, Vector, Plane, Marker)
*/
interface GEOM_IBasicOperations : GEOM_IOperations
{
/*!
- * Create point by three coordinates.
+ * \brief Create point by three coordinates.
* \param theX The X coordinate of the point.
* \param theY The Y coordinate of the point.
* \param theZ The Z coordinate of the point.
GEOM_Object MakePointXYZ (in double theX, in double theY, in double theZ);
/*!
- * Create a point, distant from the referenced point
+ * \brief Create a point, distant from the referenced point
* on the given distances along the coordinate axes.
* \param theReference The referenced point.
* \param theX Displacement from the referenced point along OX axis.
* \return New GEOM_Object, containing the created point.
*/
GEOM_Object MakePointWithReference (in GEOM_Object theReference,
- in double theX, in double theY, in double theZ);
+ in double theX, in double theY, in double theZ);
/*!
* Create a point, corresponding to the given parameter on the given curve.
* \return New GEOM_Object, containing the created point.
*/
GEOM_Object MakePointOnCurve (in GEOM_Object theRefCurve,
- in double theParameter);
+ in double theParameter);
+
+ /*!
+ * \brief Create a point, corresponding to the given length on the given curve.
+ * \param theRefCurve The referenced curve.
+ * \param theLength Length on the referenced curve. It can be negative.
+ * \param theStartPoint Any vertex close to one of edge's
+ * ends to select start point among them.
+ * If NULL, fist vertex is used.
+ * \return New GEOM_Object, containing the created point.
+ */
+ GEOM_Object MakePointOnCurveByLength (in GEOM_Object theRefCurve,
+ in double theLength,
+ in GEOM_Object theStartPoint);
/*!
- * Create a point on the given curve, projecting given point
+ * \brief Create a point on the given curve, projecting given point
* \param theRefCurve The referenced curve.
* \param theXParameter X co-ordinate of point to project on curve
* \param theYParameter Y co-ordinate of point to project on curve
*/
GEOM_Object MakePointOnCurveByCoord (in GEOM_Object theRefCurve,
in double theXParameter,
- in double theYarameter,
- in double theZPameter);
+ in double theYParameter,
+ in double theZParameter);
/*!
- * Create a point, corresponding to the given parameters on the
+ * \brief 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.
* \return New GEOM_Object, containing the created point.
*/
GEOM_Object MakePointOnSurface (in GEOM_Object theRefSurf,
- in double theUParameter,
- in double theVParameter);
+ in double theUParameter,
+ in double theVParameter);
/*!
- * Create a point on the given surface, projecting given point
+ * \brief Create a point on the given surface, projecting given point
* \param theRefSurf The referenced surface.
* \param theXParameter X co-ordinate of point to project on curve
* \param theYParameter Y co-ordinate of point to project on curve
*/
GEOM_Object MakePointOnSurfaceByCoord (in GEOM_Object theRefSurf,
in double theXParameter,
- in double theYarameter,
- in double theZPameter);
+ in double theYParameter,
+ in double theZParameter);
/*!
- * Create a point, on two lines intersection.
+ * \brief 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);
+ in GEOM_Object theRefLine2);
/*!
- * Create a vector, corresponding to tangent to the given parameter on the given curve.
+ * \brief 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.
+ * between 0. and 1.. Value of 0. corresponds first parameter of curve; value
+ * 1. corresponds last parameter of curve.
* \return New GEOM_Object, containing the created point.
*/
GEOM_Object MakeTangentOnCurve (in GEOM_Object theRefCurve,
- in double theParameter);
+ in double theParameter);
/*!
- * Create a vector with the given components.
+ * \brief Create a vector with the given components.
* \param theDX X component of the vector.
* \param theDY Y component of the vector.
* \param theDZ Z component of the vector.
* \return New GEOM_Object, containing the created vector.
*/
GEOM_Object MakeVectorDXDYDZ (in double theDX,
- in double theDY,
- in double theDZ);
+ in double theDY,
+ in double theDZ);
/*!
- * Create a vector between two points.
+ * \brief Create a vector between two points.
* \param thePnt1 Start point for the vector.
* \param thePnt2 End point for the vector.
* \return New GEOM_Object, containing the created vector.
GEOM_Object MakeVectorTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
/*!
- * Create a line, passing through the given point
+ * C\brief reate a line, passing through the given point
* and parrallel to the given direction
* \param thePnt Point. The resulting line will pass through it.
* \param theDir Direction. The resulting line will be parallel to it.
GEOM_Object MakeLine (in GEOM_Object thePnt, in GEOM_Object theDir);
/*!
- * Create a line, passing through the given points
+ * \brief Create a line, passing through the given points
* \param thePnt1 First of two points, defining the line.
* \param thePnt2 Second of two points, defining the line.
* \return New GEOM_Object, containing the created line.
GEOM_Object MakeLineTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
/*!
- * Create a line, given by two faces intersection.
+ * \brief 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
+ * \brief Create a plane, passing through the three given points
* \param thePnt1 First of three points, defining the plane.
* \param thePnt2 Second of three points, defining the plane.
* \param thePnt3 Fird of three points, defining the plane.
* \return New GEOM_Object, containing the created plane.
*/
GEOM_Object MakePlaneThreePnt (in GEOM_Object thePnt1,
- in GEOM_Object thePnt2,
- in GEOM_Object thePnt3,
- in double theTrimSize);
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3,
+ in double theTrimSize);
/*!
- * Create a plane, passing through the given point
+ * \brief Create a plane, passing through the given point
* and normal to the given vector.
* \param thePnt Point, the plane has to pass through.
* \param theVec Vector, defining the plane normal direction.
* \return New GEOM_Object, containing the created plane.
*/
GEOM_Object MakePlanePntVec (in GEOM_Object thePnt,
- in GEOM_Object theVec,
- in double theTrimSize);
+ in GEOM_Object theVec,
+ in double theTrimSize);
/*!
- * Create a plane, similar to the existing one, but with another size of representing face.
+ * \brief Create a plane, similar to the existing one, but with another size of representing face.
* \param theFace Referenced plane or LCS(Marker).
* \param theTrimSize New half size of a side of quadrangle face, representing the plane.
* \return New GEOM_Object, containing the created plane.
*/
GEOM_Object MakePlaneFace (in GEOM_Object theFace,
- in double theTrimSize);
-
+ in double theTrimSize);
+
/*!
- * Create a plane, by two vectors.
+ * \brief Create a plane, by two vectors.
* \param theVec1 Vector1, the plane has to pass through first point of this vector.
- * \param theVec Vector2, defining the plane normal direction.
+ * \param theVec2 Vector2, defining the plane normal direction.
* \param theTrimSize Half size of a side of quadrangle face, representing the plane.
* \return New GEOM_Object, containing the created plane.
*/
GEOM_Object MakePlane2Vec (in GEOM_Object theVec1,
- in GEOM_Object theVec2,
- in double theTrimSize);
-
+ in GEOM_Object theVec2,
+ in double theTrimSize);
+
/*!
- * Create a plane, defined by local coordinate system.
+ * \brief Create a plane, defined by local coordinate system.
* \param theLCS Referenced LCS(Marker).
* \param theTrimSize Half size of a side of quadrangle face, representing the plane.
* \param theOrientation OXY, OYZ or OZX orientation = (1, 2 or 3).
* \return New GEOM_Object, containing the created plane.
*/
GEOM_Object MakePlaneLCS (in GEOM_Object theLCS,
- in double theTrimSize,
- in double theOrientation);
+ in double theTrimSize,
+ in double theOrientation);
/*!
- * Create a local coordinate system.
+ * \brief Create a local coordinate system.
* \param theOX,theOY,theOZ Three coordinates of coordinate system origin.
* \param theXDX,theXDY,theXDZ Three components of OX direction
* \param theYDX,theYDY,theYDZ Three components of OY direction
* \return New GEOM_Object, containing the created coordinate system.
*/
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);
+ in double theXDX, in double theXDY, in double theXDZ,
+ in double theYDX, in double theYDY, in double theYDZ);
+
+ /*!
+ * \brief Create a local coordinate system from shape.
+ * \param theShape The initial shape to detect the coordinate system.
+ * \return New GEOM_Object, containing the created coordinate system.
+ */
+ GEOM_Object MakeMarkerFromShape (in GEOM_Object theShape);
+
+ /*!
+ * \brief Create a local coordinate system from point and two vectors (DX, DY).
+ * \param theOrigin Point of coordinate system origin.
+ * \param theXVec Vector of X direction.
+ * \param theYVec Vector of Y direction.
+ * \return New GEOM_Object, containing the created coordinate system.
+ */
+ GEOM_Object MakeMarkerPntTwoVec (in GEOM_Object theOrigin,
+ in GEOM_Object theXVec, in GEOM_Object theYVec);
/*!
- * Create a tangent plane to specified face in the point with specified parameters.
+ * \brief 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 theParameterU - value of parameter by U
* \return New GEOM_Object, containing the face built on tangent plane.
*/
GEOM_Object MakeTangentPlaneOnFace(in GEOM_Object theFace,
- in double theParameterU,
- in double theParameterV,
- in double theTrimSize);
+ in double theParameterU,
+ in double theParameterV,
+ in double theTrimSize);
};
interface GEOM_ITransformOperations : GEOM_IOperations
{
/*!
- * Translate the given object along the vector, specified by its end points.
+ * \brief Translate the given object along the vector, specified by its end points.
* \param theObject The object to be translated.
* \param thePoint1 Start point of translation vector.
* \param thePoint2 End point of translation vector.
* \return theObject.
*/
GEOM_Object TranslateTwoPoints (in GEOM_Object theObject,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2);
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
/*!
- * Translate the given object along the vector, specified
+ * \brief Translate the given object along the vector, specified
* by its end points, creating its copy before the translation.
* \param theObject The object to be translated.
* \param thePoint1 Start point of translation vector.
* \return New GEOM_Object, containing the translated object.
*/
GEOM_Object TranslateTwoPointsCopy (in GEOM_Object theObject,
- in GEOM_Object thePoint1,
+ in GEOM_Object thePoint1,
in GEOM_Object thePoint2);
/*!
- * Translate the given object along the vector, specified by its components.
+ * \brief Translate the given object along the vector, specified by its components.
* \param theObject The object to be translated.
* \param theDX,theDY,theDZ Components of translation vector.
* \return theObject.
*/
GEOM_Object TranslateDXDYDZ (in GEOM_Object theObject,
- in double theDX, in double theDY, in double theDZ);
+ in double theDX, in double theDY, in double theDZ);
/*!
- * Translate the given object along the vector, specified
+ * \brief Translate the given object along the vector, specified
* by its components, creating its copy before the translation.
* \param theObject The object to be translated.
* \param theDX,theDY,theDZ Components of translation vector.
* \return New GEOM_Object, containing the translated object.
*/
GEOM_Object TranslateDXDYDZCopy (in GEOM_Object theObject,
- in double theDX, in double theDY, in double theDZ);
+ in double theDX, in double theDY, in double theDZ);
/*!
- * Translate the given object along the given vector.
+ * \brief Translate the given object along the given vector.
* \param theObject The object to be translated.
* \param theVector Translation vector, giving both direction and distance.
* \return theObject.
*/
GEOM_Object TranslateVector (in GEOM_Object theObject,
- in GEOM_Object theVector);
+ in GEOM_Object theVector);
/*!
- * Translate the given object along the given vector,
+ * \brief Translate the given object along the given vector,
* creating its copy before the translation.
* \param theObject The object to be translated.
* \param theVector Translation vector, giving both direction and distance.
* \return New GEOM_Object, containing the translated object.
*/
GEOM_Object TranslateVectorCopy (in GEOM_Object theObject,
- in GEOM_Object theVector);
+ in GEOM_Object theVector);
/*!
- * Translate the given object along the given vector on given distance,
+ * \brief 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.
+ * \param theCopy 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);
+ in GEOM_Object theVector,
+ in double theDistance,
+ in boolean theCopy);
/*!
- * Translate the given object along the given vector a given number times
+ * \brief Translate the given object along the given vector a given number times
* \param theObject The object to be translated.
* \param theVector Direction of the translation.
* \param theStep Distance to translate on.
* the shapes, obtained after each translation.
*/
GEOM_Object MultiTranslate1D (in GEOM_Object theObject,
- in GEOM_Object theVector,
- in double theStep,
- in long theNbTimes);
+ in GEOM_Object theVector,
+ in double theStep,
+ in long theNbTimes);
/*!
- * Conseqently apply two specified translations to theObject specified number of times.
+ * \brief Conseqently apply two specified translations to theObject specified number of times.
* \param theObject The object to be translated.
* \param theVector1 Direction of the first translation.
* \param theStep1 Step of the first translation.
* the shapes, obtained after each translation.
*/
GEOM_Object MultiTranslate2D (in GEOM_Object theObject,
- in GEOM_Object theVector1,
- in double theStep1,
- in long theNbTimes1,
- in GEOM_Object theVector2,
- in double theStep2,
- in long theNbTimes2);
+ in GEOM_Object theVector1,
+ in double theStep1,
+ in long theNbTimes1,
+ in GEOM_Object theVector2,
+ in double theStep2,
+ in long theNbTimes2);
/*!
- * Rotate given object around vector perpendicular to plane containing three points.
+ * \brief Rotate given object around vector perpendicular to plane containing three points.
* \param theObject The object to be rotated.
* \param theCentPoint central point - the axis is the vector perpendicular to the plane
- * containing the three points.
- * \param thePoint1 and thePoint2 - in a perpendicular plan of the axis.
+ * containing the three points.
+ * \param thePoint1,thePoint2 - in a perpendicular plan of the axis.
* \return theObject.
*/
GEOM_Object RotateThreePoints (in GEOM_Object theObject,
- in GEOM_Object theCentPoint,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2);
+ in GEOM_Object theCentPoint,
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
/*!
- * Rotate given object around vector perpendicular to plane containing three points.
+ * \brief Rotate given object around vector perpendicular to plane containing three points.
+ *
* Creating its copy before the rotatation.
* \param theObject The object to be rotated.
* \param theCentPoint central point - the axis is the vector perpendicular to the plane
* containing the three points.
- * \param thePoint1 and thePoint2 - in a perpendicular plan of the axis.
+ * \param thePoint1,thePoint2 - in a perpendicular plan of the axis.
* \return New GEOM_Object, containing the rotated object.
*/
GEOM_Object RotateThreePointsCopy (in GEOM_Object theObject,
- in GEOM_Object theCentPoint,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2);
+ in GEOM_Object theCentPoint,
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
/*!
- * Rotate the given object around the given axis on the given angle.
+ * \brief Rotate the given object around the given axis on the given angle.
* \param theObject The object to be rotated.
* \param theAxis Rotation axis.
* \param theAngle Rotation angle in radians.
* \return theObject.
*/
GEOM_Object Rotate (in GEOM_Object theObject,
- in GEOM_Object theAxis,
- in double theAngle);
+ in GEOM_Object theAxis,
+ in double theAngle);
/*!
* \return New GEOM_Object, containing the rotated object.
*/
GEOM_Object RotateCopy (in GEOM_Object theObject,
- in GEOM_Object theAxis,
- in double theAngle);
+ in GEOM_Object theAxis,
+ in double theAngle);
/*!
- * Rotate the given object around the given axis a given number times.
+ * \brief Rotate the given object around the given axis a given number times.
+ *
* Rotation angle will be 2*PI/theNbTimes.
* \param theObject The object to be rotated.
* \param theAxis The rotation axis.
* shapes, obtained after each rotation.
*/
GEOM_Object MultiRotate1D (in GEOM_Object theObject,
- in GEOM_Object theAxis,
- in long theNbTimes);
+ in GEOM_Object theAxis,
+ in long theNbTimes);
/*!
- * Rotate the given object around the
+ * \brief Rotate the given object around the
* given axis on the given angle a given number
* times and multi-translate each rotation result.
+ *
* Translation direction passes through center of gravity
* of rotated shape and its projection on the rotation axis.
* \param theObject The object to be rotated.
* shapes, obtained after each transformation.
*/
GEOM_Object MultiRotate2D (in GEOM_Object theObject,
- in GEOM_Object theAxis,
- in double theAngle,
- in long theNbTimes1,
- in double theStep,
- in long theNbTimes2);
+ in GEOM_Object theAxis,
+ in double theAngle,
+ in long theNbTimes1,
+ in double theStep,
+ in long theNbTimes2);
/*!
- * Replace the given object by an object,
+ * \brief Replace the given object by an object,
* symmetrical to it relatively the given plane.
* \param theObject The object to be mirrored.
* \param thePlane Plane of symmetry.
GEOM_Object MirrorPlane (in GEOM_Object theObject, in GEOM_Object thePlane);
/*!
- * Create an object, symmetrical
+ * \brief Create an object, symmetrical
* to the given one relatively the given plane.
* \param theObject The object to be mirrored.
* \param thePlane Plane of symmetry.
GEOM_Object MirrorPlaneCopy (in GEOM_Object theObject, in GEOM_Object thePlane);
/*!
- * Replace the given object by an object,
+ * \brief Replace the given object by an object,
* symmetrical to it relatively the given axis.
* \param theObject The object to be mirrored.
* \param theAxis Axis of symmetry.
GEOM_Object MirrorAxis (in GEOM_Object theObject, in GEOM_Object theAxis);
/*!
- * Create an object, symmetrical
+ * \brief Create an object, symmetrical
* to the given one relatively the given axis.
* \param theObject The object to be mirrored.
* \param theAxis Axis of symmetry.
GEOM_Object MirrorAxisCopy (in GEOM_Object theObject, in GEOM_Object theAxis);
/*!
- * Replace the given object by an object, symmetrical to it relatively the given point.
+ * \brief Replace the given object by an object, symmetrical to it relatively the given point.
* \param theObject The object to be mirrored.
* \param thePoint Point of symmetry.
* \return theObject.
GEOM_Object MirrorPoint (in GEOM_Object theObject, in GEOM_Object thePoint);
/*!
- * Create an object, symmetrical to the given one relatively the given point.
+ * \brief Create an object, symmetrical to the given one relatively the given point.
* \param theObject The object to be mirrored.
* \param thePoint Point of symmetry.
* \return New GEOM_Object, containing the mirrored object.
GEOM_Object MirrorPointCopy (in GEOM_Object theObject, in GEOM_Object thePoint);
/*!
- * Replace the given object by its offset.
+ * \brief Replace the given object by its offset.
* \param theObject The base object for the offset.
* \param theOffset Offset value.
* \return theObject.
GEOM_Object OffsetShape (in GEOM_Object theObject, in double theOffset);
/*!
- * Create new object as offset of the given one.
+ * \brief Create new object as offset of the given one.
* \param theObject The base object for the offset.
* \param theOffset Offset value.
* \return New GEOM_Object, containing the offset object.
GEOM_Object OffsetShapeCopy (in GEOM_Object theObject, in double theOffset);
/*!
- * Scale the given object by the factor.
+ * \brief Create new object as projection of the given one on a 2D surface.
+ * \param theSource The source object for the projection. It can be a point, edge or wire.
+ * \param theTarget The target object. It can be planar or cylindrical face.
+ * \return New GEOM_Object, containing the projection.
+ */
+ GEOM_Object ProjectShapeCopy (in GEOM_Object theSource, in GEOM_Object theTarget);
+
+ /*!
+ * \brief Scale the given object by the factor.
* \param theObject The object to be scaled.
* \param thePoint Center point for scaling.
* \param theFactor Scaling factor value.
* \return theObject.
*/
GEOM_Object ScaleShape (in GEOM_Object theObject, in GEOM_Object thePoint,
- in double theFactor);
+ in double theFactor);
/*!
- * Scale the given object by the factor, creating its copy before the scaling.
+ * \brief Scale the given object by the factor, creating its copy before the scaling.
* \param theObject The object to be scaled.
* \param thePoint Center point for scaling.
* \param theFactor Scaling factor value.
* \return New GEOM_Object, containing the scaled shape.
*/
GEOM_Object ScaleShapeCopy (in GEOM_Object theObject, in GEOM_Object thePoint,
- in double theFactor);
+ in double theFactor);
/*!
- * Scale the given object by different factors along coordinate axes.
+ * \brief 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.
in double theFactorZ);
/*!
- * Scale the given object by different factors along coordinate axes,
+ * \brief 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.
in double theFactorZ);
/*!
- * Modify the Location of the given object by LCS.
+ * \brief Modify the Location of the given object by LCS.
* \param theObject The object to be displaced.
* \param theStartLCS Coordinate system to perform displacement from it.
* If \a theStartLCS is NULL, displacement
* \return theObject.
*/
GEOM_Object PositionShape (in GEOM_Object theObject,
- in GEOM_Object theStartLCS,
- in GEOM_Object theEndLCS);
+ in GEOM_Object theStartLCS,
+ in GEOM_Object theEndLCS);
/*!
- * Modify the Location of the given object by LCS,
+ * \brief Modify the Location of the given object by LCS,
* creating its copy before the setting.
* \param theObject The object to be displaced.
* \param theStartLCS Coordinate system to perform displacement from it.
* \return New GEOM_Object, containing the displaced shape.
*/
GEOM_Object PositionShapeCopy (in GEOM_Object theObject,
- in GEOM_Object theStartLCS,
- in GEOM_Object theEndLCS);
+ in GEOM_Object theStartLCS,
+ in GEOM_Object theEndLCS);
/*!
- * Modify the Location of the given object by Path,
+ * \brief Modify the Location of the given object by Path,
* \param theObject The object to be displaced.
* \param thePath Wire or Edge along that the object will be translated.
- * \param theDistance progress of Path (0 = actual location, 1 = end of path location).
- * \param theCopy is a true or false parameter. true is to create a copy, false to move the object.
- * \param theCopy is a true or false parameter. true is to reverse direction, false is to move normal direction.
+ * \param theDistance progress of Path (0 = actual location, 1 = end of path location).
+ * \param theCopy is a true or false parameter. true is to create a copy, false to move the object.
+ * \param theReverse is a true or false parameter. true is to reverse direction, false is to move normal direction.
* \return New GEOM_Object, containing the displaced shape.
*/
-
GEOM_Object PositionAlongPath (in GEOM_Object theObject,
- in GEOM_Object thePath,
- in double theDistance,
- in boolean theCopy,
- in boolean theReverse);
+ in GEOM_Object thePath,
+ in double theDistance,
+ in boolean theCopy,
+ in boolean theReverse);
+
+ /*!
+ * \brief Transform the shape in the same way what was used for the sample shape creation.
+ * \param theObject The object to be transformed.
+ * \param theSample The object containing information about required transformation.
+ * \note Implementation of this method is limited by multi-transformations now.
+ * \note Internal method.
+ * \return New GEOM_Object, containing the transformed shape.
+ */
+ GEOM_Object TransformLikeOtherCopy (in GEOM_Object theObject,
+ in GEOM_Object theSample);
/*!
- * Recompute the shape from its arguments.
+ * \brief Recompute the shape from its arguments.
* \param theObject The object to be recomputed.
* \return theObject.
*/
GEOM_Object RecomputeObject (in GEOM_Object theObject);
};
-
+
+ // # GEOM_I3DPrimOperations:
/*!
- * GEOM_I3DPrimOperations: Interface for 3D primitives creation
+ * \brief Interface for 3D primitives creation
+ *
* Box, Cylinder, Cone, Sphere, Prism (extrusion),
* Pipe (extrusion along contour), Revolution, Solid (from shell).
*/
interface GEOM_I3DPrimOperations : GEOM_IOperations
{
/*!
- * Create a box with specified dimensions along the coordinate axes
+ * \brief Create a box with specified dimensions along the coordinate axes
* and with edges, parallel to the coordinate axes.
+ *
* Center of the box will be at point (DX/2, DY/2, DZ/2).
* \param theDX Length of Box edges, parallel to OX axis.
* \param theDY Length of Box edges, parallel to OY axis.
GEOM_Object MakeBoxDXDYDZ (in double theDX, in double theDY, in double theDZ);
/*!
- * Create a box with two specified opposite vertices,
+ * \brief Create a box with two specified opposite vertices,
* and with edges, parallel to the coordinate axes
* \param thePnt1 First of two opposite vertices.
* \param thePnt2 Second of two opposite vertices.
GEOM_Object MakeBoxTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
/*!
- * Create a face specified dimensions along OX-OY coordinate axes,
+ * \brief 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.
*/
GEOM_Object MakeFaceHW (in double theH, in double theW, in short theOrientation);
/*!
- * Create a face by normale vector or edge and two specified sizes,
+ * \brief Create a face by normale vector or edge and two specified sizes,
* vertical (H) and horisontal (W).
- * \param theVec defines plane.
+ * \param theObj defines plane.
* \param theH vertical size (height).
- * \param theW horisontal size (width).
+ * \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.
+ * \brief 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);
+ in GEOM_Object theVec,
+ in double theR);
/*!
- * Create a disk (circular face), passing through three given points
+ * \brief 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);
-
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3);
+
/*!
- * Create a disk specified dimensions along OX-OY coordinate axes,
+ * \brief 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
- * will be collinear to the OZ axis of the coordinate system.
+ * \brief Create a cylinder with given radius and height at
+ * the origin of coordinate system.
+ *
+ * Axis of the cylinder will be collinear to the OZ axis of the coordinate system.
* \param theR Cylinder radius.
* \param theH Cylinder height.
* \return New GEOM_Object, containing the created cylinder.
GEOM_Object MakeCylinderRH (in double theR, in double theH);
/*!
- * Create a cylinder with given base point, axis, radius and height.
+ * \brief Create a cylinder with given base point, axis, radius and height.
* \param thePnt Central point of cylinder base.
* \param theAxis Cylinder axis.
* \param theR Cylinder radius.
* \return New GEOM_Object, containing the created cylinder.
*/
GEOM_Object MakeCylinderPntVecRH (in GEOM_Object thePnt,
- in GEOM_Object theAxis,
- in double theR,
- in double theH);
+ in GEOM_Object theAxis,
+ in double theR,
+ in double theH);
/*!
- * Create a cone with given height and radiuses at
- * the origin of coordinate system. Axis of the cone will
- * be collinear to the OZ axis of the coordinate system.
+ * \brief Create a cone with given height and radiuses at
+ * the origin of coordinate system.
+ *
+ * Axis of the cone will be collinear to the OZ axis of the coordinate system.
* \param theR1 Radius of the first cone base.
* \param theR2 Radius of the second cone base.
* \note If both radiuses are non-zero, the cone will be truncated.
GEOM_Object MakeConeR1R2H (in double theR1, in double theR2, in double theH);
/*!
- * Create a cone with given base point, axis, height and radiuses.
+ * \brief Create a cone with given base point, axis, height and radiuses.
* \param thePnt Central point of the first cone base.
* \param theAxis Cone axis.
* \param theR1 Radius of the first cone base.
* \return New GEOM_Object, containing the created cone.
*/
GEOM_Object MakeConePntVecR1R2H (in GEOM_Object thePnt,
- in GEOM_Object theAxis,
- in double theR1,
- in double theR2,
- in double theH);
+ in GEOM_Object theAxis,
+ in double theR1,
+ in double theR2,
+ in double theH);
/*!
- * Create a torus with given radiuses at the origin of coordinate system.
+ * \brief Create a torus with given radiuses at the origin of coordinate system.
* \param theRMajor Torus major radius.
* \param theRMinor Torus minor radius.
* \return New GEOM_Object, containing the created torus.
*/
GEOM_Object MakeTorusRR (in double theRMajor,
- in double theRMinor);
+ in double theRMinor);
/*!
- * Create a torus with given center, normal vector and radiuses.
+ * \brief Create a torus with given center, normal vector and radiuses.
* \param thePnt Torus central point.
* \param theVec Torus axis of symmetry.
* \param theRMajor Torus major radius.
* \return New GEOM_Object, containing the created torus.
*/
GEOM_Object MakeTorusPntVecRR (in GEOM_Object thePnt,
- in GEOM_Object theVec,
- in double theRMajor,
- in double theRMinor);
+ in GEOM_Object theVec,
+ in double theRMajor,
+ in double theRMinor);
/*!
- * Create a sphere with given radius at the origin of coordinate system.
+ * \brief Create a sphere with given radius at the origin of coordinate system.
* \param theR Sphere radius.
* \return New GEOM_Object, containing the created sphere.
*/
GEOM_Object MakeSphereR (in double theR);
/*!
- * Create a sphere with given center and radius.
+ * \brief Create a sphere with given center and radius.
* \param thePnt Sphere center.
* \param theR Sphere radius.
* \return New GEOM_Object, containing the created .
GEOM_Object MakeSpherePntR (in GEOM_Object thePnt, in double theR);
/*!
- * Create a shape by extrusion of the base shape along the vector,
- * i.e. all the space, transfixed by the base shape during its translation
+ * \brief Create a shape by extrusion of the base shape along the vector
+ *
+ * All the space, transfixed by the base shape during its translation
* along the vector on the given distance.
* \param theBase Base shape to be extruded.
* \param theVec Direction of extrusion.
* \return New GEOM_Object, containing the created prism.
*/
GEOM_Object MakePrismVecH (in GEOM_Object theBase,
- in GEOM_Object theVec,
- in double theH);
- /* The Same Prism but in 2 directions (forward&backward) */
+ in GEOM_Object theVec,
+ in double theH);
+ /* \brief The Same Prism but in 2 directions (forward&backward) */
GEOM_Object MakePrismVecH2Ways (in GEOM_Object theBase,
- in GEOM_Object theVec,
- in double theH);
+ in GEOM_Object theVec,
+ in double theH);
+ /* \brief The Same as MakePrismVecH but with scaling */
+ GEOM_Object MakePrismVecHWithScaling (in GEOM_Object theBase,
+ in GEOM_Object theVec,
+ in double theH,
+ in double theScaleFactor);
/*!
- * Create a shape by extrusion of the base shape along a vector, defined by two points.
+ * \brief Create a shape by extrusion of the base shape along a vector, defined by two points.
* \param theBase Base shape to be extruded.
* \param thePoint1 First end of extrusion vector.
* \param thePoint2 Second end of extrusion vector.
* \return New GEOM_Object, containing the created prism.
*/
GEOM_Object MakePrismTwoPnt (in GEOM_Object theBase,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2);
- /* The same prism but in two directions forward&backward */
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
+ /* \brief The same prism but in two directions forward&backward */
GEOM_Object MakePrismTwoPnt2Ways (in GEOM_Object theBase,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2);
-
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
+ /* \brief The Same as MakePrismTwoPnt but with scaling */
+ GEOM_Object MakePrismTwoPntWithScaling (in GEOM_Object theBase,
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2,
+ in double theScaleFactor);
+
/*!
- * Create a shape by extrusion of the base shape along a vector, defined by DX DY DZ.
+ * \brief 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.
+ * \param theDX, theDY, theDZ 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 */
+ in double theDX, in double theDY, in double theDZ);
+ /* \brief 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);
+ /* \brief The Same as MakePrismDXDYDZ but with scaling */
+ GEOM_Object MakePrismDXDYDZWithScaling (in GEOM_Object theBase,
+ in double theDX, in double theDY, in double theDZ,
+ in double theScaleFactor);
+
+
+ /*!
+ * \brief Add / Remove material to / from a solid by extrusion of the base shape on the given distance.
+ * \param theInitShape Initial shape on which to perform the feature.It has to be a solid or
+ * a compound made of a single solid
+ * \param theBase Edge or wire defining the base shape to be extruded.
+ * \param theHeight Prism dimension along the normal of the face.
+ * \param theAngle Draft angel in degrees
+ * \param theFuse If true material is added else material is removed
+ * \return New GEOM_Object, containing the modified shape
+ */
+ GEOM_Object MakeDraftPrism (in GEOM_Object theInitShape,
+ in GEOM_Object theBase,
+ in double theHeight,
+ in double theAngle,
+ in boolean theFuse);
/*!
- * Create a shape by extrusion of the base shape along
+ * \brief Create a shape by extrusion of the base shape along
* the path shape. 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.
GEOM_Object MakePipe (in GEOM_Object theBase, in GEOM_Object thePath);
/*!
- * Create a shape by revolution of the base shape around the axis
- * on the given angle, i.e. all the space, transfixed by the base
+ * \brief Create a shape by revolution of the base shape around the axis
+ * on the given angle.
+ *
+ * All the space, transfixed by the base
* shape during its rotation around the axis on the given angle.
* \param theBase Base shape to be rotated.
* \param theAxis Rotation axis.
* \return New GEOM_Object, containing the created revolution.
*/
GEOM_Object MakeRevolutionAxisAngle (in GEOM_Object theBase,
- in GEOM_Object theAxis,
- in double theAngle);
+ 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);
+ in GEOM_Object theAxis,
+ in double theAngle);
/*!
- * Create a filling from the given compound of contours.
+ * \brief Create a filling from the given compound of contours.
+ * \param theShape Initial shape on which to perform the feature.
* \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
+ * \param theMethod Kind of method to perform filling operation.
+ * \param theApprox Boolean indicating if result should be approximated
* \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 boolean theApprox);
+ in long theMinDeg, in long theMaxDeg,
+ in double theTol2D, in double theTol3D,
+ in long theNbIter,
+ in filling_oper_method theMethod,
+ in boolean theApprox);
/*!
- * Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
+ * \brief Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
* \param theSeqSections - set of specified sections.
* \param theModeSolid - mode defining building solid or shell
* \param thePreci - precision 3D used for smoothing by default 1.e-6
* \return New GEOM_Object, containing the created shell or solid.
*/
GEOM_Object MakeThruSections(in ListOfGO theSeqSections,
- in boolean theModeSolid,
- in double thePreci,
+ in boolean theModeSolid,
+ in double thePreci,
in boolean theRuled);
- /*!
- * Create a shape by extrusion of the profile shape along
- * the path shape. The path shape can be a wire or an edge.
- * the several profiles can be specified in the several locations of path.
+ /*!
+ * \brief Create a shape by extrusion of the profile shape along
+ * the path shape.
+ *
+ * The path shape can be a wire or an edge.
+ * the several profiles can be specified in the several locations of path.
* \param theSeqBases - list of Bases shape to be extruded.
* \param theLocations - list of locations on the path corresponding
* specified list of the Bases shapes. Number of locations
* \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
+ * \param theWithCorrection - 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 MakePipeWithDifferentSections (in ListOfGO theSeqBases,
- in ListOfGO theLocations,
- in GEOM_Object thePath,
- in boolean theWithContact ,
- in boolean theWithCorrection );
+ in ListOfGO theLocations,
+ 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.
+ * \brief 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 theSeqSubBases - list of corresponding sub-shapes 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
+ * \param theWithCorrection - 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 );
+ in ListOfGO theSeqSubBases,
+ in ListOfGO theLocations,
+ in GEOM_Object thePath,
+ in boolean theWithContact ,
+ in boolean theWithCorrection );
/*!
- * Create solids between given sections
+ * \brief 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);
+ 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.
+ * \brief 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.
* 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);
+ GEOM_Object MakePipeBiNormalAlongVector (in GEOM_Object theBase,
+ in GEOM_Object thePath,
+ in GEOM_Object theVec);
};
+ // # GEOM_IShapesOperations
/*!
- * GEOM_IShapesOperations: Interface for Shapes creation:
+ * \brief Interface for Shapes creation:
+ *
* Edge from two points, Wire from edges, Face from wire,
* Shell from faces, Solid from shells, Compound from shapes
*/
interface GEOM_IShapesOperations : GEOM_IOperations
{
/*!
- * Create a linear edge with specified ends.
+ * \brief Create a linear edge with specified ends.
* \param thePnt1 Point for the first end of edge.
* \param thePnt2 Point for the second end of edge.
* \return New GEOM_Object, containing the created edge.
GEOM_Object MakeEdge (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
/*!
- * Create a wire from the set of edges and wires.
+ * \brief Create an edge on another edge, corresponding to the given length on the given edge.
+ * \param theRefCurve The referenced edge.
+ * \param theLength Length on the referenced edge. It can be
+ * negative for extrapolation on base curve.
+ * \param theStartPoint Any vertex close to one of edge's
+ * ends to select start point among them.
+ * If NULL, fist vertex is used.
+ * \return New GEOM_Object, containing the created edge.
+ */
+ GEOM_Object MakeEdgeOnCurveByLength (in GEOM_Object theRefCurve,
+ in double theLength,
+ in GEOM_Object theStartPoint);
+
+ /*!
+ * \brief Create an edge from specified wire.
+ * \param theWire source Wire.
+ * \param theLinearTolerance linear tolerance value
+ * \param theAngularTolerance angular tolerance value
+ * \return New GEOM_Object, containing the created edge.
+ */
+ GEOM_Object MakeEdgeWire (in GEOM_Object theWire,
+ in double theLinearTolerance,
+ in double theAngularTolerance);
+
+ /*!
+ * \brief Create a wire from the set of edges and wires.
* \param theEdgesAndWires List of edge and/or wires.
* \param theTolerance Maximum distance between vertices, that will be merged.
* Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()).
in double theTolerance);
/*!
- * Create a face on the given wire.
+ * \brief Create a face on the given wire.
* \param theWire closed Wire or Edge to build the face on.
* \param isPlanarWanted If TRUE, only planar face will be built.
* If impossible, NULL object will be returned.
GEOM_Object MakeFace (in GEOM_Object theWire, in boolean isPlanarWanted);
/*!
- * Create a face on the given wires set.
+ * \brief Create a face on the given wires set.
* \param theWires List of closed wires or edges to build the face on.
* \param isPlanarWanted If TRUE, only planar face will be built.
* If impossible, NULL object will be returned.
GEOM_Object MakeFaceWires (in ListOfGO theWires, in boolean isPlanarWanted);
/*!
- * Create a shell from the set of faces and shells.
+ * \brief Create a shell from the set of faces and shells.
* \param theFacesAndShells List of faces and/or shells.
* \return New GEOM_Object, containing the created shell.
*/
GEOM_Object MakeShell (in ListOfGO theFacesAndShells);
/*!
- * Create a solid, bounded by the given shell.
+ * \brief Create a solid, bounded by the given shell.
* \param theShell Bounding shell.
* \return New GEOM_Object, containing the created solid.
*/
GEOM_Object MakeSolidShell (in GEOM_Object theShell);
/*!
- * Create a solid, bounded by the given shells.
+ * \brief Create a solid, bounded by the given shells.
* \param theShells Bounding shells.
* \return New GEOM_Object, containing the created solid.
*/
GEOM_Object MakeSolidShells (in ListOfGO theShells);
/*!
- * Create a compound of the given shapes.
+ * \brief Create a compound of the given shapes.
* \param theShapes List of shapes to put in compound.
* \return New GEOM_Object, containing the created compound.
*/
GEOM_Object MakeCompound (in ListOfGO theShapes);
/*!
- * Replace coincident faces in theShape by one face.
+ * \brief 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.
ListOfGO GetGlueFaces (in GEOM_Object theShape, in double theTolerance);
/*!
- * Replace coincident faces in theShape by one face
+ * \brief 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.
+ * \param doGlueAllEdges If TRUE, all coincident edges of <VAR>theShape</VAR>
+ * will be glued, otherwise only the edges,
+ * belonging to <VAR>theFaces</VAR>.
* \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);
+ in ListOfGO theFaces, in boolean doKeepNonSolids,
+ in boolean doGlueAllEdges);
+
+ /*!
+ * \brief Replace coincident edges in theShape by one edge.
+ * \param theShape Initial shape.
+ * \param theTolerance Maximum distance between edges, which can be considered as coincident.
+ * \return New GEOM_Object, containing a copy of theShape without coincident edges.
+ */
+ GEOM_Object MakeGlueEdges (in GEOM_Object theShape, in double theTolerance);
+
+ /*!
+ * Find coincident edges in theShape for possible gluing.
+ * \param theShape Initial shape.
+ * \param theTolerance Maximum distance between edges, which can be considered as coincident.
+ * \return ListOfGO
+ */
+ ListOfGO GetGlueEdges (in GEOM_Object theShape, in double theTolerance);
+
+ /*!
+ * \brief Replace coincident edges in theShape by one edge
+ * in compliance with given list of edges
+ * \param theShape Initial shape.
+ * \param theTolerance Maximum distance between edges, which can be considered as coincident.
+ * \param theEdges List of edges for gluing.
+ * \return New GEOM_Object, containing a copy of theShape without some edges.
+ */
+ GEOM_Object MakeGlueEdgesByList (in GEOM_Object theShape,
+ in double theTolerance,
+ in ListOfGO theEdges);
+
+ /*!
+ * \brief Get all sub-shapes and groups of \a theShape,
+ * that were created already by any other methods.
+ * \param theShape Any shape.
+ * \param theGroupsOnly If this parameter is TRUE, only groups will be
+ * returned, else all found sub-shapes and groups.
+ * \return List of existing sub-objects of \a theShape.
+ */
+ ListOfGO GetExistingSubObjects (in GEOM_Object theShape,
+ in boolean theGroupsOnly);
+
+ /*!
+ * \brief Deprecated method.
+ *
+ * Use MakeAllSubShapes() instead.
+ */
+ ListOfGO MakeExplode (in GEOM_Object theShape,
+ in long theShapeType,
+ in boolean isSorted);
/*!
- * Explode a shape on subshapes of a given type.
+ * \brief Explode a shape on sub-shapes of a given type.
+ *
+ * If the shape itself has the given type, it is also returned.
* \param theShape Shape to be exploded.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param isSorted If this parameter is TRUE, sub-shapes will be
* sorted by coordinates of their gravity centers.
* \return List of sub-shapes of type theShapeType, contained in theShape.
*/
- ListOfGO MakeExplode (in GEOM_Object theShape,
- in long theShapeType,
- in boolean isSorted);
+ ListOfGO MakeAllSubShapes (in GEOM_Object theShape,
+ in long theShapeType,
+ in boolean isSorted);
/*!
- * Explode a shape on subshapes of a given type.
- * Does the same, as the above method, but returns IDs of sub-shapes,
- * not GEOM_Objects. It works faster.
+ * \brief Extract all sub-shapes of the given type from
+ * the given shape, excluding the shape itself.
* \param theShape Shape to be exploded.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param isSorted If this parameter is TRUE, sub-shapes will be
* sorted by coordinates of their gravity centers.
- * \return List of IDs of sub-shapes of type theShapeType, contained in theShape.
+ * \return List of sub-shapes of type theShapeType, contained in theShape.
+ */
+ ListOfGO ExtractSubShapes (in GEOM_Object theShape,
+ in long theShapeType,
+ in boolean isSorted);
+
+ /*!
+ * \brief Deprecated method. Use GetAllSubShapesIDs() instead.
*/
ListOfLong SubShapeAllIDs (in GEOM_Object theShape,
- in long theShapeType,
- in boolean isSorted);
+ in long theShapeType,
+ in boolean isSorted);
/*!
- * Get a sub shape defined by its unique ID inside \a theMainShape
- * \note The sub shape GEOM_Objects can has ONLY ONE function.
- * Don't try to apply modification operations on them.
+ * \brief Explode a shape on sub-shapes of a given type.
+ *
+ * Does the same, as MakeAllSubShapes, but returns IDs of
+ * sub-shapes, not GEOM_Object. It works faster.
+ * \param theShape Shape to be exploded.
+ * \param theShapeType Type of sub-shapes to be retrieved.
+ * \param isSorted If this parameter is TRUE, sub-shapes will be
+ * sorted by coordinates of their gravity centers.
+ * \return List of IDs of sub-shapes of type theShapeType, contained in theShape.
+ */
+ ListOfLong GetAllSubShapesIDs (in GEOM_Object theShape,
+ in long theShapeType,
+ in boolean isSorted);
+
+ /*!
+ * \brief Get a sub-shape defined by its unique ID inside \a theMainShape
+ * \param theMainShape Main shape.
+ * \param theID Unique ID of sub-shape inside \a theMainShape.
+ * \return GEOM_Object, corresponding to found sub-shape.
+ * \note The sub-shape GEOM_Object can has ONLY ONE function.
+ * Don't try to apply modification operations (without copy) on them.
*/
GEOM_Object GetSubShape (in GEOM_Object theMainShape,
- in long theID);
+ in long theID);
+
+ /*!
+ * \brief Get a set of sub-shapes defined by their unique IDs inside \a theMainShape
+ * \param theMainShape Main shape.
+ * \param theIndices List of unique IDs of sub-shapes inside \a theMainShape.
+ * \return List of GEOM_Object, corresponding to found sub-shapes.
+ * \note The sub-shape GEOM_Object can has ONLY ONE function.
+ * Don't try to apply modification operations (without copy) on them.
+ */
+ ListOfGO MakeSubShapes (in GEOM_Object theMainShape,
+ in ListOfLong theIndices);
/*!
* Get global index of \a theSubShape in \a theMainShape.
long GetSubShapeIndex (in GEOM_Object theMainShape, in GEOM_Object theSubShape);
/*!
- * Get index of \a theSubShape in \a theMainShape, unique among sub-shapes of the same type.
+ * \brief Get index of \a theSubShape in \a theMainShape, unique among sub-shapes of the same type.
+ *
* Together with method <VAR>GetShapeTypeString()</VAR> it can be used
* to generate automatic names for sub-shapes, when publishing them in a study.
* \param theMainShape Main shape.
string GetShapeTypeString (in GEOM_Object theShape);
/*!
- * Count number of faces in the given shape.
+ * \brief Count number of faces in the given shape.
* \param theShape Shape to count faces in.
* \return Number of faces in the given shape.
*/
long NumberOfFaces (in GEOM_Object theShape);
/*!
- * Count number of edges in the given shape.
+ * \brief Count number of edges in the given shape.
* \param theShape Shape to count edges in.
* \return Number of edges in theShape.
*/
long NumberOfEdges (in GEOM_Object theShape);
/*!
- * Count number of subshapes of type \a theShapeType in the given shape.
- * \param theShape Shape to count subshapes in.
- * \param theShapeType The type of subshapes to count.
- * \return Number of subshapes of type \a theShapeType in \a theShape.
+ * \brief Count number of sub-shapes of type \a theShapeType in the given shape.
+ * \param theShape Shape to count sub-shapes in.
+ * \param theShapeType The type of sub-shapes to count.
+ * \return Number of sub-shapes of type \a theShapeType in \a theShape.
*/
long NumberOfSubShapes (in GEOM_Object theShape,
in long theShapeType);
GEOM_Object ChangeOrientation (in GEOM_Object theShape);
/*!
- * Retrieve all free faces from the given shape.
+ * \brief Retrieve all free faces from the given shape.
+ *
* Free face is a face, which is not shared between two shells of the shape.
* \param theShape Shape to find free faces in.
* \return List of IDs of all free faces, contained in theShape.
ListOfLong GetFreeFacesIDs (in GEOM_Object theShape);
/*!
- * Get all sub-shapes of theShape1 of the given type, shared with theShape2.
+ * \brief Get all sub-shapes of theShape1 of the given type, shared with theShape2.
* \param theShape1 Shape to find sub-shapes in.
* \param theShape2 Shape to find shared sub-shapes with.
* \param theShapeType Type of sub-shapes to be retrieved.
* \return List of sub-shapes of theShape1, shared with theShape2.
*/
ListOfGO GetSharedShapes (in GEOM_Object theShape1,
- in GEOM_Object theShape2,
- in long theShapeType);
+ in GEOM_Object theShape2,
+ in long theShapeType);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Get all sub-shapes, shared by all shapes in the list \a theShapes.
+ * \param theShapes Shapes to find common sub-shapes of.
+ * \param theShapeType Type of sub-shapes to be retrieved.
+ * \return List of objects, that are sub-shapes of all given shapes.
+ */
+ ListOfGO GetSharedShapesMulti (in ListOfGO theShapes,
+ in long theShapeType);
+
+ /*!
+ * \brief 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 theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theAx1 Vector (or line, or linear edge), specifying normal
* direction and location of the plane to find shapes on.
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of all found sub-shapes.
*/
ListOfGO GetShapesOnPlane (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theAx1,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theAx1,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief 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 theShape Shape to find sub-shapes of.
* \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 theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of all found sub-shapes.
*/
ListOfGO GetShapesOnPlaneWithLocation (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theAx1,
- in GEOM_Object thePnt,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theAx1,
+ in GEOM_Object thePnt,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified cylinder by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theAxis Vector (or line, or linear edge), specifying
* axis of the cylinder to find shapes on.
* \param theRadius Radius of the cylinder to find shapes on.
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of all found sub-shapes.
*/
ListOfGO GetShapesOnCylinder (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theAxis,
- in double theRadius,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theAxis,
+ in double theRadius,
+ in shape_state theState);
+
+ /*!
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * the specified cylinder by the certain way, defined through \a theState parameter.
+ * \param theShape Shape to find sub-shapes of.
+ * \param theShapeType Type of sub-shapes to be retrieved.
+ * \param theAxis Vector (or line, or linear edge), specifying
+ * axis of the cylinder to find shapes on.
+ * \param thePnt Point specifying location of the bottom of the cylinder.
+ * \param theRadius Radius of the cylinder to find shapes on.
+ * \param theState The state of the sub-shapes to find.
+ * \return List of all found sub-shapes.
+ */
+ ListOfGO GetShapesOnCylinderWithLocation (in GEOM_Object theShape,
+ in long theShapeType,
+ in GEOM_Object theAxis,
+ in GEOM_Object thePnt,
+ in double theRadius,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified sphere by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theCenter Point, specifying center of the sphere to find shapes on.
* \param theRadius Radius of the sphere to find shapes on.
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of all found sub-shapes.
*/
ListOfGO GetShapesOnSphere (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theCenter,
- in double theRadius,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theCenter,
+ in double theRadius,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified quadrangle by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theTopRigthPoint Top right quadrangle corner
* \param theBottomLeftPoint Bottom left quadrangle corner
* \param theBottomRigthPoint Bottom right quadrangle corner
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of all found sub-shapes.
*/
ListOfGO GetShapesOnQuadrangle (in GEOM_Object theShape,
in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief 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 theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theAx1 Vector (or line, or linear edge), specifying normal
* direction and location of the plane to find shapes on.
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of IDs of all found sub-shapes.
*/
ListOfLong GetShapesOnPlaneIDs (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theAx1,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theAx1,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief 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 theShape Shape to find sub-shapes of.
* \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 theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of IDs of all found sub-shapes.
*/
ListOfLong GetShapesOnPlaneWithLocationIDs (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theAx1,
- in GEOM_Object thePnt,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theAx1,
+ in GEOM_Object thePnt,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified cylinder by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theAxis Vector (or line, or linear edge), specifying
* axis of the cylinder to find shapes on.
* \param theRadius Radius of the cylinder to find shapes on.
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of IDs of all found sub-shapes.
*/
ListOfLong GetShapesOnCylinderIDs (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theAxis,
- in double theRadius,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theAxis,
+ in double theRadius,
+ in shape_state theState);
+
+ /*!
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * the specified cylinder by the certain way, defined through \a theState parameter.
+ * \param theShape Shape to find sub-shapes of.
+ * \param theShapeType Type of sub-shapes to be retrieved.
+ * \param theAxis Vector (or line, or linear edge), specifying
+ * axis of the cylinder to find shapes on.
+ * \param thePnt Point specifying location of the bottom of the cylinder.
+ * \param theRadius Radius of the cylinder to find shapes on.
+ * \param theState The state of the sub-shapes to find.
+ * \return List of IDs all found sub-shapes.
+ */
+ ListOfLong GetShapesOnCylinderWithLocationIDs (in GEOM_Object theShape,
+ in long theShapeType,
+ in GEOM_Object theAxis,
+ in GEOM_Object thePnt,
+ in double theRadius,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified sphere by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theCenter Point, specifying center of the sphere to find shapes on.
* \param theRadius Radius of the sphere to find shapes on.
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of IDs of all found sub-shapes.
*/
ListOfLong GetShapesOnSphereIDs (in GEOM_Object theShape,
- in long theShapeType,
- in GEOM_Object theCenter,
- in double theRadius,
- in shape_state theState);
+ in long theShapeType,
+ in GEOM_Object theCenter,
+ in double theRadius,
+ in shape_state theState);
/*!
- * Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
+ * \brief Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified quadrangle by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \param theShapeType Type of sub-shapes to be retrieved.
* \param theTopRigthPoint Top right quadrangle corner
* \param theBottomLeftPoint Bottom left quadrangle corner
* \param theBottomRigthPoint Bottom right quadrangle corner
- * \param theState The state of the subshapes to find.
+ * \param theState The state of the sub-shapes to find.
* \return List of IDs of all found sub-shapes.
*/
ListOfLong GetShapesOnQuadrangleIDs (in GEOM_Object theShape,
in shape_state theState);
/*!
- * \brief Find subshapes complying with given status
- * \param theBox - the box to check state of subshapes against
+ * \brief Find sub-shapes complying with given status
+ * \param theBox - the box to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
* \return List of IDs of all found sub-shapes.
*/
ListOfLong GetShapesOnBoxIDs (in GEOM_Object theBox,
- in GEOM_Object theShape,
- in long theShapeType,
- in shape_state theState);
+ in GEOM_Object theShape,
+ in long theShapeType,
+ in shape_state theState);
/*!
- * \brief Find subshapes complying with given status
- * \param theBox - the box to check state of subshapes against
+ * \brief Find sub-shapes complying with given status
+ * \param theBox - the box to check state of sub-shapes against
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape of theShape
* \param theState - required state
* \return List of all found sub-shapes.
*/
ListOfGO GetShapesOnBox (in GEOM_Object theBox,
- in GEOM_Object theShape,
- in long theShapeType,
- in shape_state theState);
+ in GEOM_Object theShape,
+ in long theShapeType,
+ in shape_state theState);
/*!
- * \brief Find subshapes complying with given status
- * \param theCheckShape - the shape to check state of subshapes against
+ * \brief Find sub-shapes complying with given status
+ * \param theCheckShape - the shape to check state of sub-shapes against. It must be a solid.
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape 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);
+ 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
+ * \brief Find sub-shapes complying with given status
+ * \param theCheckShape - the shape to check state of sub-shapes against. It must be a solid.
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape 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);
+ 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
+ * \brief Find sub-shapes complying with given status
+ * \param theCheckShape - the shape to check state of sub-shapes against. It must be a solid.
* \param theShape - the shape to explore
- * \param theShapeType - type of subshape of theShape
+ * \param theShapeType - type of sub-shape 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);
+ in GEOM_Object theShape,
+ in short theShapeType,
+ in shape_state theState);
/*!
- * Get sub-shape(s) of \a theShapeWhere, which are
+ * \brief 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.
* \return Group of all found sub-shapes or a single found sub-shape.
*/
GEOM_Object GetInPlace (in GEOM_Object theShapeWhere,
- in GEOM_Object theShapeWhat);
+ in GEOM_Object theShapeWhat);
/*!
- * Get sub-shape(s) of \a theShapeWhere, which are
+ * Old implementation of GetInPlace functionality, based on shape properties.
+ */
+ GEOM_Object GetInPlaceOld (in GEOM_Object theShapeWhere,
+ in GEOM_Object theShapeWhat);
+
+ /*!
+ * \brief 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,
* \return Group of all found sub-shapes or a single found sub-shape.
*/
GEOM_Object GetInPlaceByHistory (in GEOM_Object theShapeWhere,
- in GEOM_Object theShapeWhat);
+ in GEOM_Object theShapeWhat);
/*!
- * Get sub-shape of theShapeWhere, which are
+ * \brief Get sub-shape of theShapeWhere, which are
* coincident with \a theShapeWhat that can either SOLID, FACE, EDGE or VERTEX.
* \param theShapeWhere Shape to find sub-shapes of.
* \param theShapeWhat Shape, specifying what to find.
* \return found sub-shape.
*/
GEOM_Object GetSame (in GEOM_Object theShapeWhere,
- in GEOM_Object theShapeWhat);
+ in GEOM_Object theShapeWhat);
+
+ /*!
+ * \brief Get sub-shape Ids of theShapeWhere, which are
+ * coincident with \a theShapeWhat that can either SOLID, FACE, EDGE or VERTEX.
+ * \param theShapeWhere Shape to find sub-shapes of.
+ * \param theShapeWhat Shape, specifying what to find.
+ * \return found sub-shape Ids.
+ */
+ ListOfLong GetSameIDs (in GEOM_Object theShapeWhere,
+ in GEOM_Object theShapeWhat);
+
};
+ // # GEOM_IBlocksOperations:
/*!
- * GEOM_IBlocksOperations: Interface for Blocks construction
+ * \brief Interface for Blocks construction
* Face from points or edges, Block from faces,
* Blocks multi-translation and multi-rotation
*/
interface GEOM_IBlocksOperations : GEOM_IOperations
{
- /*!
- * Creation of blocks
- */
+
+ // # Creation of blocks
/*!
- * Create a quadrangle face from four edges. Order of Edges is not
+ * \brief Create a quadrangle face from four edges. Order of Edges is not
* important. It is not necessary that edges share the same vertex.
* \param theEdge1,theEdge2,theEdge3,theEdge4 Edges for the face bound.
* \return New GEOM_Object, containing the created face.
*/
GEOM_Object MakeQuad (in GEOM_Object theEdge1,
- in GEOM_Object theEdge2,
- in GEOM_Object theEdge3,
- in GEOM_Object theEdge4);
+ in GEOM_Object theEdge2,
+ in GEOM_Object theEdge3,
+ in GEOM_Object theEdge4);
/*!
- * Create a quadrangle face on two edges.
+ * \brief Create a quadrangle face on two edges.
+ *
* The missing edges will be built by creating the shortest ones.
* \param theEdge1,theEdge2 Two opposite edges for the face.
* \return New GEOM_Object, containing the created face.
*/
GEOM_Object MakeQuad2Edges (in GEOM_Object theEdge1,
- in GEOM_Object theEdge2);
+ in GEOM_Object theEdge2);
/*!
- * Create a quadrangle face with specified corners.
+ * \brief Create a quadrangle face with specified corners.
+ *
* The missing edges will be built by creating the shortest ones.
* \param thePnt1,thePnt2,thePnt3,thePnt4 Corner vertices for the face.
* \return New GEOM_Object, containing the created face.
*/
GEOM_Object MakeQuad4Vertices (in GEOM_Object thePnt1,
- in GEOM_Object thePnt2,
- in GEOM_Object thePnt3,
- in GEOM_Object thePnt4);
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3,
+ in GEOM_Object thePnt4);
/*!
- * Create a hexahedral solid, bounded by the six given faces. Order of
- * faces is not important. It is not necessary that Faces share the same edge.
- * \param theFace1-theFace6 Faces for the hexahedral solid.
+ * \brief Create a hexahedral solid, bounded by the six given faces. Order of
+ * faces is not important.
+ *
+ * It is not necessary that Faces share the same edge.
+ * \param theFace1,theFace2,theFace3,theFace4,theFace5,theFace6 Faces for the hexahedral solid.
* \return New GEOM_Object, containing the created solid.
*/
GEOM_Object MakeHexa (in GEOM_Object theFace1,
- in GEOM_Object theFace2,
- in GEOM_Object theFace3,
- in GEOM_Object theFace4,
- in GEOM_Object theFace5,
- in GEOM_Object theFace6);
+ in GEOM_Object theFace2,
+ in GEOM_Object theFace3,
+ in GEOM_Object theFace4,
+ in GEOM_Object theFace5,
+ in GEOM_Object theFace6);
/*!
- * Create a hexahedral solid between two given faces.
+ * \brief Create a hexahedral solid between two given faces.
+ *
* The missing faces will be built by creating the smallest ones.
* \param theFace1,theFace2 Two opposite faces for the hexahedral solid.
* \return New GEOM_Object, containing the created solid.
*/
GEOM_Object MakeHexa2Faces (in GEOM_Object theFace1,
- in GEOM_Object theFace2);
+ in GEOM_Object theFace2);
- /*!
- * Extract elements of blocks and blocks compounds
- */
+
+ // # Extract elements of blocks and blocks compounds
+
/*!
- * Get a vertex, found in the given shape by its coordinates.
+ * \brief Get a vertex, found in the given shape by its coordinates.
* \param theShape Block or a compound of blocks.
* \param theX,theY,theZ Coordinates of the sought vertex.
* \param theEpsilon Maximum allowed distance between the resulting
* \return New GEOM_Object, containing the found vertex.
*/
GEOM_Object GetPoint (in GEOM_Object theShape,
- in double theX,
- in double theY,
- in double theZ,
- in double theEpsilon);
+ in double theX,
+ in double theY,
+ in double theZ,
+ in double theEpsilon);
/*!
- * Get an edge, found in the given shape by two given vertices.
+ * \brief Find a vertex of the given shape, which has minimal distance to the given point.
+ * \param theShape Any shape.
+ * \param thePoint Point, close to the desired vertex.
+ * \return New GEOM_Object, containing the found vertex.
+ */
+ GEOM_Object GetVertexNearPoint (in GEOM_Object theShape,
+ in GEOM_Object thePoint);
+
+ /*!
+ * \brief Get an edge, found in the given shape by two given vertices.
* \param theShape Block or a compound of blocks.
* \param thePoint1,thePoint2 Points, close to the ends of the desired edge.
* \return New GEOM_Object, containing the found edge.
*/
GEOM_Object GetEdge (in GEOM_Object theShape,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2);
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2);
/*!
- * Find an edge of the given shape, which has minimal distance to the given point.
+ * \brief Find an edge of the given shape, which has minimal distance to the given point.
* \param theShape Block or a compound of blocks.
* \param thePoint Point, close to the desired edge.
* \return New GEOM_Object, containing the found edge.
*/
GEOM_Object GetEdgeNearPoint (in GEOM_Object theShape,
- in GEOM_Object thePoint);
+ in GEOM_Object thePoint);
/*!
- * Returns a face, found in the given shape by four given corner vertices.
+ * \brief Returns a face, found in the given shape by four given corner vertices.
* \param theShape Block or a compound of blocks.
- * \param thePoint1-thePoint4 Points, close to the corners of the desired face.
+ * \param thePoint1,thePoint2,thePoint3,thePoint4 Points, close to the corners of the desired face.
* \return New GEOM_Object, containing the found face.
*/
GEOM_Object GetFaceByPoints (in GEOM_Object theShape,
- in GEOM_Object thePoint1,
- in GEOM_Object thePoint2,
- in GEOM_Object thePoint3,
- in GEOM_Object thePoint4);
+ in GEOM_Object thePoint1,
+ in GEOM_Object thePoint2,
+ in GEOM_Object thePoint3,
+ in GEOM_Object thePoint4);
/*!
- * Get a face of block, found in the given shape by two given edges.
+ * \brief Get a face of block, found in the given shape by two given edges.
* \param theShape Block or a compound of blocks.
* \param theEdge1,theEdge2 Edges, close to the edges of the desired face.
* \return New GEOM_Object, containing the found face.
*/
GEOM_Object GetFaceByEdges (in GEOM_Object theShape,
- in GEOM_Object theEdge1,
- in GEOM_Object theEdge2);
+ in GEOM_Object theEdge1,
+ in GEOM_Object theEdge2);
/*!
- * Find a face, opposite to the given one in the given block.
+ * \brief Find a face, opposite to the given one in the given block.
* \param theBlock Must be a hexahedral solid.
* \param theFace Face of \a theBlock, opposite to the desired face.
* \return New GEOM_Object, containing the found face.
*/
GEOM_Object GetOppositeFace (in GEOM_Object theBlock,
- in GEOM_Object theFace);
+ in GEOM_Object theFace);
/*!
- * Find a face of the given shape, which has minimal distance to the given point.
+ * \brief Find a face of the given shape, which has minimal distance to the given point.
* \param theShape Block or a compound of blocks.
* \param thePoint Point, close to the desired face.
* \return New GEOM_Object, containing the found face.
*/
GEOM_Object GetFaceNearPoint (in GEOM_Object theShape,
- in GEOM_Object thePoint);
+ in GEOM_Object thePoint);
/*!
- * Find a face of block, whose outside normale has minimal angle with the given vector.
- * \param theShape Block or a compound of blocks.
+ * \brief Find a face of block, whose outside normale has minimal angle with the given vector.
+ * \param theBlock Block or a compound of blocks.
* \param theVector Vector, close to the normale of the desired face.
* \return New GEOM_Object, containing the found face.
*/
GEOM_Object GetFaceByNormale (in GEOM_Object theBlock,
- in GEOM_Object theVector);
+ in GEOM_Object theVector);
/*!
- * Extract blocks from blocks compounds
+ * \brief Find all sub-shapes of type \a theShapeType of the given shape,
+ * which have minimal distance to the given point.
+ * \param theShape Any shape.
+ * \param thePoint Point, close to the desired shape.
+ * \param theShapeType Defines what kind of sub-shapes is searched.
+ * \param theTolerance The tolerance for distances comparison. All shapes
+ * with distances to the given point in interval
+ * [minimal_distance, minimal_distance + theTolerance] will be gathered.
+ * \return New GEOM_Object, containing a group of all found shapes.
*/
+ GEOM_Object GetShapesNearPoint (in GEOM_Object theShape,
+ in GEOM_Object thePoint,
+ in long theShapeType,
+ in double theTolerance);
+
+ // # Extract blocks from blocks compounds
+
/*!
- * Check, if the compound contains only specified blocks.
+ * \brief Check, if the compound contains only specified blocks.
* \param theCompound The compound to check.
* \param theMinNbFaces If solid has lower number of faces, it is not a block.
* \param theMaxNbFaces If solid has higher number of faces, it is not a block.
* \note If theMaxNbFaces = 0, the maximum number of faces is not restricted.
+ * \param theNbBlocks Number of specified blocks in theCompound.
* \return TRUE, if the given compound contains only blocks.
- * \return theNbBlocks Number of specified blocks in theCompound.
*/
boolean IsCompoundOfBlocks (in GEOM_Object theCompound,
- in long theMinNbFaces,
- in long theMaxNbFaces,
- out long theNbBlocks);
+ in long theMinNbFaces,
+ in long theMaxNbFaces,
+ out long theNbBlocks);
/*!
- * Enumeration of Blocks Compound defects.
+ * \brief Enumeration of Blocks Compound defects.
*/
enum BCErrorType
{
};
/*!
- * Description of Blocks Compound defect: type and incriminated sub-shapes.
+ * \brief Description of Blocks Compound defect: type and incriminated sub-shapes.
*/
struct BCError
{
};
/*!
- * Sequence of all Blocks Compound defects.
+ * \brief Sequence of all Blocks Compound defects.
*/
typedef sequence<BCError> BCErrors;
/*!
- * Check, if the compound of blocks is given.
+ * \brief Check, if the compound of blocks is given.
+ *
* To be considered as a compound of blocks, the
* given shape must satisfy the following conditions:
* - Each element of the compound should be a Block (6 faces and 12 edges).
* - The glue between two quadrangle faces should be applied.
* \note Single block is also accepted as a valid compound of blocks.
* \param theCompound The compound to check.
+ * \param theErrors Structure, containing discovered errors and incriminated sub-shapes.
* \return TRUE, if the given shape is a compound of blocks.
- * \return theErrors Structure, containing discovered errors and incriminated sub-shapes.
*/
boolean CheckCompoundOfBlocks (in GEOM_Object theCompound,
- out BCErrors theErrors);
+ out BCErrors theErrors);
/*!
- * Convert sequence of Blocks Compound errors, returned by
+ * \brief Convert sequence of Blocks Compound errors, returned by
* <VAR>CheckCompoundOfBlocks()</VAR>, into string.
* \param theCompound The bad compound.
* \param theErrors The sequence of \a theCompound errors.
* \return String, describing all the errors in form, suitable for printing.
*/
string PrintBCErrors (in GEOM_Object theCompound,
- in BCErrors theErrors);
+ in BCErrors theErrors);
/*!
- * Remove all seam and degenerated edges from \a theShape.
+ * \brief Remove all seam and degenerated edges from \a theShape.
+ *
* Unite faces and edges, sharing one surface.
* \param theShape The compound or single solid to remove irregular edges from.
* \param theOptimumNbFaces If more than zero, unite faces only for those solids,
in long theOptimumNbFaces);
/*!
- * Check, if the given shape is a blocks compound.
+ * \brief Check, if the given shape is a blocks compound.
+ *
* Fix all detected errors.
* \note Single block can be also fixed by this method.
* \param theCompound The compound to check and improve.
GEOM_Object CheckAndImprove (in GEOM_Object theCompound);
/*!
- * Get all the blocks, contained in the given compound.
+ * \brief Get all the blocks, contained in the given compound.
+ *
* \param theCompound The compound to explode.
* \param theMinNbFaces If solid has lower number of faces, it is not a block.
* \param theMaxNbFaces If solid has higher number of faces, it is not a block.
* \note If theMaxNbFaces = 0, the maximum number of faces is not restricted.
- * \return List of GEOM_Objects, containing the retrieved blocks.
+ * \return List of GEOM_Object, containing the retrieved blocks.
*/
ListOfGO ExplodeCompoundOfBlocks (in GEOM_Object theCompound,
- in long theMinNbFaces,
- in long theMaxNbFaces);
+ in long theMinNbFaces,
+ in long theMaxNbFaces);
/*!
- * Find block, containing the given point inside its volume or on boundary.
+ * \brief Find block, containing the given point inside its volume or on boundary.
* \param theCompound Compound, to find block in.
* \param thePoint Point, close to the desired block. If the point lays on
* boundary between some blocks, we return block with nearest center.
* \return New GEOM_Object, containing the found block.
*/
GEOM_Object GetBlockNearPoint (in GEOM_Object theCompound,
- in GEOM_Object thePoint);
+ in GEOM_Object thePoint);
/*!
- * Find block, containing all the elements, passed as the parts, or maximum quantity of them.
+ * \brief Find block, containing all the elements, passed as the parts, or maximum quantity of them.
* \param theCompound Compound, to find block in.
* \param theParts List of faces and/or edges and/or vertices to be parts of the found block.
* \return New GEOM_Object, containing the found block.
*/
GEOM_Object GetBlockByParts (in GEOM_Object theCompound,
- in ListOfGO theParts);
+ in ListOfGO theParts);
/*!
- * Return all blocks, containing all the elements, passed as the parts.
+ * \brief Return all blocks, containing all the elements, passed as the parts.
* \param theCompound Compound, to find blocks in.
* \param theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
- * \return List of GEOM_Objects, containing the found blocks.
+ * \return List of GEOM_Object, containing the found blocks.
*/
ListOfGO GetBlocksByParts (in GEOM_Object theCompound,
- in ListOfGO theParts);
+ in ListOfGO theParts);
- /*!
- * Operations on blocks with gluing of result
- */
+ // # Operations on blocks with gluing of result
/*!
- * Multi-transformate block and glue the result.
+ * \brief Multi-transformate block and glue the result.
+ *
* Transformation is defined so, as to superpose theDirFace1 with theDirFace2.
* \param theBlock Hexahedral solid to be multi-transformed.
* \param theDirFace1 First direction face global index.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeMultiTransformation1D (in GEOM_Object theBlock,
- in long theDirFace1,
- in long theDirFace2,
- in long theNbTimes);
+ in long theDirFace1,
+ in long theDirFace2,
+ in long theNbTimes);
/*!
- * Multi-transformate block and glue the result.
+ * \brief Multi-transformate block and glue the result.
* \param theBlock Hexahedral solid to be multi-transformed.
* \param theDirFace1U,theDirFace2U Direction faces for the first transformation.
* \param theDirFace1V,theDirFace2V Direction faces for the second transformation.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeMultiTransformation2D (in GEOM_Object theBlock,
- in long theDirFace1U,
- in long theDirFace2U,
- in long theNbTimesU,
- in long theDirFace1V,
- in long theDirFace2V,
- in long theNbTimesV);
+ in long theDirFace1U,
+ in long theDirFace2U,
+ in long theNbTimesU,
+ in long theDirFace1V,
+ in long theDirFace2V,
+ in long theNbTimesV);
- /*!
- * Special operation - propagation
- */
+ // # Special operation - propagation
+
/*!
- * Build all possible propagation groups.
+ * \brief Build all possible propagation groups.
+ *
* Propagation group is a set of all edges, opposite to one (main)
* edge of this group directly or through other opposite edges.
* Notion of Opposite Edge make sence only on quadrangle face.
* \param theShape Shape to build propagation groups on.
- * \return List of GEOM_Objects, each of them is a propagation group.
+ * \return List of GEOM_Object, each of them is a propagation group.
*/
ListOfGO Propagate (in GEOM_Object theShape);
};
+ // # GEOM_IBooleanOperations
/*!
- * GEOM_IBooleanOperations: Interface for boolean operations (Cut, Fuse, Common)
+ * \brief Interface for boolean operations (Cut, Fuse, Common)
*/
interface GEOM_IBooleanOperations : GEOM_IOperations
{
/*!
- * Perform one of boolean operations on two given shapes.
+ * \brief Perform one of boolean operations on two given shapes.
* \param theShape1 First argument for boolean operation.
* \param theShape2 Second argument for boolean operation.
* \param theOperation Indicates the operation to be done:
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeBoolean (in GEOM_Object theShape1,
- in GEOM_Object theShape2,
- in long theOperation);
+ in GEOM_Object theShape2,
+ in long theOperation);
/*!
- * Perform partition operation.
+ * \brief Perform partition operation.
+ *
* \param theShapes Shapes to be intersected.
* \param theTools Shapes to intersect theShapes.
* \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)
+ * \param theKeepNonlimitShapes: if this parameter == 0, then only shapes of
+ * target type (equal to Limit) are kept in the result,
+ * else standalone shapes of lower dimension
+ * are kept also (if they exist).
*
* After implementation new version of PartitionAlgo (October 2006)
* other parameters are ignored by current functionality. They are kept
* \return New GEOM_Object, containing the result shapes.
*/
GEOM_Object MakePartition (in ListOfGO theShapes,
- in ListOfGO theTools,
- in ListOfGO theKeepInside,
- in ListOfGO theRemoveInside,
- in short theLimit,
- in boolean theRemoveWebs,
- in ListOfLong theMaterials,
- in short theKeepNonlimitShapes);
+ in ListOfGO theTools,
+ in ListOfGO theKeepInside,
+ in ListOfGO theRemoveInside,
+ in short theLimit,
+ in boolean theRemoveWebs,
+ in ListOfLong theMaterials,
+ in short theKeepNonlimitShapes);
/*!
- * Perform partition operation.
+ * \brief Perform partition operation.
+ *
* This method may be usefull if it is needed to make a partition for
* a compound containing nonintersected shapes. Performance will be better
* since intersection between shapes from compound is not performed.
* \return New GEOM_Object, containing the result shapes.
*/
GEOM_Object MakePartitionNonSelfIntersectedShape (in ListOfGO theShapes,
- in ListOfGO theTools,
- in ListOfGO theKeepInside,
- in ListOfGO theRemoveInside,
- in short theLimit,
- in boolean theRemoveWebs,
- in ListOfLong theMaterials,
- in short theKeepNonlimitShapes);
+ in ListOfGO theTools,
+ in ListOfGO theKeepInside,
+ in ListOfGO theRemoveInside,
+ in short theLimit,
+ in boolean theRemoveWebs,
+ in ListOfLong theMaterials,
+ in short theKeepNonlimitShapes);
/*!
- * Perform partition of the Shape with the Plane
+ * \brief Perform partition of the Shape with the Plane
* \param theShape Shape to be intersected.
* \param thePlane Tool shape, to intersect theShape.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeHalfPartition (in GEOM_Object theShape,
- in GEOM_Object thePlane);
+ in GEOM_Object thePlane);
};
+ // # GEOM_ICurvesOperations:
/*!
- * GEOM_ICurvesOperations: Interface for curves creation.
+ * \brief Interface for curves creation.
+ *
* Polyline, Circle, Spline (Bezier and Interpolation)
*/
interface GEOM_ICurvesOperations : GEOM_IOperations
{
/*!
- * Create a circle with given center, normal vector and radius.
+ * \brief Create a circle with given center, normal vector and radius.
* \param thePnt Circle center.
* \param theVec Vector, normal to the plane of the circle.
* \param theR Circle radius.
* \return New GEOM_Object, containing the created circle.
*/
GEOM_Object MakeCirclePntVecR (in GEOM_Object thePnt,
- in GEOM_Object theVec,
- in double theR);
+ in GEOM_Object theVec,
+ in double theR);
/*!
- * Create a circle, passing through three given points
+ * \brief Create a circle, passing through three given points
* \param thePnt1,thePnt2,thePnt3 Points, defining the circle.
* \return New GEOM_Object, containing the created circle.
*/
GEOM_Object MakeCircleThreePnt (in GEOM_Object thePnt1,
- in GEOM_Object thePnt2,
- in GEOM_Object thePnt3);
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3);
/*!
- * Create a circle with given center, with a radius equals the distance from center to Point1
+ * \brief 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);
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3);
/*!
- * Create an ellipse with given center, normal vector and radiuses.
+ * \brief Create an ellipse with given center, normal vector and radiuses.
* \param thePnt Ellipse center.
* \param theVec Vector, normal to the plane of the ellipse.
* \param theRMajor Major ellipse radius.
* \return New GEOM_Object, containing the created ellipse.
*/
GEOM_Object MakeEllipse (in GEOM_Object thePnt,
- in GEOM_Object theVec,
- in double theRMajor,
- in double theRMinor);
+ in GEOM_Object theVec,
+ in double theRMajor,
+ in double theRMinor);
/*!
- * Create an ellipse with given center, normal vector, main axis vector and radiuses.
+ * \brief Create an ellipse with given center, normal vector, main axis vector and radiuses.
* \param thePnt Ellipse center.
* \param theVec Vector, normal to the plane of the ellipse.
* \param theRMajor Major ellipse radius.
* \return New GEOM_Object, containing the created ellipse.
*/
GEOM_Object MakeEllipseVec (in GEOM_Object thePnt,
- in GEOM_Object theVec,
- in double theRMajor,
- in double theRMinor,
- in GEOM_Object theVecMaj);
+ in GEOM_Object theVec,
+ in double theRMajor,
+ in double theRMinor,
+ in GEOM_Object theVecMaj);
/*!
- * Create an arc of circle, passing through three given points.
+ * \brief Create an arc of circle, passing through three given points.
* \param thePnt1 Start point of the arc.
* \param thePnt2 Middle point of the arc.
* \param thePnt3 End point of the arc.
* \return New GEOM_Object, containing the created arc.
*/
GEOM_Object MakeArc (in GEOM_Object thePnt1,
- in GEOM_Object thePnt2,
- in GEOM_Object thePnt3);
+ in GEOM_Object thePnt2,
+ in GEOM_Object thePnt3);
/*!
- * Create an arc of circle of center C from one point to another
+ * \brief 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.
in GEOM_Object thePnt1,
in GEOM_Object thePnt2,
in boolean theSense);
-
+
/*!
- * Create an arc of ellipse of center C and two points P1 P2.
+ * \brief Create an arc of ellipse of center C and two points P1 P2.
* \param theCenter Center point of the arc.
* \param thePnt1 Major radius is distance from center to Pnt1.
- * \param thePnt2 define a plane and Minor radius as a shortest distance from Pnt2 to vector Center->Pnt1.
+ * \param thePnt2 define a plane and Minor radius as a shortest
+ * distance from Pnt2 to vector Center->Pnt1.
* \return New GEOM_Object, containing the created arc.
*/
GEOM_Object MakeArcOfEllipse (in GEOM_Object theCenter,
- in GEOM_Object thePnt1,
- in GEOM_Object thePnt2);
+ in GEOM_Object thePnt1,
+ in GEOM_Object thePnt2);
/*!
- * Create a polyline on the set of points.
+ * \brief Create a polyline on the set of points.
* \param thePoints Sequence of points for the polyline.
+ * \param theIsClosed If TRUE, build a closed wire.
* \return New GEOM_Object, containing the created polyline.
*/
- GEOM_Object MakePolyline (in ListOfGO thePoints);
+ GEOM_Object MakePolyline (in ListOfGO thePoints,
+ in boolean theIsClosed);
/*!
- * Create bezier curve on the set of points.
+ * \brief Create bezier curve on the set of points.
* \param thePoints Sequence of points for the bezier curve.
+ * \param theIsClosed If TRUE, build a closed curve.
* \return New GEOM_Object, containing the created bezier curve.
*/
- GEOM_Object MakeSplineBezier (in ListOfGO thePoints);
+ GEOM_Object MakeSplineBezier (in ListOfGO thePoints,
+ in boolean theIsClosed);
/*!
- * Create B-Spline curve on the set of points.
+ * \brief Create B-Spline curve on the set of points.
* \param thePoints Sequence of points for the B-Spline curve.
* \param theIsClosed If TRUE, build a closed curve.
+ * \param theDoReordering If TRUE, the algo does not follow the order of
+ * \a thePoints but searches for the closest vertex.
* \return New GEOM_Object, containing the created B-Spline curve.
*/
GEOM_Object MakeSplineInterpolation (in ListOfGO thePoints,
- in boolean theIsClosed);
+ in boolean theIsClosed,
+ in boolean theDoReordering);
+
+ /*!
+ * \brief Creates a curve using the parametric definition of the basic points.
+ * \param thexExpr parametric equation of the coordinates X.
+ * \param theyExpr parametric equation of the coordinates Y.
+ * \param thezExpr parametric equation of the coordinates Z.
+ * \param theParamMin the minimal value of the parameter.
+ * \param theParamMax the maximum value of the parameter.
+ * \param theParamStep the step of the parameter.
+ * \param theCurveType the type of the curve.
+ * \return New GEOM_Object, containing the created curve.
+ */
+ GEOM_Object MakeCurveParametric(in string thexExpr,
+ in string theyExpr,
+ in string thezExpr,
+ in double theParamMin,
+ in double theParamMax,
+ in double theParamStep,
+ in curve_type theCurveType);
- /*!
- * Create a sketcher (wire or face), following the textual description,
- * passed through \a theCommand argument. \n
+ /*!
+ * \brief Creates a curve using the parametric definition of the basic points.
+ * \param thexExpr parametric equation of the coordinates X.
+ * \param theyExpr parametric equation of the coordinates Y.
+ * \param thezExpr parametric equation of the coordinates Z.
+ * \param theParamMin the minimal value of the parameter.
+ * \param theParamMax the maximum value of the parameter.
+ * \param theParamNbStep the number of steps of the parameter discretization.
+ * \param theCurveType the type of the curve.
+ * \return New GEOM_Object, containing the created curve.
+ */
+ GEOM_Object MakeCurveParametricNew(in string thexExpr,
+ in string theyExpr,
+ in string thezExpr,
+ in double theParamMin,
+ in double theParamMax,
+ in long theParamNbStep,
+ in curve_type theCurveType);
+
+ /*!
+ * \brief Create a sketcher (wire or face), following the textual description,
+ * passed through \a theCommand argument.
+ *
* Edges of the resulting wire or face will be arcs of circles and/or linear segments. \n
* Format of the description string have to be the following:
*
* \return New GEOM_Object, containing the created wire.
*/
GEOM_Object MakeSketcher (in string theCommand, in ListOfDouble theWorkingPlane);
-
+
/*!
- * Create a 3D sketcher, following the numerical description,
- * passed through points created by \a theCoordinates argument. \n
+ * \brief Create a 3D sketcher, following the numerical description,
+ * passed through points created by \a theCoordinates argument.
+ *
* Format of the description string have to be the following:
*
* "Make3DSketcher[x1, y1, z1, x2, y2, z2, ..., xN, yN, zN]"
*/
-
+
GEOM_Object Make3DSketcher (in ListOfDouble theCoordinates);
/*!
- * Create a sketcher (wire or face), following the textual description,
- * passed through \a theCommand argument. \n
+ * \brief Create a sketcher (wire or face), following the textual description,
+ * passed through \a theCommand argument.
+ *
* For format of the description string see the previous method.\n
* \param theCommand String, defining the sketcher in local
* coordinates of the working plane.
GEOM_Object MakeSketcherOnPlane (in string theCommand, in GEOM_Object theWorkingPlane);
};
+ // # GEOM_ILocalOperations:
/*!
- * GEOM_ILocalOperations: Interface for fillet and chamfer creation.
+ * \brief Interface for fillet and chamfer creation.
*/
interface GEOM_ILocalOperations : GEOM_IOperations
{
/*!
- * Perform a fillet on all edges of the given shape.
+ * \brief Perform a fillet on all edges of the given shape.
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeFilletAll (in GEOM_Object theShape,
- in double theR);
+ in double theR);
/*!
- * Perform a fillet on the specified edges of the given shape
+ * \brief Perform a fillet on the specified edges of the given shape
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \param theEdges Global indices of edges to perform fillet on.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeFilletEdges (in GEOM_Object theShape,
- in double theR,
- in ListOfLong theEdges);
+ in double theR,
+ in ListOfLong theEdges);
GEOM_Object MakeFilletEdgesR1R2 (in GEOM_Object theShape,
- in double theR1,
- in double theR2,
- in ListOfLong theEdges);
+ in double theR1,
+ in double theR2,
+ in ListOfLong theEdges);
/*!
- * Perform a fillet on all edges of the specified faces of the given shape.
+ * \brief Perform a fillet on all edges of the specified faces of the given shape.
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \param theFaces Global indices of faces to perform fillet on.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeFilletFaces (in GEOM_Object theShape,
- in double theR,
- in ListOfLong theFaces);
-
+ in double theR,
+ in ListOfLong theFaces);
+
GEOM_Object MakeFilletFacesR1R2 (in GEOM_Object theShape,
- in double theR1,
- in double theR2,
- in ListOfLong theFaces);
-
+ in double theR1,
+ in double theR2,
+ in ListOfLong theFaces);
+
/*!
- * Perform a fillet on face of the specified vertexes of the given shape.
+ * \brief Perform a fillet on a face or a shell at the specified vertexes.
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \param theVertexes Global indices of vertexes to perform fillet on.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeFillet2D (in GEOM_Object theShape,
- in double theR,
- in ListOfLong theVertexes);
+ in double theR,
+ in ListOfLong theVertexes);
/*!
- * Perform a fillet on edges of the specified vertexes of the given wire.
+ * \brief Perform a fillet on edges of the specified vertexes of the given wire.
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \param theVertexes Global indices of vertexes to perform fillet on.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeFillet1D (in GEOM_Object theShape,
- in double theR,
- in ListOfLong theVertexes);
+ in double theR,
+ in ListOfLong theVertexes);
/*!
- * Perform a symmetric chamfer on all edges of the given shape.
+ * \brief Perform a symmetric chamfer on all edges of the given shape.
* \param theShape Shape, to perform chamfer on.
* \param theD Chamfer size along each face.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeChamferAll (in GEOM_Object theShape,
- in double theD);
+ in double theD);
/*!
- * Perform a chamfer on edges, common to the specified faces.
+ * \brief Perform a chamfer on edges, common to the specified faces.
* with distance D1 on the Face1
* \param theShape Shape, to perform chamfer on.
* \param theD1 Chamfer size along \a theFace1.
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeChamferEdge (in GEOM_Object theShape,
- in double theD1, in double theD2,
- in long theFace1, in long theFace2);
+ in double theD1, in double theD2,
+ in long theFace1, in long theFace2);
/*!
- * The Same but with params theD = Chamfer Lenght
+ * \brief 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);
+ in double theD, in double theAngle,
+ in long theFace1, in long theFace2);
/*!
- * Perform a chamfer on all edges of the specified faces.
+ * \brief Perform a chamfer on all edges of the specified faces.
* with distance D1 on the first specified face (if several for one edge)
* \param theShape Shape, to perform chamfer on.
* \param theD1 Chamfer size along face from \a theFaces. If both faces,
* \return New GEOM_Object, containing the result shape.
*/
GEOM_Object MakeChamferFaces (in GEOM_Object theShape,
- in double theD1, in double theD2,
- in ListOfLong theFaces);
+ 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);
+ in double theD, in double theAngle,
+ in ListOfLong theFaces);
/*!
- * Perform a chamfer on edges,
+ * \brief 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 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);
+ 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);
+ in double theD, in double theAngle,
+ in ListOfLong theEdges);
/*!
- * Perform an Archimde operation on the given shape with given parameters.
+ * \brief Perform an Archimde operation on the given shape with given parameters.
* The object presenting the resulting face is returned
* \param theShape Shape to be put in water.
* \param theWeight Weight og the shape.
* by a plane, corresponding to water level.
*/
GEOM_Object MakeArchimede (in GEOM_Object theShape,
- in double theWeight,
- in double theWaterDensity,
- in double theMeshDeflection);
+ in double theWeight,
+ in double theWaterDensity,
+ in double theMeshDeflection);
/*!
- * Duplicates <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
+ * \brief Duplicates <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
+ *
* Present here only for compatibility.
*/
long GetSubShapeIndex (in GEOM_Object theShape, in GEOM_Object theSubShape);
};
+ // # GEOM_IHealingOperations:
/*!
- * GEOM_IHealingOperations: Interface for shape healing operations.
+ * \brief Interface for shape healing operations
+ *
* Shape Processing, SuppressFaces, etc.
*/
interface GEOM_IHealingOperations : GEOM_IOperations
{
/*!
- * Apply a sequence of Shape Healing operators to the given object.
+ * \brief Apply a sequence of Shape Healing operators to the given object.
* \param theShapes Shape to be processed.
* \param theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
* \param theParameters List of names of parameters
* \return New GEOM_Object, containing processed shape.
*/
GEOM_Object ProcessShape (in GEOM_Object theShapes,
- in string_array theOperators,
- in string_array theParameters,
- in string_array theValues);
+ in string_array theOperators,
+ in string_array theParameters,
+ in string_array theValues);
/*!
- * Get default sequence of operators, their parameters and parameters' values
- * of Shape Process operation. In the current implementation the defaults are
+ * \brief Get default sequence of operators, their parameters and parameters' values
+ * of Shape Process operation.
+ *
+ * In the current implementation the defaults are
* read from the file pointed by CSF_ShHealingDefaults environmental variable.
* \param theOperators Output. Default list of names of operators.
* \param theParameters Output. Default list of names of parameters.
* as parameters are listed in \a theParameters list.
*/
void GetShapeProcessParameters (out string_array theOperators,
- out string_array theParameters,
- out string_array theValues);
+ out string_array theParameters,
+ out string_array theValues);
/*!
- * Get parameters and parameters' values for the given Shape Process operation.
+ * \brief Get parameters and parameters' values for the given Shape Process operation.
+ *
* In the current implementation the defaults are
* read from the file pointed by CSF_ShHealingDefaults environmental variable.
* \param theOperator Input. The operator's name.
* as parameters are listed in \a theParameters list.
*/
void GetOperatorParameters (in string theOperator,
- out string_array theParameters,
- out string_array theValues);
+ out string_array theParameters,
+ out string_array theValues);
/*!
- * Remove faces from the given object (shape).
+ * \brief Remove faces from the given object (shape).
* \param theObject Shape to be processed.
* \param theFaces Indices of faces to be removed, if EMPTY then the method
* removes ALL faces of the given object.
GEOM_Object SuppressFaces (in GEOM_Object theObject, in short_array theFaces);
/*!
- * Close an open wire.
+ * \brief Close an open wire.
* \param theObject Shape to be processed.
* \param theWires Indexes of edge(s) and wire(s) to be closed within <VAR>theObject</VAR>'s shape,
* if -1, then theObject itself is a wire.
* \return New GEOM_Object, containing processed shape.
*/
GEOM_Object CloseContour (in GEOM_Object theObject, in short_array theWires,
- in boolean isCommonVertex);
+ in boolean isCommonVertex);
/*!
- * Remove internal wires and edges from the given object (face).
+ * \brief Remove internal wires and edges from the given object (face).
* \param theObject Shape to be processed.
* \param theWires Indices of wires to be removed, if EMPTY then the method
* removes ALL internal wires of the given object.
GEOM_Object RemoveIntWires (in GEOM_Object theObject, in short_array theWires);
/*!
- * Remove internal closed contours (holes) from the given object.
+ * \brief Remove internal closed contours (holes) from the given object.
* \param theObject Shape to be processed.
* \param theWires Indices of wires to be removed, if EMPTY then the method
* removes ALL internal holes of the given object
GEOM_Object Sew (in GEOM_Object theObject, in double theTolerance);
/*!
- * Addition of a point to a given edge object.
+ * \brief Addition of a point to a given edge object.
* \param theObject Shape to be processed.
* \param theEdgeIndex Index of edge to be divided within theObject's shape,
* if -1, then theObject itself is the edge.
* \return New GEOM_Object, containing processed shape.
*/
GEOM_Object DivideEdge (in GEOM_Object theObject, in short theEdgeIndex,
- in double theValue, in boolean isByParameter);
+ in double theValue, in boolean isByParameter);
/*!
- * Get a list of wires (wrapped in GEOM_Object-s),
+ * \brief Get a list of wires (wrapped in GEOM_Object-s),
* that constitute a free boundary of the given shape.
* \param theObject Shape to get free boundary of.
* \param theClosedWires Output. Closed wires on the free boundary of the given shape.
* \return FALSE, if an error(s) occured during the method execution.
*/
boolean GetFreeBoundary (in GEOM_Object theObject,
- out ListOfGO theClosedWires,
- out ListOfGO theOpenWires);
+ out ListOfGO theClosedWires,
+ out ListOfGO theOpenWires);
/*!
- * Change orientation of the given object.
+ * \brief Change orientation of the given object.
* \param theObject Shape to be processed.
* \return New GEOM_Object, containing processed shape.
*/
GEOM_Object ChangeOrientation (in GEOM_Object theObject);
GEOM_Object ChangeOrientationCopy (in GEOM_Object theObject);
+ /*!
+ * \brief Try to limit tolerance of the given object by value \a theTolerance.
+ * \param theObject Shape to be processed.
+ * \param theTolerance Required tolerance value.
+ * \return New GEOM_Object, containing processed shape.
+ */
+ GEOM_Object LimitTolerance (in GEOM_Object theObject, in double theTolerance);
+
};
+ // # GEOM_IInsertOperations:
/*!
- * GEOM_IInsertOperations: Interface for shape insert operations (like copy, import).
+ * \brief Interface for shape insert operations (like copy, import).
*
*/
interface GEOM_IInsertOperations : GEOM_IOperations
{
/*!
- * Create a copy of the given object
+ * \brief Create a copy of the given object
*/
GEOM_Object MakeCopy (in GEOM_Object theOriginal);
/*!
- * Export the given shape into a file with given name.
+ * \brief Export the given shape into a file with given name.
* \param theObject Shape to be stored in the file.
* \param theFileName Name of the file to store the given shape in.
* \param theFormatName Specify format for the shape storage.
void Export (in GEOM_Object theObject, in string theFileName, in string theFormatName);
/*!
- * Import a shape from the BRep or IGES or STEP file
+ * \brief Import a shape from the BRep or IGES or STEP file
* (depends on given format) with given name.
* \param theFileName The file, containing the shape.
* \param theFormatName Specify format for the file reading.
* set to 'meter' and result model will be scaled.
* \return New GEOM_Object, containing the imported shape.
*/
- GEOM_Object Import (in string theFileName, in string theFormatName);
+ GEOM_Object ImportFile (in string theFileName, in string theFormatName);
/*!
- * Get the supported import formats and corresponding patterns for File dialog.
+ * \brief Get the supported import formats and corresponding patterns for File dialog.
* \param theFormats Output. List of formats, available for import.
* \param thePatterns Output. List of file patterns, corresponding to available formats.
* \return Returns available formats and patterns through the arguments.
*/
void ImportTranslators (out string_array theFormats,
- out string_array thePatterns);
+ out string_array thePatterns);
/*!
- * Get the supported export formats and corresponding patterns for File dialog.
+ * \brief Get the supported export formats and corresponding patterns for File dialog.
* \param theFormats Output. List of formats, available for export.
* \param thePatterns Output. List of file patterns, corresponding to available formats.
* \return Returns available formats and patterns through the arguments.
*/
void ExportTranslators (out string_array theFormats,
- out string_array thePatterns);
+ out string_array thePatterns);
+
+ /*!
+ * \brief Load texture from file
+ * \param theTextureFile texture file name
+ * \return unique texture identifier
+ */
+ long LoadTexture(in string theTextureFile);
+
+ /*!
+ * \brief Add texture to the study
+ * \param theWidth texture width in pixels
+ * \param theHeight texture height in pixels
+ * \param theTexture texture byte array
+ * \return unique texture identifier
+ */
+ long AddTexture(in long theWidth, in long theHeight, in SALOMEDS::TMPFile theTexture);
+
+ /*!
+ * \brief Get previously loaded texture data
+ * \param theID texture identifier
+ * \param theWidth texture width in pixels
+ * \param theHeight texture height in pixels
+ * \return texture byte array
+ */
+ SALOMEDS::TMPFile GetTexture(in long theID, out long theWidth, out long theHeight);
+
+ /*!
+ * \brief Get list of all avaiable texture IDs
+ * \return list of all texture IDs avaiable for the current study
+ */
+ ListOfLong GetAllTextures();
};
+ // # GEOM_IKindOfShape:
/*!
- * GEOM_IKindOfShape: namespace for shape_kind enumeration.
+ * \brief Interface for shape_kind enumeration.
*/
interface GEOM_IKindOfShape
{
enum shape_kind {
NO_SHAPE,
- // COMPOSITEs
+ //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
+ /*! full sphere */
+ SPHERE,
+ /*! cylinder */
+ CYLINDER,
+ /*! box with faces, parallel to global coordinate planes */
+ BOX,
+ /*! other box */
+ ROTATED_BOX,
+ /*! full torus */
+ TORUS,
+ /*! cone */
+ CONE,
+ /*! solid, bounded by polygons */
+ POLYHEDRON,
+ /*! other solid */
+ 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
+ /*! spherical face (closed) */
+ SPHERE2D,
+ /*! cylindrical face with defined height */
+ CYLINDER2D,
+ /*! toroidal face (closed) */
+ TORUS2D,
+ /*! conical face with defined height */
+ CONE2D,
+ /*! planar, bounded by circle */
+ DISK_CIRCLE,
+ /*! planar, bounded by ellipse */
+ DISK_ELLIPSE,
+ /*! planar, bounded by segments */
+ POLYGON,
+ /*! infinite planar */
+ PLANE,
+ /*! other planar */
+ PLANAR,
+ /*! other face */
+ 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
+ /*! full circle */
+ CIRCLE,
+ /*! arc of circle */
+ ARC_CIRCLE,
+ /*! full ellipse */
+ ELLIPSE,
+ /*! arc of ellipse */
+ ARC_ELLIPSE,
+ /*! infinite segment */
+ LINE,
+ /*! segment */
+ SEGMENT,
+ /*! other edge */
+ EDGE,
// VERTEX
- VERTEX
+ VERTEX,
+ // ADVANCED shapes
+ /*! all advanced shapes (temporary implementation) */
+ ADVANCED
};
};
-
+ // # GEOM_IMeasureOperations:
/*!
- * GEOM_IMeasureOperations: Interface for measurement (distance, whatis) and
+ * \brief Interface for measurement (distance, whatis) and
* properties calculation (like Centre of Mass, Inertia, etc.).
*
*/
interface GEOM_IMeasureOperations : GEOM_IOperations
{
/*!
- * Get kind of theShape.
+ * \brief 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.)
*/
//short KindOfShape (in GEOM_Object theShape,
GEOM_IKindOfShape::shape_kind KindOfShape (in GEOM_Object theShape,
- out ListOfLong theIntegers,
- out ListOfDouble theDoubles);
+ out ListOfLong theIntegers,
+ out ListOfDouble theDoubles);
/*!
- * Get position (LCS) of theShape.
+ * \brief Get position (LCS) of theShape.
* \param theShape Shape to calculate position of.
* \param Ox,Oy,Oz Output. Coordinates of shape's location origin.
* Origin of the LCS is situated at the shape's center of mass.
* \return Returns position of the shape through the last nine arguments.
*/
void GetPosition (in GEOM_Object theShape,
- out double Ox, out double Oy, out double Oz,
- out double Zx, out double Zy, out double Zz,
- out double Xx, out double Xy, out double Xz);
+ out double Ox, out double Oy, out double Oz,
+ out double Zx, out double Zy, out double Zz,
+ out double Xx, out double Xy, out double Xz);
/*!
- * Get summarized length of all wires,
+ * \brief Get summarized length of all wires,
* area of surface and volume of the given shape.
* \param theShape Shape to define properties of.
* \param theLength Output. Summarized length of all wires of the given shape.
* \return Returns shape properties through the last three arguments.
*/
void GetBasicProperties (in GEOM_Object theShape,
- out double theLength,
- out double theSurfArea,
- out double theVolume);
+ out double theLength,
+ out double theSurfArea,
+ out double theVolume);
/*!
- * Get a point, situated at the centre of mass of theShape.
+ * \brief Get a point, situated at the centre of mass of theShape.
* \param theShape Shape to define centre of mass of.
* \return New GEOM_Object, containing the created point.
*/
GEOM_Object GetCentreOfMass (in GEOM_Object theShape);
+ /*
+ * Get the vertex by index for 1D objects depends the edge/wire orientation
+ * \param theShape Shape (wire or edge) to find the vertex on it
+ * \param theIndex Index of vertex sub-shape
+ * \return New GEOM_Object, vertex.
+ */
+ GEOM_Object GetVertexByIndex( in GEOM_Object theShape, in long index );
+
/*!
- * Get a vector, representing the normal of theFace.
+ * \brief 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.
* \return New GEOM_Object, containing the created normal vector.
*/
GEOM_Object GetNormal (in GEOM_Object theFace,
- in GEOM_Object theOptionalPoint);
+ in GEOM_Object theOptionalPoint);
/*!
- * Get inertia matrix and moments of inertia of theShape.
+ * \brief Get inertia matrix and moments of inertia of theShape.
* \param theShape Shape to calculate inertia of.
- * \param I(1-3)(1-3) Output. Components of the inertia matrix of the given shape.
+ * \param I11,I12,I13,I21,I22,I23,I31,I32,I33 Output. Components of the inertia matrix of the given shape.
* \param Ix,Iy,Iz Output. Moments of inertia of the given shape.
* \return Returns inertia through the last twelve arguments.
*/
void GetInertia (in GEOM_Object theShape,
- out double I11, out double I12, out double I13,
- out double I21, out double I22, out double I23,
- out double I31, out double I32, out double I33,
- out double Ix , out double Iy , out double Iz);
+ out double I11, out double I12, out double I13,
+ out double I21, out double I22, out double I23,
+ out double I31, out double I32, out double I33,
+ out double Ix , out double Iy , out double Iz);
/*!
- * Get parameters of bounding box of the given shape
+ * \brief Get parameters of bounding box of the given shape
* \param theShape Shape to obtain bounding box of.
* \param Xmin,Xmax Output. Limits of shape along OX axis.
* \param Ymin,Ymax Output. Limits of shape along OY axis.
* \return Returns parameters of bounding box through the last six arguments.
*/
void GetBoundingBox (in GEOM_Object theShape,
- out double Xmin, out double Xmax,
- out double Ymin, out double Ymax,
- out double Zmin, out double Zmax);
+ out double Xmin, out double Xmax,
+ out double Ymin, out double Ymax,
+ out double Zmin, out double Zmax);
/*!
- * Get min and max tolerances of sub-shapes of theShape
+ * \brief Get min and max tolerances of sub-shapes of theShape
* \param theShape Shape, to get tolerances of.
* \param FaceMin,FaceMax Output. Min and max tolerances of the faces.
* \param EdgeMin,EdgeMax Output. Min and max tolerances of the edges.
* \return Returns shape tolerances through the last six arguments.
*/
void GetTolerance (in GEOM_Object theShape,
- out double FaceMin, out double FaceMax,
- out double EdgeMin, out double EdgeMax,
- out double VertMin, out double VertMax);
+ out double FaceMin, out double FaceMax,
+ out double EdgeMin, out double EdgeMax,
+ out double VertMin, out double VertMax);
/*!
- * Check a topology of the given shape.
+ * \brief Check a topology of the given shape.
* \param theShape Shape to check validity of.
* \param theDescription Output. Description of problems in the shape, if they are.
* \return TRUE, if the shape "seems to be valid" from the topological point of view.
*/
boolean CheckShape (in GEOM_Object theShape,
- out string theDescription);
+ out string theDescription);
/*!
- * Check a topology and a geometry of the given shape.
+ * \brief Check a topology and a geometry of the given shape.
* \param theShape Shape to check validity of.
* \param theDescription Output. Description of problems in the shape, if they are.
* \return TRUE, if the shape "seems to be valid".
*/
boolean CheckShapeWithGeometry (in GEOM_Object theShape,
- out string theDescription);
+ out string theDescription);
/*!
- * Obtain description of the given shape
+ * \brief Check a topology of the given shape on self-intersections presence.
+ * \param theShape Shape to check validity of.
+ * \param theIntersections Output. List of intersected sub-shapes IDs, it contains pairs of IDs.
+ * \return TRUE, if the shape does not have any self-intersections.
+ */
+ boolean CheckSelfIntersections (in GEOM_Object theShape,
+ out ListOfLong theIntersections);
+
+ /*!
+ * \brief Check if the given shape can be an argument for MakeSolid operation
+ * \param theShape Shape to be described.
+ * \return Empty string if a solid can be made on this shape, error code otherwise.
+ */
+ string IsGoodForSolid (in GEOM_Object theShape);
+
+ /*!
+ * O\brief btain description of the given shape
* \param theShape Shape to be described.
* \return Description of the given shape.
*/
string WhatIs (in GEOM_Object theShape);
/*!
- * Get minimal distance between the given shapes.
+ * \brief Check if points defined by coords = [x1, y1, z1, x2, y2, z2, ...] are inside or on
+ * the shape theShape.
+ * \param theShape Shape to check.
+ * \param coords list of coordinates.
+ * \param tolerance tolerance.
+ * \return list of boolean.
+ */
+ ListOfBool AreCoordsInside(in GEOM_Object theShape, in ListOfDouble coords, in double tolerance);
+
+ /*!
+ * \brief Get minimal distance between the given shapes.
* \param theShape1,theShape2 Shapes to find minimal distance between.
* \param X1,Y1,Z1 Output. Coordinates of point on theShape1, nearest to theShape2.
* \param X2,Y2,Z2 Output. Coordinates of point on theShape2, nearest to theShape1.
* \return Value of the minimal distance between the given shapes.
*/
double GetMinDistance (in GEOM_Object theShape1, in GEOM_Object theShape2,
- out double X1, out double Y1, out double Z1,
- out double X2, out double Y2, out double Z2);
+ 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.
+ * \brief 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
+ * \brief Get angle between the given vectors.
+ * \param theShape1,theShape2 Vectors to find angle between.
+ * \return Value of the angle between the given vectors.
+ */
+ double GetAngleBtwVectors (in GEOM_Object theShape1, in GEOM_Object theShape2);
+
+ /*!
+ * \brief 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
+ * \brief 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
+ * \brief 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
+ * \brief 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);
+ in double theVParam);
/*!
- * Get max radius of curvature of surface in the given point
+ * \brief 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
+ * \brief 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);
+ in double theVParam);
/*!
- * Get min radius of curvature of surface in the given point
+ * \brief Get min radius of curvature of surface in the given point
* \param theShape - surface.
* \param thePoint - point
* \return Value of curvature.
};
-
+ // # GEOM_IGroupOperations:
/*!
- * GEOM_IGroupOperations: Interface for groups creation.
+ * \brief Interface for groups creation.
*/
interface GEOM_IGroupOperations : GEOM_IOperations
{
/*!
- * Creates a new group which will store sub shapes of theMainShape
- * \param theMainShape is a GEOM object on which the group is selected
+ * \brief Creates a new group which will store sub-shapes of theMainShape
+ * \param theMainShape is a GEOM_Object on which the group is selected
* \param theShapeType defines a shape type of the group
* \return a newly created GEOM group
*/
GEOM_Object CreateGroup (in GEOM_Object theMainShape, in long theShapeType);
/*!
- * Adds a sub object with ID theSubShapeId to the group
- * \param theGroup is a GEOM group to which the new sub shape is added
- * \param theSubShapeId is a sub shape ID in the main object.
- * \note Use method <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR> to get an ID by the sub shape
+ * \brief Adds a sub-object with ID theSubShapeId to the group
+ * \param theGroup is a GEOM group to which the new sub-shape is added
+ * \param theSubShapeId is a sub-shape ID in the main object.
+ * \note Use method <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR> to get an ID by the sub-shape
*/
void AddObject (in GEOM_Object theGroup, in long theSubShapeId);
/*!
- * Removes a sub object with ID \a theSubShapeId from the group
- * \param theGroup is a GEOM group from which the sub shape is removed.
- * \param theSubShapeId is a sub shape ID in the main object.
- * \note Use method <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR> to get an ID by the sub shape
+ * \brief Removes a sub-object with ID \a theSubShapeId from the group
+ * \param theGroup is a GEOM group from which the sub-shape is removed.
+ * \param theSubShapeId is a sub-shape ID in the main object.
+ * \note Use method <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR> to get an ID by the sub-shape
*/
void RemoveObject (in GEOM_Object theGroup, in long theSubShapeId);
/*!
- * Adds to the group all the given shapes. No errors, if some shapes are alredy included.
- * \param theGroup is a GEOM group to which the new sub shapes are added.
- * \param theSubShapes is a list of sub shapes to be added.
+ * \brief Adds to the group all the given shapes. No errors, if some shapes are alredy included.
+ * \param theGroup is a GEOM group to which the new sub-shapes are added.
+ * \param theSubShapes is a list of sub-shapes to be added.
*/
void UnionList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
/*!
- * Removes from the group all the given shapes. No errors, if some shapes are not included.
+ * \brief Removes from the group all the given shapes. No errors, if some shapes are not included.
* \param theGroup is a GEOM group from which the sub-shapes are removed.
* \param theSubShapes is a list of sub-shapes to be removed.
*/
void DifferenceList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
/*!
- * Adds to the group all the given shapes. No errors, if some shapes are alredy included.
- * \param theGroup is a GEOM group to which the new sub shapes are added.
- * \param theSubShapes is a list of IDs of sub shapes to be added.
+ * \brief Adds to the group all the given shapes. No errors, if some shapes are alredy included.
+ * \param theGroup is a GEOM group to which the new sub-shapes are added.
+ * \param theSubShapes is a list of IDs of sub-shapes to be added.
*/
void UnionIDs (in GEOM_Object theGroup, in ListOfLong theSubShapes);
/*!
- * Removes from the group all the given shapes. No errors, if some shapes are not included.
+ * \brief Removes from the group all the given shapes. No errors, if some shapes are not included.
* \param theGroup is a GEOM group from which the sub-shapes are removed.
* \param theSubShapes is a list of IDs of sub-shapes to be removed.
*/
void DifferenceIDs (in GEOM_Object theGroup, in ListOfLong theSubShapes);
/*!
- * Returns a type of sub objects stored in the group
+ * \brief Returns a type of sub-objects stored in the group
* \param theGroup is a GEOM group which type is returned.
*/
long GetType (in GEOM_Object theGroup);
/*!
- * Returns a main shape associated with the group
+ * \brief Returns a main shape associated with the group
* \param theGroup is a GEOM group for which a main shape object is requested
- * \return a GEOM object which is a main shape for theGroup
+ * \return a GEOM_Object which is a main shape for theGroup
*/
GEOM_Object GetMainShape (in GEOM_Object theGroup);
/*!
- * Returns a list of sub objects ID stored in the group
+ * \brief Returns a list of sub-objects ID stored in the group
* \param theGroup is a GEOM group for which a list of IDs is requested
*/
ListOfLong GetObjects (in GEOM_Object theGroup);
};
+ // # GEOM_IAdvancedOperations:
+ /*!
+ * \brief Interface for advanced modeling functions.
+ */
+ interface GEOM_IAdvancedOperations : GEOM_IOperations
+ {
+ /*!
+ * \brief Create a T-shape object with specified caracteristics for the main and
+ * the incident pipes (radius, width, half-length).
+ *
+ * Center of the shape is (0,0,0). The main plane of the T-shape is XOY.
+ * \param theR1 Internal radius of main pipe
+ * \param theW1 Width of main pipe
+ * \param theL1 Half-length of main pipe
+ * \param theR2 Internal radius of incident pipe (R2 < R1)
+ * \param theW2 Width of incident pipe (R2+W2 < R1+W1)
+ * \param theL2 Half-length of incident pipe
+ * \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
+ * \return List of GEOM_Object, containing the created shape and propagation groups.
+ */
+ ListOfGO MakePipeTShape (in double theR1, in double theW1, in double theL1,
+ in double theR2, in double theW2, in double theL2,
+ in boolean theHexMesh);
+ /*!
+ * \brief Create a T-shape object with specified caracteristics for the main and
+ * the incident pipes (radius, width, half-length).
+ *
+ * The extremities of the main pipe are located on junctions points P1 and P2.
+ * The extremity of the incident pipe is located on junction point P3.
+ * \param theR1 Internal radius of main pipe
+ * \param theW1 Width of main pipe
+ * \param theL1 Half-length of main pipe
+ * \param theR2 Internal radius of incident pipe (R2 < R1)
+ * \param theW2 Width of incident pipe (R2+W2 < R1+W1)
+ * \param theL2 Half-length of incident pipe
+ * \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
+ * \param theP1 1st junction point of main pipe
+ * \param theP2 2nd junction point of main pipe
+ * \param theP3 Junction point of incident pipe
+ * \return List of GEOM_Object, containing the created shape and propagation groups.
+ */
+ ListOfGO MakePipeTShapeWithPosition (in double theR1, in double theW1, in double theL1,
+ in double theR2, in double theW2, in double theL2,
+ in boolean theHexMesh,
+ in GEOM_Object theP1, in GEOM_Object theP2, in GEOM_Object theP3);
+ /*!
+ * \brief Create a T-shape object with specified caracteristics for the main and
+ * the incident pipes (radius, width, half-length). A chamfer is created
+ * on the junction of the pipes.
+ *
+ * Center of the shape is (0,0,0). The main plane of the T-shape is XOY.
+ * \param theR1 Internal radius of main pipe
+ * \param theW1 Width of main pipe
+ * \param theL1 Half-length of main pipe
+ * \param theR2 Internal radius of incident pipe (R2 < R1)
+ * \param theW2 Width of incident pipe (R2+W2 < R1+W1)
+ * \param theL2 Half-length of incident pipe
+ * \param theH Height of the chamfer.
+ * \param theW Width of the chamfer.
+ * \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
+ * \return List of GEOM_Object, containing the created shape and propagation groups.
+ */
+ ListOfGO MakePipeTShapeChamfer (in double theR1, in double theW1, in double theL1,
+ in double theR2, in double theW2, in double theL2,
+ in double theH, in double theW, in boolean theHexMesh);
+ /*!
+ * \brief Create a T-shape object with specified caracteristics for the main and
+ * the incident pipes (radius, width, half-length).
+ *
+ * A chamfer is created on the junction of the pipes.
+ * The extremities of the main pipe are located on junctions points P1 and P2.
+ * The extremity of the incident pipe is located on junction point P3.
+ * \param theR1 Internal radius of main pipe
+ * \param theW1 Width of main pipe
+ * \param theL1 Half-length of main pipe
+ * \param theR2 Internal radius of incident pipe (R2 < R1)
+ * \param theW2 Width of incident pipe (R2+W2 < R1+W1)
+ * \param theL2 Half-length of incident pipe
+ * \param theH Height of the chamfer.
+ * \param theW Width of the chamfer.
+ * \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
+ * \param theP1 1st junction point of main pipe
+ * \param theP2 2nd junction point of main pipe
+ * \param theP3 Junction point of incident pipe
+ * \return List of GEOM_Object, containing the created shape and propagation groups.
+ */
+ ListOfGO MakePipeTShapeChamferWithPosition (in double theR1, in double theW1, in double theL1,
+ in double theR2, in double theW2, in double theL2,
+ in double theH, in double theW, in boolean theHexMesh,
+ in GEOM_Object theP1, in GEOM_Object theP2, in GEOM_Object theP3);
+ /*!
+ * \brief Create a T-shape object with specified caracteristics for the main and
+ * the incident pipes (radius, width, half-length).
+ *
+ * A fillet is created on the junction of the pipes.
+ * Center of the shape is (0,0,0). The main plane of the T-shape is XOY.
+ * \param theR1 Internal radius of main pipe
+ * \param theW1 Width of main pipe
+ * \param theL1 Half-length of main pipe
+ * \param theR2 Internal radius of incident pipe (R2 < R1)
+ * \param theW2 Width of incident pipe (R2+W2 < R1+W1)
+ * \param theL2 Half-length of incident pipe
+ * \param theRF Radius of curvature of fillet.
+ * \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
+ * \return List of GEOM_Object, containing the created shape and propagation groups.
+ */
+ ListOfGO MakePipeTShapeFillet (in double theR1, in double theW1, in double theL1,
+ in double theR2, in double theW2, in double theL2,
+ in double theRF, in boolean theHexMesh);
+ /*!
+ * \brief Create a T-shape object with specified caracteristics for the main and
+ * the incident pipes (radius, width, half-length).
+ *
+ * A fillet is created on the junction of the pipes.
+ * The extremities of the main pipe are located on junctions points P1 and P2.
+ * The extremity of the incident pipe is located on junction point P3.
+ * \param theR1 Internal radius of main pipe
+ * \param theW1 Width of main pipe
+ * \param theL1 Half-length of main pipe
+ * \param theR2 Internal radius of incident pipe (R2 < R1)
+ * \param theW2 Width of incident pipe (R2+W2 < R1+W1)
+ * \param theL2 Half-length of incident pipe
+ * \param theRF Radius of curvature of fillet.
+ * \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
+ * \param theP1 1st junction point of main pipe
+ * \param theP2 2nd junction point of main pipe
+ * \param theP3 Junction point of incident pipe
+ * \return List of GEOM_Object, containing the created shape and propagation groups.
+ */
+ ListOfGO MakePipeTShapeFilletWithPosition (in double theR1, in double theW1, in double theL1,
+ in double theR2, in double theW2, in double theL2,
+ in double theRF, in boolean theHexMesh,
+ in GEOM_Object theP1, in GEOM_Object theP2, in GEOM_Object theP3);
+ /*!
+ * This function allows to create a disk already divided into blocks. It
+ * can be use to create divided pipes for later meshing in hexaedra.
+ * \param theR Radius of the disk
+ * \param theRatio Relative size of the central square diagonal against the disk diameter
+ * \return New GEOM_Object, containing the created shape.
+ */
+ GEOM_Object MakeDividedDisk (in double theR, in double theRatio, in short theOrientation);
+
+ /*@@ insert new functions before this line @@ do not remove this line @@*/
+ };
+ // # GEOM_Gen:
/*!
- * GEOM_Gen: Interface to access other GEOM interfaces.
- * Also contains some methods to access and manage GEOM objects.
+ * \brief Interface to access other GEOM interfaces.
+ *
+ * Also contains some methods to access and manage GEOM_Object.
*/
- interface GEOM_Gen : Engines::Component,SALOMEDS::Driver
+ interface GEOM_Gen : Engines::EngineComponent,SALOMEDS::Driver
{
/*!
- * Undo/Redo Management
+ * \brief Undo/Redo Management
*/
void Undo (in long theStudyID);
void Redo (in long theStudyID);
/*!
- * Publishing management
+ * \brief 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
*/
SALOMEDS::SObject AddInStudy (in SALOMEDS::Study theStudy,
- in GEOM_Object theObject,
- in string theName,
- in GEOM_Object theFather);
+ in GEOM_Object theObject,
+ in string theName,
+ in GEOM_Object theFather);
/*!
- * Publish sub-shapes, standing for arguments and sub-shapes of arguments
+ * \brief 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 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 theFindMethod method to search sub-shapes, corresponding to arguments and
+ * their sub-shapes. 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,
+ * Do not publish sub-shapes in place of arguments, but only
+ * in place of sub-shapes 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.
+ * \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
+ * and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
* \return list of published sub-shapes
*/
ListOfGO RestoreSubShapesO (in SALOMEDS::Study theStudy,
- in GEOM_Object theObject,
- in ListOfGO theArgs,
- in find_shape_method theFindMethod,
- in boolean theInheritFirstArg);
+ in GEOM_Object theObject,
+ in ListOfGO theArgs,
+ in find_shape_method theFindMethod,
+ in boolean theInheritFirstArg,
+ in boolean theAddPrefix);
+
+ /*!
+ * \brief 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 sub-shapes, corresponding to arguments and
+ * their sub-shapes. Value from enumeration GEOM::find_shape_method.
+ * \param theInheritFirstArg set properties of the first argument for \a theObject.
+ * Do not publish sub-shapes in place of arguments, but only
+ * in place of sub-shapes 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.
+ * \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
+ * and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
+ * \return list of published sub-shapes
+ */
+ ListOfGO RestoreGivenSubShapesO (in SALOMEDS::Study theStudy,
+ in GEOM_Object theObject,
+ in ListOfGO theArgs,
+ in find_shape_method theFindMethod,
+ in boolean theInheritFirstArg,
+ in boolean theAddPrefix);
/*!
- * Publish sub-shapes, standing for arguments and sub-shapes of arguments
+ * \brief 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
+ * \param theStudy the study, in which theObject is published already,
+ * and in which the arguments will be published
+ * \param theSObject study object, referencing 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 sub-shapes, corresponding to arguments and
+ * their sub-shapes. Value from enumeration GEOM::find_shape_method.
+ * \param theInheritFirstArg set properties of the first argument for \a theObject.
+ * Do not publish sub-shapes in place of arguments, but only
+ * in place of sub-shapes 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.
+ * \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
+ * and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
*/
ListOfGO RestoreSubShapesSO (in SALOMEDS::Study theStudy,
- in SALOMEDS::SObject theSObject,
- in ListOfGO theArgs,
- in find_shape_method theFindMethod,
- in boolean theInheritFirstArg);
+ in SALOMEDS::SObject theSObject,
+ in ListOfGO theArgs,
+ in find_shape_method theFindMethod,
+ in boolean theInheritFirstArg,
+ in boolean theAddPrefix);
- /*!
- * Methods to access interfaces for objects creation and transformation
- */
+ // # Methods to access interfaces for objects creation and transformation
+
GEOM_IBasicOperations GetIBasicOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
GEOM_ITransformOperations GetITransformOperations(in long theStudyID) raises (SALOME::SALOME_Exception);
GEOM_I3DPrimOperations GetI3DPrimOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
GEOM_IMeasureOperations GetIMeasureOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
GEOM_IBlocksOperations GetIBlocksOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
GEOM_IGroupOperations GetIGroupOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
+ GEOM_IAdvancedOperations GetIAdvancedOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
- /*!
- * Objects Management
- */
+ // # Objects Management
+
/*!
- * Removes the object from the GEOM component
- * \param theObject is a GEOM object to be removed
+ * \brief Removes the object from the GEOM component
+ * \param theObject is a GEOM_Object to be removed
*/
void RemoveObject (in GEOM_Object theObject);
/*!
- * Returns an object defined by the study and its entry in the GEOM component
+ * \brief Returns an object defined by the study and its entry in the GEOM component
* \param theStudyID is a SALOMEDS Study ID
- * \param theEntry is an entry of the requested GEOM object in the GEOM component
- * \note if the object has not previously been created a NULL GEOM object is returned
+ * \param theEntry is an entry of the requested GEOM_Object in the GEOM component
+ * \note if the object has not previously been created a NULL GEOM_Object is returned
*/
GEOM_Object GetObject (in long theStudyID, in string theEntry);
/*!
- * Add a sub shape defined by indices in \a theIndices
- * (contains unique IDs of sub shapes inside theMainShape)
- * \note The sub shape GEOM_Objects can has ONLY ONE function.
+ * \brief Add a sub-shape defined by indices in \a theIndices
+ * (contains unique IDs of sub-shapes inside \a theMainShape)
+ * \note The sub-shape GEOM_Object can has ONLY ONE function.
* Don't try to apply modification operations on them.
* \note Internal method
*/
GEOM_Object AddSubShape (in GEOM_Object theMainShape, in ListOfLong theIndices);
+ // # GEOM_Objects IOR Management
+
/*!
- * GEOM object's IOR Management
- */
-
- /*!
- * Returns a GEOM Object defined by its IOR
- * \param theIOR a string containg an IOR of the requested GEOM object
+ * \brief Returns a GEOM_Object defined by its IOR
+ * \param theIOR a string containg an IOR of the requested GEOM_Object
*/
GEOM_Object GetIORFromString (in string theIOR);
/*!
- * Returns a string which contains an IOR of the GEOM object
- * \param theObject is a GEOM object which IOR is requested
+ * \brief Returns a string which contains an IOR of the GEOM_Object
+ * \param theObject is a GEOM_Object which IOR is requested
*/
string GetStringFromIOR (in GEOM_Object theObject);
/*!
- * Returns a name with which a GEOM object was dumped into python script
- * \param theStudyEntry is an entry of the GEOM object in the study
+ * \brief Returns a name with which a GEOM_Object was dumped into python script
+ * \param theStudyEntry is an entry of the GEOM_Object in the study
*/
string GetDumpName (in string theStudyEntry);
/*!
- * Returns all names with which a GEOM objects was dumped
+ * \brief Returns all names with which a GEOM_Object was dumped
* into python script to avoid the same names in SMESH script
*/
string_array GetAllDumpNames();
/*!
- * Publishes the named subshapes of given object in the study.
+ * \brief Publishes the named sub-shapes of given object in the study.
* \param theStudy The study in which the object is published
- * \param theObject The object which named subshapes are published
+ * \param theObject The object which named sub-shapes are published
*/
ListOfGO PublishNamedShapesInStudy(in SALOMEDS::Study theStudy,
- //in SObject theSObject,
- in Object theObject);
+ //in SObject theSObject,
+ in Object theObject);
};
};