Salome HOME
Merge branch 'V9_11_BR'
[modules/geom.git] / idl / GEOM_Gen.idl
index a85830009c4e448fed8158f1c566bf3ffedc5623..7907cde35940c73aa950860bd6a5abd3391cde85 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023  CEA, EDF, 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
@@ -39,7 +39,7 @@ module GEOM
    */
   enum shape_type 
   { 
    */
   enum shape_type 
   { 
-    /*!  */
+    /*! A collection of arbitrary shapes */
     COMPOUND,
     /*! A collection of solids */ 
     COMPSOLID, 
     COMPOUND,
     /*! A collection of solids */ 
     COMPSOLID, 
@@ -47,16 +47,19 @@ module GEOM
     SOLID, 
     /*! A collection of faces connected by some edges of their wire boundaries */
     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 */
+    /*! Part of a plane (in 2D geometry) or a surface (in 3D geometry) bounded by a closed wire */
     FACE, 
     FACE, 
-    /*!  A sequence of edges connected by their vertices */
+    /*! 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,
     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 };
+    /*! Arbitrary shape in a Compound (used for processing of Compounds in some operations) */ 
+    SHAPE,
+    /*! Flat (top-level) contents of a Compound (used for processing of Compounds in some operations) */
+    FLAT
+    };
 
   /*!
    * \brief Marker type
 
   /*!
    * \brief Marker type
@@ -112,7 +115,8 @@ module GEOM
    *  \brief Kind of method to find inside one main shape some sub-shapes,
    *  corresponding to other given shape (its argument)
    *
    *  \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.RestoreSubShapesO(), GEOM_Gen.RestoreSubShapesSO()
+   *  Is used in functions GEOM_Gen.RestoreSubShapesO(), GEOM_Gen.RestoreSubShapesSO(),
+   *  TransferNames()
    */
   enum find_shape_method
   {
    */
   enum find_shape_method
   {
@@ -136,7 +140,10 @@ module GEOM
     /*! To be used only for multi-transformation result.
      *  Only this method can be used after multi-transformation.
      */
     /*! To be used only for multi-transformation result.
      *  Only this method can be used after multi-transformation.
      */
-    FSM_MultiTransformed
+    FSM_MultiTransformed,
+
+    /*! Use old GetInPlace functionality. */
+    FSM_GetInPlace_Old
   };
 
   /*!
   };
 
   /*!
@@ -188,8 +195,32 @@ module GEOM
     FDT_String
   };
 
     FDT_String
   };
 
+  /**
+   * This enumeration represents the level of checking shape on
+   * self-interference. It defines which interferferences will be checked.
+   */
+  enum si_check_level
+  {
+    SI_V_V,     // only V/V interferences
+    SI_V_E,     // V/V and V/E interferences
+    SI_E_E,     // V/V, V/E and E/E interferences
+    SI_V_F,     // V/V, V/E, E/E and V/F interferences
+    SI_E_F,     // V/V, V/E, E/E, V/F and E/F interferences
+    SI_ALL      // all interferences
+  };
 
 
- /*!
+  /**
+   * This enumeration represents comparison conditions.
+   */
+  enum comparison_condition
+  {
+    CC_GT, ///< Greater then
+    CC_GE, ///< Greater then or equal to
+    CC_LT, ///< Less then
+    CC_LE  ///< Less then or equal to
+  };
+
+  /*!
    * \brief Object creation parameters
    *
    * Is returned by GEOM_Object::GetCreationInformation()
    * \brief Object creation parameters
    *
    * Is returned by GEOM_Object::GetCreationInformation()
@@ -197,7 +228,6 @@ module GEOM
   struct Parameter
   {
     string name;
   struct Parameter
   {
     string name;
-    //any value;
     string value;
   };
   typedef sequence<Parameter> Parameters;
     string value;
   };
   typedef sequence<Parameter> Parameters;
@@ -207,6 +237,17 @@ module GEOM
     string     operationName;
     Parameters params;
   };
     string     operationName;
     Parameters params;
   };
+  typedef sequence<CreationInformation> CreationInformationSeq;
+
+  /*!
+   * \brief Reporting on shape healing
+   */
+  struct ModifInfo
+  {
+    string name;  // what changed
+    long   count; // how many times
+  };
+  typedef sequence<ModifInfo> ModifStatistics;
 
 
   typedef sequence<string>       string_array;
 
 
   typedef sequence<string>       string_array;
@@ -215,7 +256,9 @@ module GEOM
   typedef sequence<long>         ListOfLong;
   typedef sequence<double>       ListOfDouble;
   typedef sequence<ListOfDouble> ListOfListOfDouble;
   typedef sequence<long>         ListOfLong;
   typedef sequence<double>       ListOfDouble;
   typedef sequence<ListOfDouble> ListOfListOfDouble;
+  typedef sequence<ListOfLong>   ListOfListOfLong;
 
 
+  interface GEOM_Gen;
   interface GEOM_Object;
   interface GEOM_BaseObject;
   interface GEOM_Field;
   interface GEOM_Object;
   interface GEOM_BaseObject;
   interface GEOM_Field;
@@ -253,12 +296,9 @@ module GEOM
     string GetEntry();
 
     /*!
     string GetEntry();
 
     /*!
-     *  \brief Get ID of study, where the object is created.
-     */
-    long GetStudyID();
-
-    /*!
-     *  \brief Get internal type of the object (POINT, BOX, CYLINDER, EXTRUSION...).
+     *  \brief Get internal type of operation created this object (POINT, BOX, CYLINDER, EXTRUSION...).
+     *  \note To get topological information on the object, use \ref GEOM_IMeasureOperations::WhatIs() "WhatIs()"
+     * or \ref GEOM_IMeasureOperations::KindOfShape() "KindOfShape()" operation.
      */
     long GetType();
 
      */
     long GetType();
 
@@ -319,7 +359,12 @@ module GEOM
     /*!
      * \brief Return name of operation and values of parameters used for object creation
      */
     /*!
      * \brief Return name of operation and values of parameters used for object creation
      */
-    CreationInformation GetCreationInformation();
+    CreationInformationSeq GetCreationInformation();
+
+    /*!
+     * \brief Return the engine creating this object
+     */
+    GEOM_Gen GetGen();
   };
 
   //# GEOM_Object
   };
 
   //# GEOM_Object
@@ -348,7 +393,7 @@ module GEOM
      *
      *  This function is useful for the compounds only; for simple shapes it
      *  exactly the same value as GetShapeType().
      *
      *  This function is useful for the compounds only; for simple shapes it
      *  exactly the same value as GetShapeType().
-     *  Note, that compounds are procesed recursively.
+     *  Note, that compounds are processed recursively.
      *
      *  \sa GetShapeType(), GetTopologyType(), GetMaxShapeType()
      */
      *
      *  \sa GetShapeType(), GetTopologyType(), GetMaxShapeType()
      */
@@ -359,12 +404,24 @@ module GEOM
      *
      *  This function is useful for the compounds only; for simple shapes it
      *  exactly the same value as GetShapeType().
      *
      *  This function is useful for the compounds only; for simple shapes it
      *  exactly the same value as GetShapeType().
-     *  Note, that compounds are procesed recursively.
+     *  Note, that compounds are processed recursively.
      *
      *  \sa GetShapeType(), GetTopologyType(), GetMinShapeType()
      */
     shape_type GetMaxShapeType();
 
      *
      *  \sa GetShapeType(), GetTopologyType(), GetMinShapeType()
      */
     shape_type GetMaxShapeType();
 
+    /*!
+     *  \brief Returns a name of a sub-shape if the sub-shape is published in the study
+     *  \param subID - sub-shape ID
+     *  \return string - the found name or an empty string if the sub-shape does not
+     *          exits or is not published in the study
+     *
+     * \note Only sub-shapes directly retrieved (using e.g. ExtractSubShapes() or
+     *       via group creation) can be found. Also, as sub-shape can be published in the study
+     *       many times, only the first found name is returned.
+     */
+    string GetSubShapeName(in long subID);
+
     /*!
      *  \brief Set color of the object.
      *
     /*!
      *  \brief Set color of the object.
      *
@@ -452,6 +509,12 @@ module GEOM
      */
     GEOM_Object GetMainShape();
 
      */
     GEOM_Object GetMainShape();
 
+    /*
+     * \brief Returns true if the current object has connection to a parametrical model
+     * which can be modified by parameters change.
+     */
+    boolean IsParametrical();
+
   };
 
   //# GEOM_Field
   };
 
   //# GEOM_Field
@@ -627,7 +690,7 @@ module GEOM
 
     /*!
      *  \brief Set the operation error code
 
     /*!
      *  \brief Set the operation error code
-     *  \param theErrorID is a string describing the error occured
+     *  \param theErrorID is a string describing the error occurred
      *  \note This method is supposed to be used only by interfaces inheriting from IOperations.
      */
     void SetErrorCode (in string theErrorID);
      *  \note This method is supposed to be used only by interfaces inheriting from IOperations.
      */
     void SetErrorCode (in string theErrorID);
@@ -637,18 +700,13 @@ module GEOM
      */
     string GetErrorCode();
 
      */
     string GetErrorCode();
 
-    /*!
-     *  \brief Get ID of study, where the operation is defined
-     */
-    long GetStudyID();
-
     /*!
      *  \brief Opens a new transaction
      */
     void StartOperation();
 
     /*!
     /*!
      *  \brief Opens a new transaction
      */
     void StartOperation();
 
     /*!
-     *  \brief Closes the previously opened trasaction
+     *  \brief Closes the previously opened transaction
      */
     void FinishOperation();
 
      */
     void FinishOperation();
 
@@ -690,10 +748,13 @@ module GEOM
      *  Create a point, corresponding to the given parameter on the given curve.
      *  \param theRefCurve The referenced curve.
      *  \param theParameter Value of parameter on the referenced curve.
      *  Create a point, corresponding to the given parameter on the given curve.
      *  \param theRefCurve The referenced curve.
      *  \param theParameter Value of parameter on the referenced curve.
+     *  \param takeOrientationIntoAccount flag that tells if it is necessary
+     *         to take the curve's orientation into account.
      *  \return New GEOM_Object, containing the created point.
      */
     GEOM_Object MakePointOnCurve (in GEOM_Object theRefCurve,
      *  \return New GEOM_Object, containing the created point.
      */
     GEOM_Object MakePointOnCurve (in GEOM_Object theRefCurve,
-                                  in double theParameter);
+                                  in double      theParameter,
+                                  in boolean     takeOrientationIntoAccount);
 
     /*!
      *  \brief Create a point, corresponding to the given length on the given curve.
 
     /*!
      *  \brief Create a point, corresponding to the given length on the given curve.
@@ -755,7 +816,8 @@ module GEOM
      *  \param theFace The referenced face.
      *  \return New GEOM_Object, containing the created point.
      */
      *  \param theFace The referenced face.
      *  \return New GEOM_Object, containing the created point.
      */
-    GEOM_Object MakePointOnFace (in GEOM_Object theFace);
+    GEOM_Object MakePointOnFace (in GEOM_Object theFace,
+                                in long        theNumberOfPnts);
 
     /*!
      *  \brief Create a point, on two lines intersection.
 
     /*!
      *  \brief Create a point, on two lines intersection.
@@ -796,8 +858,8 @@ module GEOM
     GEOM_Object MakeVectorTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
 
     /*!
     GEOM_Object MakeVectorTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
 
     /*!
-     *  C\brief reate a line, passing through the given point
-     *  and parrallel to the given direction
+     *  \brief Create a line, passing through the given point
+     *  and parallel 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.
      *  \return New GEOM_Object, containing the created line.
      *  \param thePnt Point. The resulting line will pass through it.
      *  \param theDir Direction. The resulting line will be parallel to it.
      *  \return New GEOM_Object, containing the created line.
@@ -824,7 +886,7 @@ module GEOM
      *  \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.
      *  \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.
+     *  \param thePnt3 Third of three points, defining the plane.
      *  \param theTrimSize Half size of a side of quadrangle face, representing the plane.
      *  \return New GEOM_Object, containing the created plane.
      */
      *  \param theTrimSize Half size of a side of quadrangle face, representing the plane.
      *  \return New GEOM_Object, containing the created plane.
      */
@@ -1242,17 +1304,23 @@ module GEOM
      *  \brief Replace the given object by its offset.
      *  \param theObject The base object for the offset.
      *  \param theOffset Offset value.
      *  \brief Replace the given object by its offset.
      *  \param theObject The base object for the offset.
      *  \param theOffset Offset value.
+     *  \param theJoinByPipes To join offset surfaces by pipes or by intersection.
      *  \return theObject.
      */
      *  \return theObject.
      */
-    GEOM_Object OffsetShape (in GEOM_Object theObject, in double theOffset);
+    GEOM_Object OffsetShape (in GEOM_Object theObject,
+                             in double      theOffset,
+                             in boolean     theJoinByPipes);
 
     /*!
      *  \brief Create new object as offset of the given one.
      *  \param theObject The base object for the offset.
      *  \param theOffset Offset value.
 
     /*!
      *  \brief Create new object as offset of the given one.
      *  \param theObject The base object for the offset.
      *  \param theOffset Offset value.
+     *  \param theJoinByPipes To join offset surfaces by pipes or by intersection.
      *  \return New GEOM_Object, containing the offset object.
      */
      *  \return New GEOM_Object, containing the offset object.
      */
-    GEOM_Object OffsetShapeCopy (in GEOM_Object theObject, in double theOffset);
+    GEOM_Object OffsetShapeCopy (in GEOM_Object theObject,
+                                 in double      theOffset,
+                                 in boolean     theJoinByPipes);
 
     /*!
      *  \brief Create new object as projection of the given one on a 2D surface.
 
     /*!
      *  \brief Create new object as projection of the given one on a 2D surface.
@@ -1379,6 +1447,35 @@ module GEOM
      *  \return theObject.
      */
     GEOM_Object RecomputeObject (in GEOM_Object theObject);
      *  \return theObject.
      */
     GEOM_Object RecomputeObject (in GEOM_Object theObject);
+
+    /*!
+     *  \brief Compute the projection of a wire or a face on a cylinder.
+     *
+     *  This method computes a wire or a face or a compound of faces
+     *  that represents a projection of the source shape onto cylinder.
+     *  The cylinder's coordinate system is the same as the global coordinate
+     *  system.
+     *
+     *  \param theObject The object to be projected. It can be either
+     *         a planar wire or a face.
+     *  \param theRadius The radius of the cylinder.
+     *  \param theStartAngle The starting angle from the cylinder's X axis
+     *         around Z axis. The angle from which the projection is started.
+     *  \param theAngleLength The projection length angle. The angle in which
+     *         to project the total length of the wire. If it is negative the
+     *         projection is not scaled and natural wire length is kept for
+     *         the projection.
+     *  \param theAngleRotation the desired angle between the tangent vector
+     *         to the first curve at the first point of the theObject's
+     *         projection in 2D space and U-direction of cylinder's 2D space.
+     *  \return A wire or a face or a compound of faces that represents a
+     *         projection of the source shape onto a cylinder.
+     */
+    GEOM_Object MakeProjectionOnCylinder (in GEOM_Object theObject,
+                                          in double      theRadius,
+                                          in double      theStartAngle,
+                                          in double      theAngleLength,
+                                          in double      theAngleRotation);
   };
   
   /*!
   };
   
   /*!
@@ -1638,29 +1735,38 @@ module GEOM
 
 
     /*!
 
 
     /*!
-     *  \brief Add / Remove material to / from  a solid by extrusion of the base shape on the given distance.
+     *  \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
      *  \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
+     *  \param theInvert If true material changes the direction 
      *  \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,
      *  \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);
+                                in boolean theFuse,
+                                in boolean theInvert);
 
     /*!
      *  \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.
 
     /*!
      *  \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.
-     *  \return New GEOM_Object, containing the created pipe.
+     *  \param IsGenerateGroups flag that tells if it is necessary to
+     *         return groups (true) or not (false).
+     *  \return The list of objects. The first one is a result pipe,
+     *          the other ones are the created groups. If \a IsGenerateGroups
+     *          is not set the returned list contains a single object, which
+     *          is the operation result.
      */
      */
-    GEOM_Object MakePipe (in GEOM_Object theBase, in GEOM_Object thePath);
+    ListOfGO MakePipe (in GEOM_Object theBase,
+                       in GEOM_Object thePath,
+                       in boolean     IsGenerateGroups);
 
     /*!
      *  \brief Create a shape by revolution of the base shape around the axis
 
     /*!
      *  \brief Create a shape by revolution of the base shape around the axis
@@ -1682,18 +1788,18 @@ module GEOM
                                               in double theAngle);
 
     /*!
                                               in double theAngle);
 
     /*!
-     *  \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
+     *  \brief Create a face from a given set of contours.
+     *  \param theContours either a list or a compound of edges/wires.
+     *  \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 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.
+     *  \param theApprox Boolean indicating if result should be approximated.
+     *  \return New GEOM_Object (face), containing the created filling surface.
      */
      */
-    GEOM_Object MakeFilling (in GEOM_Object theShape,
+    GEOM_Object MakeFilling (in ListOfGO theContours,
                              in long theMinDeg, in long theMaxDeg,
                              in double theTol2D, in double theTol3D,
                              in long theNbIter,
                              in long theMinDeg, in long theMaxDeg,
                              in double theTol2D, in double theTol3D,
                              in long theNbIter,
@@ -1719,22 +1825,33 @@ module GEOM
      *
      *  The path shape can be a wire or an edge.
      *  the several profiles can be specified in the several locations of path.
      *
      *  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 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
      *                        should be equal to number of bases or list of locations can be empty.
      *  \param thePath - Path shape to extrude the base shape along it.
      *  \param theWithContact - the mode defining that the section is translated to be in
      *  \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 or list of locations can be empty.
      *  \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.
+     *                          contact with the spine. Ignored if IsBySteps is set.
      *  \param theWithCorrection - defining that the section is rotated to be
      *  \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 );
+     *                                 orthogonal to the spine tangent in
+     *                          the correspondent point. Ignored if IsBySteps is set.
+     *  \param IsBySteps - flag that tells if the result should be created
+     *         step by step or as a whole. If IsBySteps is set no correction
+     *         of bases is allowed.
+     *  \param IsGenerateGroups flag that tells if it is necessary to
+     *         return groups (true) or not (false).
+     *  \return The list of objects. The first one is a result pipe,
+     *          the other ones are the created groups. If \a IsGenerateGroups
+     *          is not set the returned list contains a single object, which
+     *          is the operation result.
+     */
+    ListOfGO MakePipeWithDifferentSections (in ListOfGO theSeqBases,
+                                            in ListOfGO theLocations,
+                                            in GEOM_Object thePath,
+                                            in boolean theWithContact ,
+                                            in boolean theWithCorrection,
+                                            in boolean IsBySteps,
+                                            in boolean IsGenerateGroups);
 
     /*!
      *  \brief Create a shape by extrusion of the profile shape along
 
     /*!
      *  \brief Create a shape by extrusion of the profile shape along
@@ -1742,7 +1859,7 @@ module GEOM
      *
      *  The path shape can be a shell or a face.
      *  the several profiles can be specified in the several locations of path.
      *
      *  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 theSeqBases - list of Bases shape to be extruded.
      *  \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
      *  \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
@@ -1752,23 +1869,35 @@ module GEOM
      *                          contact with the spine.
      *  \param theWithCorrection - defining that the section is rotated to be
      *                                 orthogonal to the spine tangent in the correspondent point
      *                          contact with the spine.
      *  \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 );
+     *  \param IsGenerateGroups flag that tells if it is necessary to
+     *         return groups (true) or not (false).
+     *  \return The list of objects. The first one is a result pipe,
+     *          the other ones are the created groups. If \a IsGenerateGroups
+     *          is not set the returned list contains a single object, which
+     *          is the operation result.
+     */
+    ListOfGO MakePipeWithShellSections (in ListOfGO theSeqBases,
+                                        in ListOfGO theSeqSubBases,
+                                        in ListOfGO theLocations,
+                                        in GEOM_Object thePath,
+                                        in boolean theWithContact,
+                                        in boolean theWithCorrection,
+                                        in boolean IsGenerateGroups);
 
     /*!
      *  \brief Create solids between given sections
      *  \param theSeqBases - list of sections (shell or face).
      *  \param theLocations - list of corresponding vertexes
 
     /*!
      *  \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.
+     *  \param IsGenerateGroups flag that tells if it is necessary to
+     *         return groups (true) or not (false).
+     *  \return The list of objects. The first one is a result pipe,
+     *          the other ones are the created groups. If \a IsGenerateGroups
+     *          is not set the returned list contains a single object, which
+     *          is the operation result.
      */
      */
-    GEOM_Object MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
-                                           in ListOfGO theLocations);
+    ListOfGO MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
+                                        in ListOfGO theLocations,
+                                        in boolean  IsGenerateGroups);
 
     /*!
      *  \brief Create a shape by extrusion of the base shape along
 
     /*!
      *  \brief Create a shape by extrusion of the base shape along
@@ -1778,26 +1907,42 @@ module GEOM
      *  \param theBase Base shape to be extruded.
      *  \param thePath Path shape to extrude the base shape along it.
      *  \param theVec Vector defines a constant binormal direction to keep the
      *  \param theBase Base shape to be extruded.
      *  \param thePath Path shape to extrude the base shape along it.
      *  \param theVec Vector defines a constant binormal direction to keep the
-     *                same angle beetween the Direction and the sections
+     *                same angle between the Direction and the sections
      *                along the sweep surface.
      *                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);
+     *  \param IsGenerateGroups flag that tells if it is necessary to
+     *         return groups (true) or not (false).
+     *  \return The list of objects. The first one is a result pipe,
+     *          the other ones are the created groups. If \a IsGenerateGroups
+     *          is not set the returned list contains a single object, which
+     *          is the operation result.
+     */
+    ListOfGO MakePipeBiNormalAlongVector (in GEOM_Object theBase,
+                                          in GEOM_Object thePath,
+                                          in GEOM_Object theVec,
+                                          in boolean     IsGenerateGroups);
 
 
      /*!
 
 
      /*!
-     *  \brief Make a thick solid from a surface shape (face or shell)
-     *  \param theObject Surface from which the thick solid is made
+     *  \brief Make a thick solid from a shape.
+     *
+     *  If the input is a surface shape (face or shell) the result is
+     *  a thick solid. If an input shape is a solid the result is a hollowed
+     *  solid with removed faces.
+     *  \param theObject face or shell to get thick solid or solid to get
+     *         hollowed solid.
+     *  \param theFacesIDs the list of face IDs to be removed from the result.
+     *          It can be empty.
      *  \param theThickness Value of the thickness
      *  \param theThickness Value of the thickness
-     *  \param isCopy To make a copy of \a theObject ot to modify \a theObject.
+     *  \param isCopy To make a copy of \a theObject or to modify \a theObject
+     *  \param isInside If true the thickness is applied towards inside
      *  \return New GEOM_Object, containing the created pipe if isCopy = true
      *          or the modified object if isCopy = false
      */
     GEOM_Object MakeThickening (in GEOM_Object theObject,
      *  \return New GEOM_Object, containing the created pipe if isCopy = true
      *          or the modified object if isCopy = false
      */
     GEOM_Object MakeThickening (in GEOM_Object theObject,
-                                in double theThickness,
-                                in boolean isCopy);
+                                in ListOfLong  theFacesIDs,
+                                in double      theThickness,
+                                in boolean     isCopy,
+                                in boolean     isInside);
 
     
     /*!
 
     
     /*!
@@ -1912,6 +2057,25 @@ module GEOM
      */
     GEOM_Object MakeFaceWires (in ListOfGO theWires, in boolean isPlanarWanted);
 
      */
     GEOM_Object MakeFaceWires (in ListOfGO theWires, in boolean isPlanarWanted);
 
+    /**
+     *  \brief Create a face based on surface of theFace limited by theWire.
+     *  \param theFace the face whose surface is used to create a new face.
+     *  \param theWire closed Wire build the face.
+     *  \return New GEOM_Object, containing the created face.
+     */
+    GEOM_Object MakeFaceFromSurface(in GEOM_Object theFace,
+                                    in GEOM_Object theWire);
+
+    /*!
+     *  \brief Create a face from a set of edges with the given constraints.
+     *  \param theConstraints List of edges and constraint faces (as a sequence of a Edge + Face couples):
+     *         - edges should form a closed wire;
+     *         - for each edge, constraint face is optional: if a constraint face is missing
+     *           for some edge, this means that there no constraint associated with this edge.
+     *  \return New GEOM_Object, containing the created face.
+     */
+    GEOM_Object MakeFaceWithConstraints(in ListOfGO theConstraints);
+
     /*!
      *  \brief Create a shell from the set of faces and shells.
      *  \param theFacesAndShells List of faces and/or shells.
     /*!
      *  \brief Create a shell from the set of faces and shells.
      *  \param theFacesAndShells List of faces and/or shells.
@@ -1941,64 +2105,73 @@ module GEOM
     GEOM_Object MakeCompound (in ListOfGO theShapes);
 
     /*!
     GEOM_Object MakeCompound (in ListOfGO theShapes);
 
     /*!
-     *  \brief Replace coincident faces in theShape by one face.
-     *  \param theShape Initial shape.
+     *  \brief Make a solid (or solids) from connected set of faces and/or shells.
+     *  \param theFacesOrShells List of faces and/or shells.
+     *  \param isIntersect If TRUE, forces performing intersections between arguments.
+     *
+     *  \return New GEOM_Object, containing the created solid (or compound of solids).
+     */
+    GEOM_Object MakeSolidFromConnectedFaces (in ListOfGO theFacesOrShells, in boolean isIntersect);
+    
+    /*!
+     *  \brief Replace coincident faces in \a theShapes by one face.
+     *  \param theShapes Initial shapes.
      *  \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.
      *  \param theTolerance Maximum distance between faces, which can be considered as coincident.
      *  \param doKeepNonSolids If FALSE, only solids will present in the result, otherwise all initial shapes.
-     *  \return New GEOM_Object, containing a copy of theShape without coincident faces.
+     *  \return New GEOM_Object containing copies of theShapes without coincident faces.
      */
      */
-    GEOM_Object MakeGlueFaces (in GEOM_Object theShape, in double theTolerance, in boolean doKeepNonSolids);
+    GEOM_Object MakeGlueFaces (in ListOfGO theShapes, in double theTolerance, in boolean doKeepNonSolids);
 
     /*!
 
     /*!
-     *  Find coincident faces in theShape for possible gluing.
-     *  \param theShape Initial shape.
+     *  Find coincident faces in theShapes for possible gluing.
+     *  \param theShapes Initial shapes.
      *  \param theTolerance Maximum distance between faces, which can be considered as coincident.
      *  \return ListOfGO
      */
      *  \param theTolerance Maximum distance between faces, which can be considered as coincident.
      *  \return ListOfGO
      */
-    ListOfGO GetGlueFaces (in GEOM_Object theShape, in double theTolerance);
+    ListOfGO GetGlueFaces (in ListOfGO theShapes, in double theTolerance);
 
     /*!
 
     /*!
-     *  \brief Replace coincident faces in theShape by one face
-     *  in compliance with given list of faces
-     *  \param theShape Initial shape.
+     *  \brief Replace coincident faces in \a theShapes by one face
+     *         in compliance with given list of faces
+     *  \param theShapes Initial shapes.
      *  \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>.
      *  \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.
+     *  \return New GEOM_Object containing copies of theShapes without coincident faces.
      */
      */
-    GEOM_Object MakeGlueFacesByList (in GEOM_Object theShape, in double theTolerance,
-                                     in ListOfGO theFaces, in boolean doKeepNonSolids,
+    GEOM_Object MakeGlueFacesByList (in ListOfGO theShapes, in double theTolerance,
+                                     in ListOfGO theFaces,  in boolean doKeepNonSolids,
                                      in boolean doGlueAllEdges);
 
     /*!
                                      in boolean doGlueAllEdges);
 
     /*!
-     *  \brief Replace coincident edges in theShape by one edge.
-     *  \param theShape Initial shape.
+     *  \brief Replace coincident edges in \a theShapes by one edge.
+     *  \param theShapes Initial shapes.
      *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
      *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
-     *  \return New GEOM_Object, containing a copy of theShape without coincident edges.
+     *  \return New GEOM_Object containing copies of theShapes without coincident edges.
      */
      */
-    GEOM_Object MakeGlueEdges (in GEOM_Object theShape, in double theTolerance);
+    GEOM_Object MakeGlueEdges (in ListOfGO theShapes, in double theTolerance);
 
     /*!
 
     /*!
-     *  Find coincident edges in theShape for possible gluing.
-     *  \param theShape Initial shape.
+     *  Find coincident edges in \a theShapes for possible gluing.
+     *  \param theShapes Initial shapes.
      *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
      *  \return ListOfGO
      */
      *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
      *  \return ListOfGO
      */
-    ListOfGO GetGlueEdges (in GEOM_Object theShape, in double theTolerance);
+    ListOfGO GetGlueEdges (in ListOfGO theShapes, in double theTolerance);
 
     /*!
 
     /*!
-     *  \brief Replace coincident edges in theShape by one edge
-     *  in compliance with given list of edges
-     *  \param theShape Initial shape.
+     *  \brief Replace coincident edges in \a theShapes by one edge
+     *         in compliance with given list of edges
+     *  \param theShapes Initial shapes.
      *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
      *  \param theEdges List of edges for gluing.
      *  \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.
+     *  \return New GEOM_Object containing copies of theShapes without some edges.
      */
      */
-    GEOM_Object MakeGlueEdgesByList (in GEOM_Object theShape,
-                                     in double theTolerance,
+    GEOM_Object MakeGlueEdgesByList (in ListOfGO theShapes,
+                                     in double   theTolerance,
                                      in ListOfGO theEdges);
 
     /*!
                                      in ListOfGO theEdges);
 
     /*!
@@ -2130,6 +2303,23 @@ module GEOM
      */
     string GetShapeTypeString (in GEOM_Object theShape);
 
      */
     string GetShapeTypeString (in GEOM_Object theShape);
 
+    /*!
+     *  \brief Check if the object is a sub-object of another GEOM object.
+     *
+     *  \param theSubObject Checked sub-object (or its parent object, in case if
+     *                      \a theSubObjectIndex is non-zero).
+     *  \param theSubObjectIndex When non-zero, specifies a sub-shape index that
+     *                           identifies a sub-object within its parent specified via \a theSubObject.
+     *  \param theObject An object that is checked for ownership (or its parent object,
+     *                   in case if \a theObjectIndex is non-zero).
+     *  \param theObjectIndex When non-zero, specifies a sub-shape index that
+     *                        identifies an object within its parent specified via \a theObject.
+     *  \return TRUE, if the given object contains sub-object.
+     */
+    boolean IsSubShapeBelongsTo( in GEOM_Object theSubObject,
+                                 in long        theSubObjectIndex,
+                                 in GEOM_Object theObject,
+                                 in long        theObjectIndex);
     /*!
      *  \brief Count number of faces in the given shape.
      *  \param theShape Shape to count faces in.
     /*!
      *  \brief Count number of faces in the given shape.
      *  \param theShape Shape to count faces in.
@@ -2181,13 +2371,21 @@ module GEOM
                               in long        theShapeType);
 
     /*!
                               in long        theShapeType);
 
     /*!
-     *  \brief Get all sub-shapes, shared by all shapes in the list \a theShapes.
+     *  \brief Get sub-shapes, shared by input shapes.
      *  \param theShapes Shapes to find common sub-shapes of.
      *  \param theShapeType Type of sub-shapes to be retrieved.
      *  \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.
+     *  \param theMultiShare Specifies what type of shares should be checked:
+     *         - \c TRUE: search sub-shapes from 1st input shape shared with all other input shapes;
+     *         - \c FALSE: causes to search sub-shapes shared between couples of input shapes.
+     *  \note If \a theShapes contains single compound, the shares between all possible couples of 
+     *        its top-level shapes are returned; otherwise, only shares between 1st input shape
+     *        and all rest input shapes are returned.
+     *              
+     *  \return List of all found sub-shapes.
      */
     ListOfGO GetSharedShapesMulti (in ListOfGO theShapes,
      */
     ListOfGO GetSharedShapesMulti (in ListOfGO theShapes,
-                                   in long     theShapeType);
+                                   in long     theShapeType,
+                                  in boolean  theMultiShare);
 
     /*!
      *  \brief 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
@@ -2280,18 +2478,18 @@ module GEOM
      *  \param theShape Shape to find sub-shapes of.
      *  \param theShapeType Type of sub-shapes to be retrieved.
      *  \param theTopLeftPoint Top left quadrangle corner
      *  \param theShape Shape to find sub-shapes of.
      *  \param theShapeType Type of sub-shapes to be retrieved.
      *  \param theTopLeftPoint Top left quadrangle corner
-     *  \param theTopRigthPoint Top right quadrangle corner
+     *  \param theTopRightPoint Top right quadrangle corner
      *  \param theBottomLeftPoint Bottom left quadrangle corner
      *  \param theBottomLeftPoint Bottom left quadrangle corner
-     *  \param theBottomRigthPoint Bottom right quadrangle corner
+     *  \param theBottomRightPoint Bottom right quadrangle corner
      *  \param theState The state of the sub-shapes to find.
      *  \return List of all found sub-shapes.
      */
     ListOfGO GetShapesOnQuadrangle (in GEOM_Object theShape,
                                     in long        theShapeType,
                                     in GEOM_Object theTopLeftPoint,
      *  \param theState The state of the sub-shapes to find.
      *  \return List of all found sub-shapes.
      */
     ListOfGO GetShapesOnQuadrangle (in GEOM_Object theShape,
                                     in long        theShapeType,
                                     in GEOM_Object theTopLeftPoint,
-                                    in GEOM_Object theTopRigthPoint,
+                                    in GEOM_Object theTopRightPoint,
                                     in GEOM_Object theBottomLeftPoint,
                                     in GEOM_Object theBottomLeftPoint,
-                                    in GEOM_Object theBottomRigthPoint,
+                                    in GEOM_Object theBottomRightPoint,
                                     in shape_state theState);
 
     /*!
                                     in shape_state theState);
 
     /*!
@@ -2384,18 +2582,18 @@ module GEOM
      *  \param theShape Shape to find sub-shapes of.
      *  \param theShapeType Type of sub-shapes to be retrieved.
      *  \param theTopLeftPoint Top left quadrangle corner
      *  \param theShape Shape to find sub-shapes of.
      *  \param theShapeType Type of sub-shapes to be retrieved.
      *  \param theTopLeftPoint Top left quadrangle corner
-     *  \param theTopRigthPoint Top right quadrangle corner
+     *  \param theTopRightPoint Top right quadrangle corner
      *  \param theBottomLeftPoint Bottom left quadrangle corner
      *  \param theBottomLeftPoint Bottom left quadrangle corner
-     *  \param theBottomRigthPoint Bottom right quadrangle corner
+     *  \param theBottomRightPoint Bottom right quadrangle corner
      *  \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 long        theShapeType,
                                          in GEOM_Object theTopLeftPoint,
      *  \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 long        theShapeType,
                                          in GEOM_Object theTopLeftPoint,
-                                         in GEOM_Object theTopRigthPoint,
+                                         in GEOM_Object theTopRightPoint,
                                          in GEOM_Object theBottomLeftPoint,
                                          in GEOM_Object theBottomLeftPoint,
-                                         in GEOM_Object theBottomRigthPoint,
+                                         in GEOM_Object theBottomRightPoint,
                                          in shape_state theState);
 
     /*!
                                          in shape_state theState);
 
     /*!
@@ -2468,7 +2666,8 @@ module GEOM
      *  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.
      *  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.
+     *  \return Compound which includes all found sub-shapes if they have different types; 
+     *          or group of all found shapes of the equal type; or a single found sub-shape.
      */
     GEOM_Object GetInPlace (in GEOM_Object theShapeWhere,
                             in GEOM_Object theShapeWhat);
      */
     GEOM_Object GetInPlace (in GEOM_Object theShapeWhere,
                             in GEOM_Object theShapeWhat);
@@ -2491,11 +2690,24 @@ module GEOM
      *
      *  \param theShapeWhere Shape to find sub-shapes of.
      *  \param theShapeWhat Shape, specifying what to find.
      *
      *  \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.
+     *  \return Compound which includes all found sub-shapes if they have different types; 
+     *          or group of all found shapes of the equal type; or a single found sub-shape.
      */
     GEOM_Object GetInPlaceByHistory (in GEOM_Object theShapeWhere,
                                      in GEOM_Object theShapeWhat);
 
      */
     GEOM_Object GetInPlaceByHistory (in GEOM_Object theShapeWhere,
                                      in GEOM_Object theShapeWhat);
 
+    /*!
+     *  \brief A sort of GetInPlace functionality, returning for each sub-shape ID of 
+     *  \a theShapeWhat a list of corresponding sub-shape IDs of \a theShapeWhere.
+     *  For example, if theShapeWhat is a box and theShapeWhere is this box cut into 
+     *  two parts by a plane, then the result can be as this: 
+     *    len( result_list ) = 35,
+     *    result_list[ 1 ] = [ 2, 36 ], which means that the box turned into two solids
+     *  with IDs 2 and 36 within theShapeWhere
+     */
+    ListOfListOfLong GetInPlaceMap (in GEOM_Object theShapeWhere,
+                                    in GEOM_Object theShapeWhat);
+
     /*!
      *  \brief Get sub-shape of theShapeWhere, which are
      *  coincident with \a theShapeWhat that can either SOLID, FACE, EDGE or VERTEX.
     /*!
      *  \brief Get sub-shape of theShapeWhere, which are
      *  coincident with \a theShapeWhat that can either SOLID, FACE, EDGE or VERTEX.
@@ -2516,6 +2728,53 @@ module GEOM
     ListOfLong GetSameIDs (in GEOM_Object theShapeWhere,
                            in GEOM_Object theShapeWhat);
 
     ListOfLong GetSameIDs (in GEOM_Object theShapeWhere,
                            in GEOM_Object theShapeWhat);
 
+    /*!
+     *  \brief Resize the input edge with the new Min and Max parameters.
+     *  The input edge parameters range is [0, 1]. If theMin parameter is
+     *  negative, the input edge is extended, otherwise it is shrinked by
+     *  theMin parameter. If theMax is greater than 1, the edge is extended,
+     *  otherwise it is shrinked by theMax parameter.
+     *  \param theEdge the input edge to be resized.
+     *  \param theMin the minimal parameter value.
+     *  \param theMax the maximal parameter value.
+     *  \return a newly created edge.
+     */
+    GEOM_Object ExtendEdge(in GEOM_Object theEdge,
+                           in double      theMin,
+                           in double      theMax);
+
+    /*!
+     *  \brief Resize the input face with the new UMin, UMax, VMin and VMax
+     *  parameters. The input face U and V parameters range is [0, 1]. If
+     *  theUMin parameter is negative, the input face is extended, otherwise
+     *  it is shrinked along U direction by theUMin parameter. If theUMax is
+     *  greater than 1, the face is extended, otherwise it is shrinked along
+     *  U direction by theUMax parameter. So as for theVMin, theVMax and
+     *  V direction of the input face.
+     *  \param theFace the input face to be resized.
+     *  \param theUMin the minimal U parameter value.
+     *  \param theUMax the maximal U parameter value.
+     *  \param theVMin the minimal V parameter value.
+     *  \param theVMax the maximal V parameter value.
+     *  \return a newly created face.
+     */
+    GEOM_Object ExtendFace(in GEOM_Object theFace,
+                           in double      theUMin,
+                           in double      theUMax,
+                           in double      theVMin,
+                           in double      theVMax);
+
+    /*!
+     *  \brief Make a surface from a face. This function takes some face as
+     *  input parameter and creates new GEOM_Object, i.e. topological shape
+     *  by extracting underlying surface of the source face and limiting it
+     *  by the Umin, Umax, Vmin, Vmax parameters of the source face (in the
+     *  parametrical space).
+     *  \param theFace the input face.
+     *  \return a newly created face.
+     */
+    GEOM_Object MakeSurfaceFromFace(in GEOM_Object theFace);
+
     /*!
      * \brief Explode a shape into edges sorted in a row from a starting point.
      * \param theShape - the shape to be exploded on edges.
     /*!
      * \brief Explode a shape into edges sorted in a row from a starting point.
      * \param theShape - the shape to be exploded on edges.
@@ -2525,6 +2784,63 @@ module GEOM
     ListOfGO GetSubShapeEdgeSorted (in GEOM_Object theShape,
                                     in GEOM_Object theStartPoint);
 
     ListOfGO GetSubShapeEdgeSorted (in GEOM_Object theShape,
                                     in GEOM_Object theStartPoint);
 
+    /*!
+     * \brief Return the list of subshapes that satisfies a certain tolerance
+     * criterion. The user defines the type of shapes to be returned, the
+     * condition and the tolerance value. The operation is defined for
+     * faces, edges and vertices only. E.g. for theShapeType FACE, theCondition
+     * CC_GT and theTolerance 1.e-7 this method returns all faces of theShape
+     * that have tolerances greater then 1.e7.
+     *
+     * \param theShape the shape to be exploded
+     * \param theShapeType the type of shapes to be returned. Can have the
+     *        values FACE, EDGE and VERTEX only.
+     * \param theCondition the condition type.
+     * \param theTolerance the tolerance filter.
+     * \return the list of shapes that satisfy the conditions.
+     */
+    ListOfGO GetSubShapesWithTolerance(in GEOM_Object          theShape,
+                                       in short                theShapeType,
+                                       in comparison_condition theCondition,
+                                       in double               theTolerance);
+
+    /**
+     * This enumeration represents an extraction statistics type. It is used in
+     * the interface GEOM_IShapesOperations::MakeExtraction.
+     */
+    enum ExtractionStatType
+    {
+      EST_Removed,  ///< Removed sub-shapes
+      EST_Modified, ///< Modified sub-shapes
+      EST_Added     ///< Newly created sub-shapes
+    };
+
+    /*!
+     * This structure defines a format of extraction statistics. It is used in
+     * the interface GEOM_IShapesOperations::MakeExtraction.
+     */
+    struct ExtractionStat
+    {
+      ExtractionStatType type;    ///< Type of extraction statistics.
+      ListOfLong         indices; ///< Shape indices touched by this type of modification.
+    };
+
+    typedef sequence<ExtractionStat> ExtractionStats;
+
+    /*!
+     * \brief Return the shape that is constructed from theShape without
+     * extracted sub-shapes from the input list.
+     *
+     * \param theShape the original shape.
+     * \param theSubShapeIDs the list of sub-shape IDs to be extracted from
+     *        the original shape.
+     * \param theStats the operation statistics. Output parameter.
+     * \return the shape without extracted sub-shapes.
+     */
+    GEOM_Object MakeExtraction(in GEOM_Object      theShape,
+                               in ListOfLong       theSubShapeIDs,
+                               out ExtractionStats theStats);
+
   };
 
  // # GEOM_IBlocksOperations: 
   };
 
  // # GEOM_IBlocksOperations: 
@@ -2540,7 +2856,7 @@ module GEOM
 
     /*!
      *  \brief 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.
+     *  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.
      */
      *  \param theEdge1,theEdge2,theEdge3,theEdge4 Edges for the face bound.
      *  \return New GEOM_Object, containing the created face.
      */
@@ -2575,7 +2891,7 @@ module GEOM
      *  \brief Create a hexahedral solid, bounded by the six given faces. Order of
      *  faces is not important. 
      *
      *  \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.
+     *  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.
      */
      *  \param theFace1,theFace2,theFace3,theFace4,theFace5,theFace6 Faces for the hexahedral solid.
      *  \return New GEOM_Object, containing the created solid.
      */
@@ -2770,10 +3086,14 @@ module GEOM
      *  - 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.
      *  - 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 theToleranceC1 the tolerance to check if two neighbor edges are
+     *         collinear in the common vertex with this tolerance. Negative
+     *         value means that C1 criterion is not used (old implementation).
      *  \param theErrors Structure, containing discovered errors and incriminated sub-shapes.
      *  \return TRUE, if the given shape is a compound of blocks.
      */
     boolean CheckCompoundOfBlocks (in GEOM_Object theCompound,
      *  \param theErrors Structure, containing discovered errors and incriminated sub-shapes.
      *  \return TRUE, if the given shape is a compound of blocks.
      */
     boolean CheckCompoundOfBlocks (in GEOM_Object theCompound,
+                                   in double      theToleranceC1,
                                    out BCErrors   theErrors);
 
     /*!
                                    out BCErrors   theErrors);
 
     /*!
@@ -2790,12 +3110,17 @@ module GEOM
      *  \brief Retrieve all non blocks solids and faces from a shape.
      *
      *  \param theShape The shape to explore.
      *  \brief Retrieve all non blocks solids and faces from a shape.
      *
      *  \param theShape The shape to explore.
+     *  \param theToleranceC1 the tolerance to check if two neighbor edges are
+     *         collinear in the common vertex with this tolerance. Negative
+     *         value means that C1 criterion is not used (old implementation).
      *  \param theNonQuads Output parameter. Group of all non quadrangular faces.
      *
      *  \return Group of all non block solids (= not 6 faces, or with 6
      *          faces, but with the presence of non-quadrangular faces).
      */
      *  \param theNonQuads Output parameter. Group of all non quadrangular faces.
      *
      *  \return Group of all non block solids (= not 6 faces, or with 6
      *          faces, but with the presence of non-quadrangular faces).
      */
-    GEOM_Object GetNonBlocks (in GEOM_Object theShape, out GEOM_Object theNonQuads);
+    GEOM_Object GetNonBlocks (in GEOM_Object  theShape,
+                              in double       theToleranceC1,
+                              out GEOM_Object theNonQuads);
 
     /*!
      *  \brief Remove all seam and degenerated edges from \a theShape.
 
     /*!
      *  \brief Remove all seam and degenerated edges from \a theShape.
@@ -2914,7 +3239,7 @@ module GEOM
      *
      *  Propagation group is a set of all edges, opposite to one (main)
      *  edge of this group directly or through other opposite edges.
      *
      *  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.
+     *  Notion of Opposite Edge make sense only on quadrangle face.
      *  \param theShape Shape to build propagation groups on.
      *  \return List of GEOM_Object, each of them is a propagation group.
      */
      *  \param theShape Shape to build propagation groups on.
      *  \return List of GEOM_Object, each of them is a propagation group.
      */
@@ -3013,7 +3338,7 @@ module GEOM
      *  \param theRemoveInside Shapes, inside which the results will be deleted.
      *         Each shape from theRemoveInside must belong to theShapes also.
      *  \param theRemoveWebs If TRUE, perform Glue 3D algorithm.
      *  \param theRemoveInside Shapes, inside which the results will be deleted.
      *         Each shape from theRemoveInside must belong to theShapes also.
      *  \param theRemoveWebs If TRUE, perform Glue 3D algorithm.
-     *  \param theMaterials Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
+     *  \param theMaterials Material indices for each shape. Make sense, only if theRemoveWebs is TRUE.
      *
      *  \return New GEOM_Object, containing the result shapes.
      */
      *
      *  \return New GEOM_Object, containing the result shapes.
      */
@@ -3029,7 +3354,7 @@ module GEOM
     /*!
      *  \brief Perform partition operation.
      *
     /*!
      *  \brief Perform partition operation.
      *
-     *  This method may be usefull if it is needed to make a partition for
+     *  This method may be useful 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.
      *
      *  a compound containing nonintersected shapes. Performance will be better
      *  since intersection between shapes from compound is not performed.
      *
@@ -3058,6 +3383,17 @@ module GEOM
      *  \param theShape Shape to be intersected.
      *  \param thePlane Tool shape, to intersect theShape.
      *  \return New GEOM_Object, containing the result shape.
      *  \param theShape Shape to be intersected.
      *  \param thePlane Tool shape, to intersect theShape.
      *  \return New GEOM_Object, containing the result shape.
+     * 
+     *  \note This operation is a shortcut to the more general \ref MakePartition
+     *  operation, where \a theShape specifies single "object" (shape being partitioned)
+     *  and \a thePlane specifies single "tool" (intersector shape). Other parameters of
+     *  \ref MakePartition operation have default values:
+     *  - \a theLimit: GEOM::SHAPE (shape limit corresponds to the type of \a theShape)
+     *  - \a theKeepNonlimitShapes: 0
+     *  - \a theKeepInside, \a theRemoveInside, \a theRemoveWebs,
+     *    \a theMaterials (obsolete parameters): empty
+     *
+     * \sa MakePartition, MakePartitionNonSelfIntersectedShape
      */
     GEOM_Object MakeHalfPartition (in GEOM_Object theShape,
                                    in GEOM_Object thePlane);
      */
     GEOM_Object MakeHalfPartition (in GEOM_Object theShape,
                                    in GEOM_Object thePlane);
@@ -3481,7 +3817,7 @@ module GEOM
      *  \param theVertexes Global indices of vertexes to perform fillet on.
      *    \note Global index of sub-shape can be obtained, using method
      *          <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
      *  \param theVertexes Global indices of vertexes to perform fillet on.
      *    \note Global index of sub-shape can be obtained, using method
      *          <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
-     *    \note The list of vertices coudl be empty, in this case fillet fill be done
+     *    \note The list of vertices could be empty, in this case fillet fill be done
      *          at all vertices in given wire
      *  \param doIgnoreSecantVertices If FALSE, fillet radius is always limited
      *         by the length of the edges, nearest to the fillet vertex.
      *          at all vertices in given wire
      *  \param doIgnoreSecantVertices If FALSE, fillet radius is always limited
      *         by the length of the edges, nearest to the fillet vertex.
@@ -3520,7 +3856,7 @@ module GEOM
                                  in double theD1, in double theD2,
                                  in long theFace1, in long theFace2);
     /*!
                                  in double theD1, in double theD2,
                                  in long theFace1, in long theFace2);
     /*!
-     *  \brief The Same but with params theD = Chamfer Lenght
+     *  \brief The Same but with params theD = Chamfer Length
      *  and theAngle = Chamfer Angle (Angle in radians)
      */
     GEOM_Object MakeChamferEdgeAD (in GEOM_Object theShape,
      *  and theAngle = Chamfer Angle (Angle in radians)
      */
     GEOM_Object MakeChamferEdgeAD (in GEOM_Object theShape,
@@ -3544,7 +3880,7 @@ module GEOM
                                   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
+     *  The Same but with params theD = Chamfer Length
      *  and theAngle = Chamfer Angle (Angle in radians)
      */
     GEOM_Object MakeChamferFacesAD (in GEOM_Object theShape,
      *  and theAngle = Chamfer Angle (Angle in radians)
      */
     GEOM_Object MakeChamferFacesAD (in GEOM_Object theShape,
@@ -3563,7 +3899,7 @@ module GEOM
                                   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
+     *  The Same but with params theD = Chamfer Length
      *  and theAngle = Chamfer Angle (Angle in radians)
      */
     GEOM_Object MakeChamferEdgesAD (in GEOM_Object theShape,
      *  and theAngle = Chamfer Angle (Angle in radians)
      */
     GEOM_Object MakeChamferEdgesAD (in GEOM_Object theShape,
@@ -3685,30 +4021,30 @@ module GEOM
 
     /*!
      *  Sewing of the given object.
 
     /*!
      *  Sewing of the given object.
-     *  \param theObject Shape to be processed.
+     *  \param theObjects Shapes to be processed.
      *  \param theTolerance Required tolerance value.
      *  \return New GEOM_Object, containing processed shape.
      */
      *  \param theTolerance Required tolerance value.
      *  \return New GEOM_Object, containing processed shape.
      */
-    GEOM_Object Sew (in GEOM_Object theObject, in double theTolerance);
+    GEOM_Object Sew (in ListOfGO theObjects, in double theTolerance);
 
     /*!
      *  Sewing of the given object. Allows non-manifold sewing.
 
     /*!
      *  Sewing of the given object. Allows non-manifold sewing.
-     *  \param theObject Shape to be processed.
+     *  \param theObjects Shapes to be processed.
      *  \param theTolerance Required tolerance value.
      *  \return New GEOM_Object, containing processed shape.
      */
      *  \param theTolerance Required tolerance value.
      *  \return New GEOM_Object, containing processed shape.
      */
-    GEOM_Object SewAllowNonManifold(in GEOM_Object theObject, in double theTolerance);
+    GEOM_Object SewAllowNonManifold(in ListOfGO theObjects, in double theTolerance);
 
     /*!
 
     /*!
-     *  Rebuild the topology of theCompound of solids by removing
-     *  of the faces that are shared by several solids.
-     *  \param theCompound Shape to be processed.
+     *  Rebuild the topology of theSolids by removing
+     *  the faces that are shared by several solids.
+     *  \param theSolids A list of shapes containing solids to be processed.
      *  \return New GEOM_Object, containing processed shape.
      */
      *  \return New GEOM_Object, containing processed shape.
      */
-    GEOM_Object RemoveInternalFaces (in GEOM_Object theCompound);
+    GEOM_Object RemoveInternalFaces (in ListOfGO theSolids);
 
     /*!
 
     /*!
-     *  \brief Addition of a point to a given edge object.
+     *  \brief Addition of a point to a given edge of \a theObject.
      *  \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.
      *  \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.
@@ -3716,11 +4052,24 @@ module GEOM
      *                  depending on \a isByParameter.
      *  \param isByParameter If TRUE : \a theValue is treated as a curve parameter [0..1],
      *                       if FALSE : \a theValue is treated as a length parameter [0..1]
      *                  depending on \a isByParameter.
      *  \param isByParameter If TRUE : \a theValue is treated as a curve parameter [0..1],
      *                       if FALSE : \a theValue is treated as a length parameter [0..1]
-     *  \return New GEOM_Object, containing processed shape.
+     *  \return New GEOM_Object, containing the processed shape.
      */
     GEOM_Object DivideEdge (in GEOM_Object theObject, in short theEdgeIndex,
                             in double theValue, in boolean isByParameter);
 
      */
     GEOM_Object DivideEdge (in GEOM_Object theObject, in short theEdgeIndex,
                             in double theValue, in boolean isByParameter);
 
+    /*!
+     *  \brief Addition of points to a given edge of \a theObject by projecting
+     *         other points to the given edge.
+     *  \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.
+     *  \param thePoints Points to project to theEdgeIndex-th edge.
+     *  \return New GEOM_Object, containing the processed shape.
+     */
+    GEOM_Object DivideEdgeByPoint (in GEOM_Object theObject,
+                                   in short       theEdgeIndex,
+                                   in ListOfGO    thePoints);
+
     /*!
      *  \brief Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
      *  \param theWire Wire to minimize the number of C1 continuous edges in.
     /*!
      *  \brief Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
      *  \param theWire Wire to minimize the number of C1 continuous edges in.
@@ -3733,13 +4082,13 @@ module GEOM
 
     /*!
      *  \brief 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.
+     *  that constitute a free boundary of the given shapes.
+     *  \param theObjects Shapes to get free boundary of.
      *  \param theClosedWires Output. Closed wires on the free boundary of the given shape.
      *  \param theOpenWires Output. Open wires on the free boundary of the given shape.
      *  \param theClosedWires Output. Closed wires on the free boundary of the given shape.
      *  \param theOpenWires Output. Open wires on the free boundary of the given shape.
-     *  \return FALSE, if an error(s) occured during the method execution.
+     *  \return FALSE, if an error(s) occurred during the method execution.
      */
      */
-    boolean GetFreeBoundary (in GEOM_Object theObject,
+    boolean GetFreeBoundary (in  ListOfGO theObjects,
                              out ListOfGO theClosedWires,
                              out ListOfGO theOpenWires);
 
                              out ListOfGO theClosedWires,
                              out ListOfGO theOpenWires);
 
@@ -3759,6 +4108,12 @@ module GEOM
      */
     GEOM_Object LimitTolerance (in GEOM_Object theObject, in double theTolerance);
 
      */
     GEOM_Object LimitTolerance (in GEOM_Object theObject, in double theTolerance);
 
+
+    /*!
+     *  \brief Return information on what has been done by the last called healing method.
+     *  \return ModifStatistics, information container.
+     */
+    ModifStatistics GetStatistics();
   };
 
  // # GEOM_IInsertOperations:
   };
 
  // # GEOM_IInsertOperations:
@@ -3774,8 +4129,8 @@ module GEOM
     GEOM_Object MakeCopy (in GEOM_Object theOriginal);
 
     /*!
     GEOM_Object MakeCopy (in GEOM_Object theOriginal);
 
     /*!
-     *  \brief Deprecated method. Use Export<FormatName> (from the
-     *  corresponding plugin) instead; here <FormatName> is a name of format.
+     *  \brief Deprecated method. Use Export\<FormatName\> (from the
+     *  corresponding plugin) instead; here \<FormatName\> is a name of format.
      *
      *  \brief Export the given shape into a file with given name.
      *  \param theObject Shape to be stored in the file.
      *
      *  \brief Export the given shape into a file with given name.
      *  \param theObject Shape to be stored in the file.
@@ -3785,8 +4140,8 @@ module GEOM
     void Export (in GEOM_Object theObject, in string theFileName, in string theFormatName);
 
     /*!
     void Export (in GEOM_Object theObject, in string theFileName, in string theFormatName);
 
     /*!
-     *  \brief Deprecated method. Use Import<FormatName> (from the
-     *  corresponding plugin) instead; here <FormatName> is a name of format.
+     *  \brief Deprecated method. Use Import\<FormatName\> (from the
+     *  corresponding plugin) instead; here \<FormatName\> is a name of format.
      *
      *  \brief Import a shape from the STL, BREP, IGES or STEP file
      *  (depends on given format) with given name.
      *
      *  \brief Import a shape from the STL, BREP, IGES or STEP file
      *  (depends on given format) with given name.
@@ -3845,11 +4200,45 @@ module GEOM
     SALOMEDS::TMPFile GetTexture(in long theID, out long theWidth, out long theHeight);
 
     /*!
     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
+     * \brief Get list of all available texture IDs
+     * \return list of all texture IDs available for the current study
      */
     ListOfLong GetAllTextures();
      */
     ListOfLong GetAllTextures();
-    
+
+    /*!
+     *  \brief Non-topological information transfer datum.
+     */
+    struct TransferDatum
+    {
+      string myName;
+      long   myNumber;
+      long   myMaxNumber;
+    };
+
+    /*!
+     *  \brief Sequence of non-topological information transfer data.
+     */
+    typedef sequence<TransferDatum> ListOfTransferDatum;
+
+    /*!
+     *  \brief Transfer non-topological data from one object to another
+     *  \param theObjectFrom the source object of non-topological data
+     *  \param theObjectTo the destination object of non-topological data
+     *  \param theFindMethod method to search sub-shapes of theObjectFrom
+     *         in shape theObjectTo. Possible values are: GEOM::FSM_GetInPlace,
+     *         GEOM::FSM_GetInPlaceByHistory and GEOM::FSM_GetInPlace_Old.
+     *         Other values of GEOM::find_shape_method are not supported.
+     *  \param theResult statistics of the operation. Output parameter. It
+     *         represents a sequence of Transfer Datum. A datum has the type
+     *         (string code), the total number of items of this type and
+     *         the number of transferred items.
+     *  \return true in case of success; otherwise false.
+     */
+    boolean TransferData(in  GEOM_Object         theObjectFrom,
+                         in  GEOM_Object         theObjectTo,
+                         in  find_shape_method   theFindMethod,
+                         out ListOfTransferDatum theResult);
+
   };
 
  // # GEOM_IKindOfShape:
   };
 
  // # GEOM_IKindOfShape:
@@ -3916,11 +4305,20 @@ module GEOM
       LINE,         
       /*! segment */
       SEGMENT,      
       LINE,         
       /*! segment */
       SEGMENT,      
+      /*! B-Spline curve */
+      CRV_BSPLINE,  
+      /*! Bezier curve */
+      CRV_BEZIER,  
+      /*! hyperbola */
+      HYPERBOLA,  
+      /*! parabola */
+      PARABOLA,  
       /*! other edge */
       EDGE,       
       // VERTEX
       VERTEX,
       // ADVANCED shapes
       /*! other edge */
       EDGE,       
       // VERTEX
       VERTEX,
       // ADVANCED shapes
+      LCS,
       /*! all advanced shapes (temporary implementation) */
       ADVANCED    
     };
       /*! all advanced shapes (temporary implementation) */
       ADVANCED    
     };
@@ -3969,12 +4367,14 @@ module GEOM
      *  \brief Get summarized length of all wires,
      *  area of surface and volume of the given shape.
      *  \param theShape Shape to define properties of.
      *  \brief Get summarized length of all wires,
      *  area of surface and volume of the given shape.
      *  \param theShape Shape to define properties of.
+     *  \param theTolerance maximal relative error of area and volume computation.
      *  \param theLength Output. Summarized length of all wires of the given shape.
      *  \param theSurfArea Output. Area of surface of the given shape.
      *  \param theVolume Output. Volume of the given shape.
      *  \return Returns shape properties through the last three arguments.
      */
     void GetBasicProperties (in GEOM_Object theShape,
      *  \param theLength Output. Summarized length of all wires of the given shape.
      *  \param theSurfArea Output. Area of surface of the given shape.
      *  \param theVolume Output. Volume of the given shape.
      *  \return Returns shape properties through the last three arguments.
      */
     void GetBasicProperties (in GEOM_Object theShape,
+                             in double theTolerance,
                              out double theLength,
                              out double theSurfArea,
                              out double theVolume);
                              out double theLength,
                              out double theSurfArea,
                              out double theVolume);
@@ -3987,12 +4387,13 @@ module GEOM
     GEOM_Object GetCentreOfMass (in GEOM_Object theShape);
 
     /*
     GEOM_Object GetCentreOfMass (in GEOM_Object theShape);
 
     /*
-     *  Get the vertex by index for 1D objects depends the edge/wire orientation
+     *  Get the vertex by index for 1D objects
      *  \param theShape Shape (wire or edge) to find the vertex on it
      *  \param theIndex Index of vertex sub-shape
      *  \param theShape Shape (wire or edge) to find the vertex on it
      *  \param theIndex Index of vertex sub-shape
+     *  \param theUseOri To consider edge/wire orientation or not
      *  \return New GEOM_Object, vertex.
      */
      *  \return New GEOM_Object, vertex.
      */
-    GEOM_Object GetVertexByIndex( in GEOM_Object theShape, in long index );
+    GEOM_Object GetVertexByIndex( in GEOM_Object theShape, in long theIndex, in boolean theUseOri );
 
     /*!
      *  \brief Get a vector, representing the normal of theFace.
 
     /*!
      *  \brief Get a vector, representing the normal of theFace.
@@ -4157,12 +4558,57 @@ module GEOM
     /*!
      *  \brief Check a topology of the given shape on self-intersections presence.
      *  \param theShape Shape to check validity of.
     /*!
      *  \brief Check a topology of the given shape on self-intersections presence.
      *  \param theShape Shape to check validity of.
+     *  \param theCheckLevel the level of self-interference check.
      *  \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,
      *  \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,
+                                    in long        theCheckLevel,
                                     out ListOfLong theIntersections);
 
                                     out ListOfLong theIntersections);
 
+    /*!
+     *  \brief Detect self-intersections of the given shape with algorithm based on mesh intersections.
+     *  \param theShape Shape to check validity of.
+     *  \param theDeflection Linear deflection coefficient that specifies quality of tessellation.
+     *  \param theTolerance Specifies a distance between sub-shapes used for detecting gaps:
+     *                       - if \a theTolerance <= 0, algorithm detects intersections
+     *                       - if \a theTolerance > 0, algorithm detects gaps
+     *  \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 CheckSelfIntersectionsFast (in GEOM_Object theShape,
+                                       in float       theDeflection,
+                                       in double      theTolerance,
+                                       out ListOfLong theIntersections);
+
+    /*!
+     *  \brief Check boolean and partition operations arguments.
+     *  \param theShape the argument of an operation to be checked.
+     *  \return TRUE if the argument is valid for a boolean or partition
+     *          operation; FALSE otherwise.
+     */
+    boolean CheckBOPArguments (in GEOM_Object theShape);
+
+    /*!
+     *  \brief Detect intersections of the given shapes with algorithm based on mesh intersections.
+     *  \param theShape1 First source object
+     *  \param theShape2 Second source object
+     *  \param theTolerance Specifies a distance between shapes used for detecting gaps:
+     *                       - if \a theTolerance <= 0, algorithm detects intersections
+     *                       - if \a theTolerance > 0, algorithm detects gaps
+     *  \param theDeflection Linear deflection coefficient that specifies quality of tessellation:
+     *                       - if \a theDeflection <= 0, default deflection 0.001 is used
+     *  \param theIntersections1 Output: contains list of sub-shapes IDs from 1st shape that localize intersection
+     *  \param theIntersections2 Output: contains list of sub-shapes IDs from 2nd shape that localize intersection
+     *  \return TRUE, if the are intersections (gaps) between source shapes
+     */
+    boolean FastIntersect (in GEOM_Object theShape1,
+                          in GEOM_Object theShape2,
+                          in double      theTolerance,
+                          in float       theDeflection,
+                          out ListOfLong theIntersections1,
+                          out ListOfLong theIntersections2);
+
     /*!
      *  \brief Check if the given shape can be an argument for MakeSolid operation
      *  \param theShape Shape to be described.
     /*!
      *  \brief Check if the given shape can be an argument for MakeSolid operation
      *  \param theShape Shape to be described.
@@ -4222,6 +4668,16 @@ module GEOM
      */
     double GetAngleBtwVectors (in GEOM_Object theShape1, in GEOM_Object theShape2);
 
      */
     double GetAngleBtwVectors (in GEOM_Object theShape1, in GEOM_Object theShape2);
 
+    /*!
+     *  \brief The function takes a single face with holes and returns a list of faces,
+     *  first of them is the original face without holes, and the other faces are placed
+     *  on the same surface as the original face but bounded by each hole wire.
+     *  If the original face has no holes, it will be returned as an output
+     *  \param theShape face, to perform operation.
+     *  \return ListOfGO, containing the result original face and faces from holes.
+     */
+    ListOfGO PatchFace(in GEOM_Object theShape);
+
     /*!
      *  \brief Get point coordinates
      */
     /*!
      *  \brief Get point coordinates
      */
@@ -4279,6 +4735,172 @@ module GEOM
      */
     double MinSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
 
      */
     double MinSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
 
+    /*!
+     *  \brief Get vector of curvature of surface in the given point along the given direction.
+     *  \param theShape - face.
+     *  \param thePoint - point.
+     *  \param theDirection - direction.
+     *  \note  Before the calculation of curvature, the point and the direction
+     *         are projected to the face, if the point does not lay on it or
+     *         the direction is not tangent to it initially.
+     *  \return Vector of curvature. The returned vector is codirectional with
+     *          the normal to the face in the given point in case of positive
+     *          curvature value and opposite to the normal in case of negative
+     *          curvature. The normal of the returned vector is equal to the
+     *          absolute value of the curvature.
+     */
+    GEOM_Object SurfaceCurvatureByPointAndDirection (in GEOM_Object theShape,
+                                                     in GEOM_Object thePoint,
+                                                     in GEOM_Object theDirection);
+
+    /*!
+     *  \brief Convert X,Y,Z points coordinates to UV parameters on the given surface.
+        \param theSurf the given face. It can be also a shell or a compound with one face.
+        \param theXYZlist float list of size 3*N where N is the number of points
+                          for which we want their U,V coordinates.
+                          If the user enters a list of size not divisible by 3
+                          an exception will be thrown.
+        \param theIsNormalized if True, the returned parameters will be in range [0, 1].
+        \return list of float of size 2*N.
+     */
+    ListOfDouble XYZtoUV(in GEOM_Object  theSurf,
+                         in ListOfDouble theXYZlist,
+                         in boolean      theIsNormalized);
+
+    /*!
+     *  \brief Convert UV parameters on the given surface to 3D points coordinates.
+        \param theSurf the given face. It can be also a shell or a compound with one face.
+        \param theUVlist float list of size 2*N where N is the number of points
+                         for which we want their X,Y,Z coordinates.
+                         If the user enters a list of non-even size
+                         an exception will be thrown.
+        \param theIsNormalized if True, the input parameters are expected to be in range [0, 1].
+        \return list of float of size 3*N.
+     */
+    ListOfDouble UVtoXYZ(in GEOM_Object  theSurf,
+                         in ListOfDouble theUVlist,
+                         in boolean      theIsNormalized);
+
+    //! Methods and structure for implement CheckConformity tool
+
+    /*!
+    *  \brief Structure for store shapes from failed checks.
+    *         If failed check on small edges, then second shape is null
+    */
+    struct PairOfShape
+    {
+      GEOM_Object first;
+      GEOM_Object second;
+    };
+
+    /*!
+    *  \brief Structure for store result of check
+    *  store type of check as number and failed shapes
+    */
+    struct CheckResult
+    {
+      long  type;
+      PairOfShape failedShapes;
+    };
+
+    typedef sequence<PairOfShape> SequenceOfPairOfShape;
+    typedef sequence<CheckResult> CheckResults;
+
+    /*!
+    *  \brief Perform analyse of shape and return all failed checks.
+    *
+    *  \param theShape Shape for check.
+    */
+    CheckResults CheckConformityShape(in GEOM_Object theShape);
+
+    /*!
+    *  \brief Find all self-intersected 2D curves.
+    *
+    *  \param theResults result of check - list of failed checks and sub-shapes.
+    */
+    SequenceOfPairOfShape SelfIntersected2D(in CheckResults theResults);
+
+    /*!
+    *  \brief Find pairs of interfering sub-shapes, by default all pairs of interfering shapes are returned.
+    *         Avaliable types:
+    *         - vertices touched by tolerance;
+    *         - vertex touching an edge in the inner point;
+    *         - vertex lying on the inner point of a face;
+    *         - edges intersecting by inner points;
+    *         - edge touching/intersecting face in the inner point;
+    *         - faces intersection by inner point
+    * 
+    *  \param theResults result of check - list of failed checks and sub-shapes.
+    *  \param theShapeType1 Type of shape.
+    *  \param theShapeType2 Type of shape.
+    */
+    SequenceOfPairOfShape InterferingSubshapes(in CheckResults theResults,
+                                               in long theShapeType1,
+                                               in long theShapeType2);
+
+    /*!
+    *  \brief Find edges, which are fully covered by tolerances of vertices.
+    *
+    *  \param theResults result of check - list of failed checks and sub-shapes.
+    */
+    ListOfGO SmallEdges(in CheckResults theResults);
+
+    /*!
+    *  \brief find remote objects (sub-shape on a shape).
+    *         Avaliable types:
+    *         - vertex far from edge;
+    *         - vertex far from face;
+    *         - edge far from face
+    *
+    *  \param theResults result of check - list of failed checks and sub-shapes.
+    *  \param theShapeType Type of shape.
+    *  \param theSubShapeType Type of sub-shape.
+    *  \param theTolerance tolerance, by default used tolerance of sub-shape.
+    */
+    SequenceOfPairOfShape DistantShapes(in CheckResults theResults,
+                                        in long theShapeType,
+                                        in long theSubShapeType,
+                                        in double theTolerance);
+
+    /*!
+    *  \brief Compute possible tolerance for the shape, minimize tolerance of shape as well
+    *         as tolerance of sub-shapes as much as possible
+    *
+    *  \param theShape Shape for update.
+    */
+    double UpdateTolerance(in GEOM_Object theShape);
+
+    /*!
+     *  \brief Get the calculator for the proximity value between the given shapes.
+     *  \param theShape1,theShape2 Shapes to find proximity.
+     *  \return The calculator object.
+     */
+    GEOM_Object ShapeProximityCalculator(in GEOM_Object theShape1, in GEOM_Object theShape2);
+
+    /*!
+     *  \brief Set number sample points to compute the coarse proximity.
+     *  \param theCalculator Proximity calculator.
+     *  \param theShape      Shape to be samples.
+     *  \param theNbSamples  Number of samples points.
+     */
+    void SetShapeSampling(in GEOM_Object theCalculator,
+                          in GEOM_Object theShape,
+                          in long theNbSamples);
+
+    /*!
+     *  \brief Compute coarse value of the proximity basing on the polygonal representation of shapes.
+     *  \param theCalculator Proximity calculator.
+     *  \return Proximity value.
+     */
+    double GetCoarseProximity(in GEOM_Object theCalculator);
+
+    /*!
+     *  \brief Compute precise value of the proximity basing on the exact shapes.
+     *  \param theCalculator Proximity calculator.
+     *  \return Proximity value.
+     */
+    double GetPreciseProximity(in GEOM_Object theCalculator);
+
   };
 
  // # GEOM_IGroupOperations:
   };
 
  // # GEOM_IGroupOperations:
@@ -4288,7 +4910,7 @@ module GEOM
   interface GEOM_IGroupOperations : GEOM_IOperations
   {
     /*!
   interface GEOM_IGroupOperations : GEOM_IOperations
   {
     /*!
-     *  \brief Creates a new group which will store  sub-shapes of theMainShape
+     *  \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
      *  \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
@@ -4312,7 +4934,7 @@ module GEOM
     void RemoveObject (in GEOM_Object theGroup, in long theSubShapeId);
 
     /*!
     void RemoveObject (in GEOM_Object theGroup, in long theSubShapeId);
 
     /*!
-     *  \brief Adds to the group all the given shapes. No errors, if some shapes are alredy included.
+     *  \brief Adds to the group all the given shapes. No errors, if some shapes are already 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.
      */
      *  \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.
      */
@@ -4326,7 +4948,7 @@ module GEOM
     void DifferenceList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
 
     /*!
     void DifferenceList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
 
     /*!
-     *  \brief Adds to the group all the given shapes. No errors, if some shapes are alredy included.
+     *  \brief Adds to the group all the given shapes. No errors, if some shapes are already 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.
      */
      *  \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.
      */
@@ -4453,7 +5075,67 @@ module GEOM
     long GetNbSubShapes(in GEOM_Object shape, in short fieldDim);
   };
 
     long GetNbSubShapes(in GEOM_Object shape, in short fieldDim);
   };
 
- // # GEOM_Gen:
+  // # GEOM_ITestOperations:
+  /*!
+   *  \brief Interface for testing operations.
+   */
+  interface GEOM_ITestOperations : GEOM_IOperations
+  {
+    /*!
+     *  \brief Build a mesh on the given shape.
+     *  \param shape is a source object
+     *  \param linearDeflection is a linear deflection
+     *  \param isRelative says if given value of deflection is relative to shape's bounding box
+     *  \param angularDeflection is an angular deflection for edges in radians
+     *  \return true in case of success; otherwise false.
+     */
+    boolean Tesselate(in GEOM_Object shape, in double linearDeflection,
+                      in boolean isRelative, in double angularDeflection);
+  };
+
+  // # GEOM_ICanonicalRecognition:
+  /*!
+   *  \brief Interface for canonical recognition operations.
+   */
+  interface GEOM_ICanonicalRecognition : GEOM_IOperations
+  {
+    /*!
+     * check if the shape is planar
+     */
+    boolean isPlane(in GEOM_Object shape, in double tolerance, inout ListOfDouble normal, inout ListOfDouble origin);
+
+    /*!
+     * check if shape is spherical
+     */
+    boolean isSphere(in GEOM_Object shape, in double tolerance, inout ListOfDouble origin, inout double radius);
+
+    /*!
+     * check if shape is conical
+     */
+    boolean isCone(in GEOM_Object shape, in double tolerance, inout ListOfDouble axis, inout ListOfDouble apex, inout double halfAngle);
+
+    /*!
+     * check if shape is cylinder
+     */
+    boolean isCylinder(in GEOM_Object shape, in double tolerance, inout ListOfDouble axis, inout ListOfDouble origin, inout double radius);
+
+    /*!
+     * check if edge / wire is line
+     */
+    boolean isLine(in GEOM_Object edge, in double tolerance, inout ListOfDouble direction, inout ListOfDouble origin);
+
+    /*!
+     * check if edge / wire is circle
+     */
+    boolean isCircle(in GEOM_Object edge, in double tolerance, inout ListOfDouble normal, inout ListOfDouble origin, inout double radius);
+
+    /*!
+     * check if edge / wire is ellipse
+     */
+    boolean isEllipse(in GEOM_Object edge, in double tolerance, inout ListOfDouble normal, inout ListOfDouble dirX, inout ListOfDouble origin, inout double majorRadius, inout double minorRadius);
+  };
+
+  // # GEOM_Gen:
   /*!
    *  \brief Interface to access other GEOM interfaces.
    *
   /*!
    *  \brief Interface to access other GEOM interfaces.
    *
@@ -4465,9 +5147,9 @@ module GEOM
      *  \brief Undo/Redo Management
      */
 
      *  \brief Undo/Redo Management
      */
 
-    void Undo (in long theStudyID);
+    void Undo ();
 
 
-    void Redo (in long theStudyID);
+    void Redo ();
 
     /*!
      * \brief Publishing management
 
     /*!
      * \brief Publishing management
@@ -4476,8 +5158,7 @@ module GEOM
      * if theFather is not NULL the object is placed under thFather's SObject.
      * Returns a SObject where theObject is placed
      */
      * 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_BaseObject theObject,
+    SALOMEDS::SObject AddInStudy (in GEOM_BaseObject theObject,
                                   in string          theName,
                                   in GEOM_BaseObject theFather);
 
                                   in string          theName,
                                   in GEOM_BaseObject theFather);
 
@@ -4485,8 +5166,6 @@ module GEOM
      *  \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)
      *  \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 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
@@ -4497,7 +5176,7 @@ module GEOM
      *                            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
      *                            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
+     *                            useful 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.
      *                            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.
@@ -4505,8 +5184,7 @@ module GEOM
      *                      and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
      *  \return list of published 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,
+    ListOfGO RestoreSubShapesO (in GEOM_Object       theObject,
                                 in ListOfGO          theArgs,
                                 in find_shape_method theFindMethod,
                                 in boolean           theInheritFirstArg,
                                 in ListOfGO          theArgs,
                                 in find_shape_method theFindMethod,
                                 in boolean           theInheritFirstArg,
@@ -4516,8 +5194,6 @@ module GEOM
      *  \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)
      *  \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 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
@@ -4528,7 +5204,7 @@ module GEOM
      *                            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
      *                            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
+     *                            useful 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.
      *                            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.
@@ -4536,8 +5212,7 @@ module GEOM
      *                      and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
      *  \return list of published 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,
+    ListOfGO RestoreGivenSubShapesO (in GEOM_Object       theObject,
                                      in ListOfGO          theArgs,
                                      in find_shape_method theFindMethod,
                                      in boolean           theInheritFirstArg,
                                      in ListOfGO          theArgs,
                                      in find_shape_method theFindMethod,
                                      in boolean           theInheritFirstArg,
@@ -4548,8 +5223,6 @@ module GEOM
      *
      *  To be used from GUI and from geompy.addToStudy.
      *  Work like the above method, but accepts study object theSObject instead of GEOM_Object.
      *
      *  To be used from GUI and from geompy.addToStudy.
      *  Work like the above method, but accepts study object theSObject instead of GEOM_Object.
-     *  \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 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
@@ -4560,15 +5233,14 @@ module GEOM
      *                            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
      *                            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
+     *                            useful 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.
      */
      *                            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,
+    ListOfGO RestoreSubShapesSO (in SALOMEDS::SObject theSObject,
                                  in ListOfGO          theArgs,
                                  in find_shape_method theFindMethod,
                                  in boolean           theInheritFirstArg,
                                  in ListOfGO          theArgs,
                                  in find_shape_method theFindMethod,
                                  in boolean           theInheritFirstArg,
@@ -4576,22 +5248,23 @@ module GEOM
 
     // #  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_IShapesOperations    GetIShapesOperations   (in long theStudyID) raises (SALOME::SALOME_Exception);
-    GEOM_IBooleanOperations   GetIBooleanOperations  (in long theStudyID) raises (SALOME::SALOME_Exception);
-    GEOM_ICurvesOperations    GetICurvesOperations   (in long theStudyID) raises (SALOME::SALOME_Exception);
-    GEOM_ILocalOperations     GetILocalOperations    (in long theStudyID) raises (SALOME::SALOME_Exception);
-    GEOM_IHealingOperations   GetIHealingOperations  (in long theStudyID) raises (SALOME::SALOME_Exception);
-    GEOM_IInsertOperations    GetIInsertOperations   (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_IFieldOperations     GetIFieldOperations    (in long theStudyID) raises (SALOME::SALOME_Exception);
-
-    GEOM_IOperations GetPluginOperations (in long   theStudyID,
-                                          in string theLibName) raises (SALOME::SALOME_Exception);
+    GEOM_IBasicOperations      GetIBasicOperations     () raises (SALOME::SALOME_Exception);
+    GEOM_ITransformOperations  GetITransformOperations () raises (SALOME::SALOME_Exception);
+    GEOM_I3DPrimOperations     GetI3DPrimOperations    () raises (SALOME::SALOME_Exception);
+    GEOM_IShapesOperations     GetIShapesOperations    () raises (SALOME::SALOME_Exception);
+    GEOM_IBooleanOperations    GetIBooleanOperations   () raises (SALOME::SALOME_Exception);
+    GEOM_ICurvesOperations     GetICurvesOperations    () raises (SALOME::SALOME_Exception);
+    GEOM_ILocalOperations      GetILocalOperations     () raises (SALOME::SALOME_Exception);
+    GEOM_IHealingOperations    GetIHealingOperations   () raises (SALOME::SALOME_Exception);
+    GEOM_IInsertOperations     GetIInsertOperations    () raises (SALOME::SALOME_Exception);
+    GEOM_IMeasureOperations    GetIMeasureOperations   () raises (SALOME::SALOME_Exception);
+    GEOM_IBlocksOperations     GetIBlocksOperations    () raises (SALOME::SALOME_Exception);
+    GEOM_IGroupOperations      GetIGroupOperations     () raises (SALOME::SALOME_Exception);
+    GEOM_IFieldOperations      GetIFieldOperations     () raises (SALOME::SALOME_Exception);
+    GEOM_ITestOperations       GetITestOperations      () raises (SALOME::SALOME_Exception);
+    GEOM_ICanonicalRecognition GetICanonicalRecognition() raises (SALOME::SALOME_Exception);
+
+    GEOM_IOperations GetPluginOperations (in string theLibName) raises (SALOME::SALOME_Exception);
 
     // # Objects Management
 
 
     // # Objects Management
 
@@ -4604,11 +5277,10 @@ module GEOM
 
     /*!
      *  \brief 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_BaseObject GetObject (in long theStudyID, in string theEntry);
+    GEOM_BaseObject GetObject (in string theEntry);
 
     /*!
      *  \brief Add a sub-shape defined by indices in \a theIndices
 
     /*!
      *  \brief Add a sub-shape defined by indices in \a theIndices
@@ -4623,7 +5295,7 @@ module GEOM
     
     /*!
      *  \brief Returns a GEOM_Object defined by its IOR
     
     /*!
      *  \brief Returns a GEOM_Object defined by its IOR
-     *  \param theIOR a string containg an IOR of the requested GEOM_Object
+     *  \param theIOR a string containing an IOR of the requested GEOM_Object
      */
     GEOM_Object GetIORFromString (in string theIOR);
 
      */
     GEOM_Object GetIORFromString (in string theIOR);
 
@@ -4647,11 +5319,9 @@ module GEOM
 
     /*!
      *  \brief Publishes the named sub-shapes 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 sub-shapes are published
      */
      *  \param theObject   The object which named sub-shapes are published
      */
-    ListOfGO PublishNamedShapesInStudy(in SALOMEDS::Study theStudy,
-                                       //in SObject theSObject,
+    ListOfGO PublishNamedShapesInStudy(//in SObject theSObject,
                                        in Object theObject);
 
     /*!
                                        in Object theObject);
 
     /*!
@@ -4704,32 +5374,33 @@ module GEOM
 
     /*!
      * \brief Collects dependencies of the given objects from other ones
 
     /*!
      * \brief Collects dependencies of the given objects from other ones
-     * \param theStudy The study in which the object is published
      * \param theListOfEntries List of GEOM object entries in OCAF tree (not in study)
      * \return Struct of dependent entries and its links as a byte array
      * \note This method is supposed to be used by GUI only.
      */
      * \param theListOfEntries List of GEOM object entries in OCAF tree (not in study)
      * \return Struct of dependent entries and its links as a byte array
      * \note This method is supposed to be used by GUI only.
      */
-    SALOMEDS::TMPFile GetDependencyTree(in SALOMEDS::Study theStudy,
-                                       in string_array theListOfEntries);
+    SALOMEDS::TMPFile GetDependencyTree(in string_array theListOfEntries);
 
     /*!
      * \brief Fills 3 lists that is used to reduce study of redundant objects:
      *  - dependencies of the given objects from other ones;
      *  - children of the given objects;
      *  - all other objects in study.
 
     /*!
      * \brief Fills 3 lists that is used to reduce study of redundant objects:
      *  - dependencies of the given objects from other ones;
      *  - children of the given objects;
      *  - all other objects in study.
-     * \param theStudy The study in which the object was published
      * \param theSelectedEntries List of GEOM object entries in OCAF tree
      * \param theParentEntries List of GEOM object entries on which the given objects depend
      * \param theSubEntries Children entries list of the given objects
      * \param theOtherEntries List of GEOM object entries which are in the study, but not in parents and children lists
      * \note This method is supposed to be used by GUI only.
      */
      * \param theSelectedEntries List of GEOM object entries in OCAF tree
      * \param theParentEntries List of GEOM object entries on which the given objects depend
      * \param theSubEntries Children entries list of the given objects
      * \param theOtherEntries List of GEOM object entries which are in the study, but not in parents and children lists
      * \note This method is supposed to be used by GUI only.
      */
-    void GetEntriesToReduceStudy(in SALOMEDS::Study theStudy,
-                                inout string_array theSelectedEntries,
-                                inout string_array theParentEntries,
-                                inout string_array theSubEntries,
-                                inout string_array theOtherEntries);
+    void GetEntriesToReduceStudy(inout string_array theSelectedEntries,
+                                                inout string_array theParentEntries,
+                                                inout string_array theSubEntries,
+                                                inout string_array theOtherEntries);
+
 
 
+    /*
+    * \brief Breaks links to parametrical mode for parametrical shape
+    */
+    void BreakLink(in string theEntry);
   };
 };
 
   };
 };