GEOM_Gen.idl

Go to the documentation of this file.

// Copyright (C) 2007-2025  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
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//  File   : GEOM_Gen.idl
//  Author : Sergey RUIN
 
#ifndef __GEOM_GEN__
#define __GEOM_GEN__
 
#include "SALOME_Exception.idl"
#include "SALOME_Component.idl"
#include "SALOMEDS.idl"
#include "SALOMEDS_Attributes.idl"
 
#include "SALOME_GenericObj.idl"
 
module GEOM
{
  enum shape_type 
  { 
    COMPOUND,
    COMPSOLID, 
    SOLID, 
    SHELL,
    FACE, 
    WIRE, 
    EDGE, 
    VERTEX,
    SHAPE,
    FLAT
    };
 
  enum marker_type { MT_NONE, MT_POINT, MT_PLUS, MT_STAR, MT_X, MT_O, MT_O_POINT, MT_O_PLUS,
                     MT_O_STAR, MT_O_X, MT_RING1, MT_RING2, MT_RING3, MT_BALL, MT_USER };
 
  enum marker_size { MS_NONE, MS_10, MS_15, MS_20, MS_25, MS_30, MS_35,
                     MS_40, MS_45, MS_50, MS_55, MS_60, MS_65, MS_70 };
 
  enum shape_state
  {
    ST_ON,
 
    ST_OUT,
    
    ST_ONOUT,
 
    ST_IN,
 
    ST_ONIN
  };
 
  enum find_shape_method
  {
    FSM_GetInPlace,
 
    FSM_Transformed,
 
    FSM_GetSame,
 
    FSM_GetShapesOnShape,
 
    FSM_GetInPlaceByHistory,
 
    FSM_MultiTransformed,
 
    FSM_GetInPlace_Old
  };
 
  enum filling_oper_method
  {
    FOM_Default,
 
    FOM_UseOri,
 
    FOM_AutoCorrect
  };
 
  enum curve_type {
    Polyline,
    
    Bezier,
 
    Interpolation
  };
 
  enum field_data_type {
    FDT_Bool,
    FDT_Int,
    FDT_Double,
    FDT_String
  };
 
  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
  };
 
  enum comparison_condition
  {
    CC_GT, 
    CC_GE, 
    CC_LT, 
    CC_LE  
  };
 
  enum wire_build_mode
  {
    WBM_FixTolerance,
 
    WBM_Approximation,
 
    WBM_KeepCurveType
  };
 
  struct Parameter
  {
    string name;
    string value;
  };
  typedef sequence<Parameter> Parameters;
 
  struct CreationInformation
  {
    string     operationName;
    Parameters params;
  };
  typedef sequence<CreationInformation> CreationInformationSeq;
 
  struct ModifInfo
  {
    string name;  // what changed
    long   count; // how many times
  };
  typedef sequence<ModifInfo> ModifStatistics;
 
 
  typedef sequence<string>       string_array;
  typedef sequence<short>        short_array;
  typedef sequence<boolean>      ListOfBool;
  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_FieldStep;
 
  typedef sequence<GEOM_Object>       ListOfGO;
  typedef sequence<GEOM_BaseObject>   ListOfGBO;
  typedef sequence<GEOM_Field>        ListOfFields;
  typedef sequence<SALOMEDS::SObject> object_list;
 
  //# GEOM_BaseObject
  interface GEOM_BaseObject : SALOME::GenericObj
  {
    void SetName (in string theName);
 
    string GetName();
 
    string GetEntry();
 
    long GetType();
 
    long GetTick();
 
    void SetStudyEntry (in string theEntry);
 
    string GetStudyEntry();
 
    ListOfGBO GetDependency();
 
    ListOfGBO GetLastDependency();
 
    /*
     *  \brief Return true if geom object representes a shape.
     *
     *  For example, method return false for GEOM_MARKER
     */
     boolean IsShape();
 
    /*
     *  \brief Return true if passed object is identical to this object
     *
     *  \param other object being compared with this one
     */
    boolean IsSame(in GEOM_BaseObject other);
 
    void SetParameters (in string theParameters);
 
    string GetParameters();
 
    CreationInformationSeq GetCreationInformation();
 
    GEOM_Gen GetGen();
  };
 
  //# GEOM_Object
  interface GEOM_Object : GEOM_BaseObject
  {
    shape_type GetShapeType();
 
    shape_type GetTopologyType();
 
    shape_type GetMinShapeType();
 
    shape_type GetMaxShapeType();
 
    string GetSubShapeName(in long subID);
 
    void SetColor(in SALOMEDS::Color theColor);
 
    SALOMEDS::Color GetColor();
 
    void SetAutoColor(in boolean theAutoColor);
 
    boolean GetAutoColor();
 
    void SetMarkerStd(in marker_type theType, in marker_size theSize );
 
    void SetMarkerTexture(in long theTextureId);
 
    marker_type GetMarkerType();
 
    marker_size GetMarkerSize();
 
    long GetMarkerTexture();
 
    long long getShape();
 
 //   ######################################################################
 //   # Internal methods (For sub-shape identification)
 //   ######################################################################
    SALOMEDS::TMPFile GetShapeStream();
 
    /*
     *  \brief Returns True if this object is not a sub-shape of another object.
     */
    boolean IsMainShape();
 
    /*
     *  \brief Get a list of ID's of sub-shapes in the main shape.
     *  \note Internal method, suppopsed to be used only by GEOM_Client
     */
    ListOfLong GetSubShapeIndices();
 
    /*
     *  \brief Get a main shape object to which this object is a sub-shape
     *  \note Internal method, suppopsed to be used only by GEOM_Client
     */
    GEOM_Object GetMainShape();
 
    /*
     * \brief Returns true if the current object has connection to a parametrical model
     * which can be modified by parameters change.
     */
    boolean IsParametrical();
 
  };
 
  //# GEOM_Field
  interface GEOM_Field : GEOM_BaseObject
  {
    GEOM_Object GetShape();
 
    field_data_type GetDataType();
 
    short GetDimension();
 
    string_array GetComponents();
 
    //void RemoveComponent(in long number);
 
    GEOM_FieldStep AddStep(in long stepID, in long stamp);
 
    void RemoveStep(in long stepID);
 
    long CountSteps();
 
    ListOfLong GetSteps();
 
    GEOM_FieldStep GetStep(in long stepID);
 
    long GetArraySize();
  };
 
  // # GEOM_FieldStep:
  interface GEOM_FieldStep : GEOM_BaseObject
  {
    void SetStamp(in long stamp);
 
    long GetStamp();
 
    long GetID();
 
    GEOM_Field GetField();
  };
 
  // # GEOM_BoolFieldStep:
  interface GEOM_BoolFieldStep : GEOM_FieldStep
  {
    boolean SetValues(in short_array boolValues);
 
    short_array GetValues();
  };
 
  // # GEOM_IntFieldStep:
  interface GEOM_IntFieldStep : GEOM_FieldStep
  {
    boolean SetValues(in ListOfLong intValues);
 
    ListOfLong GetValues();
  };
 
  // # GEOM_DoubleFieldStep:
  interface GEOM_DoubleFieldStep : GEOM_FieldStep
  {
    boolean SetValues(in ListOfDouble doubleValues);
 
    ListOfDouble GetValues();
  };
 
  // # GEOM_StringFieldStep:
  interface GEOM_StringFieldStep : GEOM_FieldStep
  {
    boolean SetValues(in string_array strValues);
 
    string_array GetValues();
  };
 
  // # GEOM_IOperations:
  interface GEOM_IOperations : SALOME::GenericObj
  {
    boolean IsDone();
 
    void SetErrorCode (in string theErrorID);
 
    string GetErrorCode();
 
    void StartOperation();
 
    void FinishOperation();
 
    void AbortOperation();
  };
  //# GEOM_IBasicOperations:
  interface GEOM_IBasicOperations : GEOM_IOperations
  {
    GEOM_Object MakePointXYZ (in double theX, in double theY, in double theZ);
 
    GEOM_Object MakePointWithReference (in GEOM_Object theReference,
                                        in double theX, in double theY, in double theZ);
 
    GEOM_Object MakePointOnCurve (in GEOM_Object theRefCurve,
                                  in double      theParameter,
                                  in boolean     takeOrientationIntoAccount);
 
    GEOM_Object MakePointOnCurveByLength (in GEOM_Object theRefCurve,
                                          in double      theLength,
                                          in GEOM_Object theStartPoint);
 
    GEOM_Object MakePointOnCurveByCoord (in GEOM_Object theRefCurve,
                                         in double theXParameter,
                                         in double theYParameter,
                                         in double theZParameter);
 
    GEOM_Object MakePointOnSurface (in GEOM_Object theRefSurf,
                                    in double theUParameter,
                                    in double theVParameter);
 
    GEOM_Object MakePointOnSurfaceByCoord (in GEOM_Object theRefSurf,
                                           in double theXParameter,
                                           in double theYParameter,
                                           in double theZParameter);
 
    GEOM_Object MakePointOnFace (in GEOM_Object theFace,
                     in long        theNumberOfPnts);
 
    GEOM_Object MakePointOnLinesIntersection (in GEOM_Object theRefLine1,
                                              in GEOM_Object theRefLine2);
 
     GEOM_Object MakeTangentOnCurve (in GEOM_Object theRefCurve,
                                     in double theParameter);
 
    GEOM_Object MakeVectorDXDYDZ (in double theDX,
                                  in double theDY,
                                  in double theDZ);
 
    GEOM_Object MakeVectorTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
 
    GEOM_Object MakeLine (in GEOM_Object thePnt, in GEOM_Object theDir);
 
    GEOM_Object MakeLineTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
 
    GEOM_Object MakeLineTwoFaces (in GEOM_Object theFace1, in GEOM_Object theFace2);
 
    GEOM_Object MakePlaneThreePnt (in GEOM_Object thePnt1,
                                   in GEOM_Object thePnt2,
                                   in GEOM_Object thePnt3,
                                   in double theTrimSize);
 
    GEOM_Object MakePlanePntVec (in GEOM_Object thePnt,
                                 in GEOM_Object theVec,
                                 in double theTrimSize);
 
    GEOM_Object MakePlaneFace (in GEOM_Object theFace,
                               in double theTrimSize);
 
    GEOM_Object MakePlane2Vec (in GEOM_Object theVec1,
                               in GEOM_Object theVec2,
                               in double theTrimSize);
 
    GEOM_Object MakePlaneLCS (in GEOM_Object theLCS,
                              in double theTrimSize,
                              in double theOrientation);
 
    GEOM_Object MakeMarker (in double theOX , in double theOY , in double theOZ,
                            in double theXDX, in double theXDY, in double theXDZ,
                            in double theYDX, in double theYDY, in double theYDZ);
 
    GEOM_Object MakeMarkerFromShape (in GEOM_Object theShape);
 
    GEOM_Object MakeMarkerPntTwoVec (in GEOM_Object theOrigin,
                                     in GEOM_Object theXVec, in GEOM_Object theYVec);
 
    GEOM_Object MakeTangentPlaneOnFace(in GEOM_Object theFace,
                                       in double theParameterU,
                                       in double theParameterV,
                                       in double theTrimSize);
  };
 
  interface GEOM_ITransformOperations : GEOM_IOperations
  {
    GEOM_Object TranslateTwoPoints (in GEOM_Object theObject,
                                    in GEOM_Object thePoint1,
                                    in GEOM_Object thePoint2);
 
    GEOM_Object TranslateTwoPointsCopy (in GEOM_Object theObject,
                                        in GEOM_Object thePoint1,
                                        in GEOM_Object thePoint2);
 
    GEOM_Object TranslateDXDYDZ (in GEOM_Object theObject,
                                 in double theDX, in double theDY, in double theDZ);
 
    GEOM_Object TranslateDXDYDZCopy (in GEOM_Object theObject,
                                     in double theDX, in double theDY, in double theDZ);
 
 
    GEOM_Object TranslateVector (in GEOM_Object theObject,
                                 in GEOM_Object theVector);
 
    GEOM_Object TranslateVectorCopy (in GEOM_Object theObject,
                                     in GEOM_Object theVector);
 
    GEOM_Object TranslateVectorDistance (in GEOM_Object theObject,
                                         in GEOM_Object theVector,
                                         in double      theDistance,
                                         in boolean     theCopy);
 
    GEOM_Object MultiTranslate1D (in GEOM_Object theObject,
                                  in GEOM_Object theVector,
                                  in double theStep,
                                  in long theNbTimes);
 
    GEOM_Object MultiTranslate2D (in GEOM_Object theObject,
                                  in GEOM_Object theVector1,
                                  in double theStep1,
                                  in long theNbTimes1,
                                  in GEOM_Object theVector2,
                                  in double theStep2,
                                  in long theNbTimes2);
 
    GEOM_Object RotateThreePoints (in GEOM_Object theObject,
                                   in GEOM_Object theCentPoint,
                                   in GEOM_Object thePoint1,
                                   in GEOM_Object thePoint2);
 
 
    GEOM_Object RotateThreePointsCopy (in GEOM_Object theObject,
                                       in GEOM_Object theCentPoint,
                                       in GEOM_Object thePoint1,
                                       in GEOM_Object thePoint2);
 
    GEOM_Object Rotate (in GEOM_Object theObject,
                        in GEOM_Object theAxis,
                        in double theAngle);
 
 
    GEOM_Object RotateCopy (in GEOM_Object theObject,
                            in GEOM_Object theAxis,
                            in double theAngle);
 
    GEOM_Object MultiRotate1D (in GEOM_Object theObject,
                               in GEOM_Object theAxis,
                               in long theNbObjects);
 
    GEOM_Object MultiRotate1DByStep (in GEOM_Object theObject,
                                     in GEOM_Object theAxis,
                                     in double theAngleStep,
                                     in long theNbSteps);
 
    GEOM_Object MultiRotate2DNbTimes (in GEOM_Object theObject,
                                      in GEOM_Object theAxis,
                                      in long theNbObjects,
                                      in double theRadialStep,
                                      in long theNbSteps);
 
    GEOM_Object MultiRotate2DByStep (in GEOM_Object theObject,
                                     in GEOM_Object theAxis,
                                     in double theAngleStep,
                                     in long theNbSteps1,
                                     in double theRadialStep,
                                     in long theNbSteps2);
 
    GEOM_Object MultiRotate2D (in GEOM_Object theObject,
                               in GEOM_Object theAxis,
                               in double theAngleStep,
                               in long theNbSteps1,
                               in double theRadialStep,
                               in long theNbSteps2);
 
    GEOM_Object MirrorPlane (in GEOM_Object theObject, in GEOM_Object thePlane);
 
    GEOM_Object MirrorPlaneCopy (in GEOM_Object theObject, in GEOM_Object thePlane);
 
    GEOM_Object MirrorAxis (in GEOM_Object theObject, in GEOM_Object theAxis);
 
    GEOM_Object MirrorAxisCopy (in GEOM_Object theObject, in GEOM_Object theAxis);
 
    GEOM_Object MirrorPoint (in GEOM_Object theObject, in GEOM_Object thePoint);
 
    GEOM_Object MirrorPointCopy (in GEOM_Object theObject, in GEOM_Object thePoint);
 
    GEOM_Object OffsetShape (in GEOM_Object theObject,
                             in double      theOffset,
                             in boolean     theJoinByPipes);
 
    GEOM_Object OffsetShapeCopy (in GEOM_Object theObject,
                                 in double      theOffset,
                                 in boolean     theJoinByPipes);
 
    GEOM_Object OffsetShapePartialCopy (in GEOM_Object theObject,
                                        in double      theOffset,
                                        in ListOfLong  theFacesIDs);
 
    GEOM_Object ProjectShapeCopy (in GEOM_Object theSource, in GEOM_Object theTarget);
 
    double ProjectPointOnWire (in  GEOM_Object thePoint,
                               in  GEOM_Object theWire,
                               out GEOM_Object thePointOnEdge,
                               out long        theEdgeInWireIndex);
 
    GEOM_Object ScaleShape (in GEOM_Object theObject, in GEOM_Object thePoint,
                            in double theFactor);
 
    GEOM_Object ScaleShapeCopy (in GEOM_Object theObject, in GEOM_Object thePoint,
                                in double theFactor);
 
    GEOM_Object ScaleShapeAlongAxes (in GEOM_Object theObject,
                                     in GEOM_Object thePoint,
                                     in double theFactorX,
                                     in double theFactorY,
                                     in double theFactorZ);
 
    GEOM_Object ScaleShapeAlongAxesCopy (in GEOM_Object theObject,
                                         in GEOM_Object thePoint,
                                         in double theFactorX,
                                         in double theFactorY,
                                         in double theFactorZ);
 
    GEOM_Object PositionShape (in GEOM_Object theObject,
                               in GEOM_Object theStartLCS,
                               in GEOM_Object theEndLCS);
 
    GEOM_Object PositionShapeCopy (in GEOM_Object theObject,
                                   in GEOM_Object theStartLCS,
                                   in GEOM_Object theEndLCS);
 
    GEOM_Object PositionAlongPath (in GEOM_Object theObject,
                                   in GEOM_Object thePath,
                                   in double theDistance,
                                   in boolean theCopy,
                                   in boolean theReverse);
 
    GEOM_Object RecomputeObject (in GEOM_Object theObject);
 
    GEOM_Object MakeProjectionOnCylinder (in GEOM_Object theObject,
                                          in double      theRadius,
                                          in double      theStartAngle,
                                          in double      theAngleLength,
                                          in double      theAngleRotation);
  };
  
  interface GEOM_I3DPrimOperations : GEOM_IOperations
  {
    GEOM_Object MakeBoxDXDYDZ (in double theDX, in double theDY, in double theDZ);
 
    GEOM_Object MakeBoxTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
 
    GEOM_Object MakeFaceHW (in double theH, in double theW, in short theOrientation);
    GEOM_Object MakeFaceObjHW (in GEOM_Object theObj, in double theH, in double theW);
    GEOM_Object MakeDiskPntVecR (in GEOM_Object thePnt,
                                 in GEOM_Object theVec,
                                 in double theR);
    GEOM_Object MakeDiskThreePnt (in GEOM_Object thePnt1,
                                  in GEOM_Object thePnt2,
                                  in GEOM_Object thePnt3);
 
    GEOM_Object MakeDiskR (in double theR, in short theOrientation);
 
    GEOM_Object MakeCylinderRH (in double theR, in double theH);
 
    GEOM_Object MakeCylinderRHA (in double theR, in double theH, in double theA);
 
    GEOM_Object MakeCylinderPntVecRH (in GEOM_Object thePnt,
                                      in GEOM_Object theAxis,
                                      in double      theR,
                                      in double      theH);
    GEOM_Object MakeCylinderPntVecRHA (in GEOM_Object thePnt,
                                      in GEOM_Object theAxis,
                                      in double      theR,
                                      in double      theH,
                                      in double      theA);
 
    GEOM_Object MakeConeR1R2H (in double theR1, in double theR2, in double theH);
 
    GEOM_Object MakeConePntVecR1R2H (in GEOM_Object thePnt,
                                     in GEOM_Object theAxis,
                                     in double      theR1,
                                     in double      theR2,
                                     in double      theH);
 
    GEOM_Object MakeTorusRR (in double theRMajor,
                             in double theRMinor);
 
    GEOM_Object MakeTorusPntVecRR (in GEOM_Object thePnt,
                                   in GEOM_Object theVec,
                                   in double theRMajor,
                                   in double theRMinor);
 
    GEOM_Object MakeSphereR (in double theR);
 
    GEOM_Object MakeSpherePntR (in GEOM_Object thePnt, in double theR);
 
    GEOM_Object MakePrismVecH (in GEOM_Object theBase,
                               in GEOM_Object theVec,
                               in double      theH);
    /*  \brief The Same Prism but in 2 directions (forward&backward) */
    GEOM_Object MakePrismVecH2Ways (in GEOM_Object theBase,
                                    in GEOM_Object theVec,
                                    in double      theH);
    /*  \brief The Same as MakePrismVecH but with scaling */
    GEOM_Object MakePrismVecHWithScaling (in GEOM_Object theBase,
                                          in GEOM_Object theVec,
                                          in double      theH,
                                          in double      theScaleFactor);
 
    GEOM_Object MakePrismTwoPnt (in GEOM_Object theBase,
                                 in GEOM_Object thePoint1,
                                 in GEOM_Object thePoint2);
    /*  \brief The same prism but in two directions forward&backward */
    GEOM_Object MakePrismTwoPnt2Ways (in GEOM_Object theBase,
                                      in GEOM_Object thePoint1,
                                      in GEOM_Object thePoint2);
    /*  \brief The Same as MakePrismTwoPnt but with scaling */
    GEOM_Object MakePrismTwoPntWithScaling (in GEOM_Object theBase,
                                            in GEOM_Object thePoint1,
                                            in GEOM_Object thePoint2,
                                            in double      theScaleFactor);
 
    GEOM_Object MakePrismDXDYDZ (in GEOM_Object theBase,
                                   in double theDX, in double theDY, in double theDZ);
    /*  \brief The same prism but in two directions forward&backward */
    GEOM_Object MakePrismDXDYDZ2Ways (in GEOM_Object theBase,
                                      in double theDX, in double theDY, in double theDZ);
    /*  \brief The Same as MakePrismDXDYDZ but with scaling */
    GEOM_Object MakePrismDXDYDZWithScaling (in GEOM_Object theBase,
                                            in double theDX, in double theDY, in double theDZ,
                                            in double theScaleFactor);
 
 
    GEOM_Object MakeDraftPrism (in GEOM_Object theInitShape,
                                in GEOM_Object theBase,
                                in double theHeight, 
                                in double theAngle,
                                in boolean theFuse,
                                in boolean theInvert);
 
    ListOfGO MakePipe (in GEOM_Object theBase,
                       in GEOM_Object thePath,
                       in boolean     IsGenerateGroups);
 
    GEOM_Object MakeRevolutionAxisAngle (in GEOM_Object theBase,
                                         in GEOM_Object theAxis,
                                         in double theAngle);
    /*  The Same Revolution but in both ways forward&backward */
    GEOM_Object MakeRevolutionAxisAngle2Ways (in GEOM_Object theBase,
                                              in GEOM_Object theAxis,
                                              in double theAngle);
 
    GEOM_Object MakeFilling (in ListOfGO theContours,
                             in long theMinDeg, in long theMaxDeg,
                             in double theTol2D, in double theTol3D,
                             in long theNbIter,
                             in filling_oper_method theMethod,
                             in boolean theApprox);
 
    GEOM_Object MakeThruSections(in ListOfGO theSeqSections,
                                 in boolean theModeSolid,
                                 in double thePreci,
                                 in boolean theRuled);
 
    ListOfGO MakePipeWithDifferentSections (in ListOfGO theSeqBases,
                                            in ListOfGO theLocations,
                                            in GEOM_Object thePath,
                                            in boolean theWithContact ,
                                            in boolean theWithCorrection,
                                            in boolean IsBySteps,
                                            in boolean IsGenerateGroups);
 
    ListOfGO MakePipeWithShellSections (in ListOfGO theSeqBases,
                                        in ListOfGO theSeqSubBases,
                                        in ListOfGO theLocations,
                                        in GEOM_Object thePath,
                                        in boolean theWithContact,
                                        in boolean theWithCorrection,
                                        in boolean IsGenerateGroups);
 
    ListOfGO MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
                                        in ListOfGO theLocations,
                                        in boolean  IsGenerateGroups);
 
    ListOfGO MakePipeBiNormalAlongVector (in GEOM_Object theBase,
                                          in GEOM_Object thePath,
                                          in GEOM_Object theVec,
                                          in boolean     IsGenerateGroups);
 
 
    GEOM_Object MakeThickening (in GEOM_Object theObject,
                                in ListOfLong  theFacesIDs,
                                in double      theThickness,
                                in boolean     isCopy,
                                in boolean     isInside);
 
    
    GEOM_Object RestorePath (in GEOM_Object theShape,
                             in GEOM_Object theBase1,
                             in GEOM_Object theBase2);
 
    GEOM_Object RestorePathEdges (in GEOM_Object theShape,
                                  in ListOfGO theBase1,
                                  in ListOfGO theBase2);
  };
 
  interface GEOM_IShapesOperations : GEOM_IOperations
  {
    GEOM_Object MakeEdge (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
 
    GEOM_Object MakeEdgeOnCurveByLength (in GEOM_Object theRefCurve,
                                         in double      theLength,
                                         in GEOM_Object theStartPoint);
 
    GEOM_Object MakeEdgeWire (in GEOM_Object theWire,
                              in double theLinearTolerance,
                              in double theAngularTolerance);
 
    GEOM_Object MakeWire (in ListOfGO theEdgesAndWires,
                          in double   theTolerance,
                          in wire_build_mode theMode);
 
    GEOM_Object MakeFace (in GEOM_Object theWire, in boolean isPlanarWanted);
 
    GEOM_Object MakeFaceWires (in ListOfGO theWires, in boolean isPlanarWanted);
 
    GEOM_Object MakeFaceFromSurface(in GEOM_Object theFace,
                                    in GEOM_Object theWire);
 
    GEOM_Object MakeWrappedFace(in ListOfGO theEdges,
                                in ListOfGO theVertices,
                                in double   theTolerance);
 
    GEOM_Object MakeFaceWithConstraints(in ListOfGO theConstraints);
 
    GEOM_Object MakeShell (in ListOfGO theFacesAndShells);
 
    GEOM_Object MakeSolidShell (in GEOM_Object theShell);
 
    GEOM_Object MakeSolidShells (in ListOfGO theShells);
 
    GEOM_Object MakeCompound (in ListOfGO theShapes);
 
    GEOM_Object MakeSolidFromConnectedFaces (in ListOfGO theFacesOrShells, in boolean isIntersect);
    
    GEOM_Object MakeGlueFaces (in ListOfGO theShapes, in double theTolerance, in boolean doKeepNonSolids);
 
    ListOfGO GetGlueFaces (in ListOfGO theShapes, in double theTolerance);
 
    GEOM_Object MakeGlueFacesByList (in ListOfGO theShapes, in double theTolerance,
                                     in ListOfGO theFaces,  in boolean doKeepNonSolids,
                                     in boolean doGlueAllEdges);
 
    GEOM_Object MakeGlueEdges (in ListOfGO theShapes, in double theTolerance);
 
    ListOfGO GetGlueEdges (in ListOfGO theShapes, in double theTolerance);
 
    GEOM_Object MakeGlueEdgesByList (in ListOfGO theShapes,
                                     in double   theTolerance,
                                     in ListOfGO theEdges);
 
    ListOfGO GetExistingSubObjects (in GEOM_Object theShape,
                                    in boolean     theGroupsOnly);
 
    ListOfGO MakeExplode (in GEOM_Object theShape,
                          in long        theShapeType,
                          in boolean     isSorted);
 
    ListOfGO MakeAllSubShapes (in GEOM_Object theShape,
                               in long        theShapeType,
                               in boolean     isSorted);
 
    ListOfGO ExtractSubShapes (in GEOM_Object theShape,
                               in long        theShapeType,
                               in boolean     isSorted);
 
    ListOfLong SubShapeAllIDs (in GEOM_Object theShape,
                               in long        theShapeType,
                               in boolean     isSorted);
 
    ListOfLong GetAllSubShapesIDs (in GEOM_Object theShape,
                                   in long        theShapeType,
                                   in boolean     isSorted);
 
    GEOM_Object GetSubShape (in GEOM_Object theMainShape,
                             in long        theID);
 
    ListOfGO MakeSubShapes (in GEOM_Object theMainShape,
                            in ListOfLong  theIndices);
 
    long GetSubShapeIndex (in GEOM_Object theMainShape, in GEOM_Object theSubShape);
 
    ListOfLong GetSubShapesIndices (in GEOM_Object theMainShape, in ListOfGO theSubShapes);
 
    long GetTopologyIndex (in GEOM_Object theMainShape, in GEOM_Object theSubShape);
 
    string GetShapeTypeString (in GEOM_Object theShape);
 
    boolean IsSubShapeBelongsTo( in GEOM_Object theSubObject,
                                 in long        theSubObjectIndex,
                                 in GEOM_Object theObject,
                                 in long        theObjectIndex);
    long NumberOfFaces (in GEOM_Object theShape);
 
    long NumberOfEdges (in GEOM_Object theShape);
 
    long NumberOfSubShapes (in GEOM_Object theShape,
                            in long        theShapeType);
 
    GEOM_Object ChangeOrientation (in GEOM_Object theShape);
 
    ListOfLong GetFreeFacesIDs (in GEOM_Object theShape);
 
    ListOfGO GetSharedShapes (in GEOM_Object theShape1,
                              in GEOM_Object theShape2,
                              in long        theShapeType);
 
    ListOfGO GetSharedShapesMulti (in ListOfGO theShapes,
                                   in long     theShapeType,
                       in boolean  theMultiShare);
 
    ListOfGO GetShapesOnPlane (in GEOM_Object theShape,
                               in long        theShapeType,
                               in GEOM_Object theAx1,
                               in shape_state theState);
    ListOfGO GetShapesOnPlaneWithLocation (in GEOM_Object theShape,
                                           in long        theShapeType,
                                           in GEOM_Object theAx1,
                                           in GEOM_Object thePnt,
                                           in shape_state theState);
 
 
 
    ListOfGO GetShapesOnCylinder (in GEOM_Object theShape,
                                  in long        theShapeType,
                                  in GEOM_Object theAxis,
                                  in double      theRadius,
                                  in shape_state theState);
 
    ListOfGO GetShapesOnCylinderWithLocation (in GEOM_Object theShape,
                                              in long        theShapeType,
                                              in GEOM_Object theAxis,
                                              in GEOM_Object thePnt,
                                              in double      theRadius,
                                              in shape_state theState);
 
    ListOfGO GetShapesOnSphere (in GEOM_Object theShape,
                                in long        theShapeType,
                                in GEOM_Object theCenter,
                                in double      theRadius,
                                in shape_state theState);
 
    ListOfGO GetShapesOnQuadrangle (in GEOM_Object theShape,
                                    in long        theShapeType,
                                    in GEOM_Object theTopLeftPoint,
                                    in GEOM_Object theTopRightPoint,
                                    in GEOM_Object theBottomLeftPoint,
                                    in GEOM_Object theBottomRightPoint,
                                    in shape_state theState);
 
    ListOfLong GetShapesOnPlaneIDs (in GEOM_Object theShape,
                                    in long        theShapeType,
                                    in GEOM_Object theAx1,
                                    in shape_state theState);
 
    ListOfLong GetShapesOnPlaneWithLocationIDs (in GEOM_Object theShape,
                                                in long        theShapeType,
                                                in GEOM_Object theAx1,
                                                in GEOM_Object thePnt,
                                                in shape_state theState);
 
    ListOfLong GetShapesOnCylinderIDs (in GEOM_Object theShape,
                                       in long        theShapeType,
                                       in GEOM_Object theAxis,
                                       in double      theRadius,
                                       in shape_state theState);
 
    ListOfLong GetShapesOnCylinderWithLocationIDs (in GEOM_Object theShape,
                                                   in long        theShapeType,
                                                   in GEOM_Object theAxis,
                                                   in GEOM_Object thePnt,
                                                   in double      theRadius,
                                                   in shape_state theState);
 
    ListOfLong GetShapesOnSphereIDs (in GEOM_Object theShape,
                                     in long        theShapeType,
                                     in GEOM_Object theCenter,
                                     in double      theRadius,
                                     in shape_state theState);
 
    ListOfLong GetShapesOnQuadrangleIDs (in GEOM_Object theShape,
                                         in long        theShapeType,
                                         in GEOM_Object theTopLeftPoint,
                                         in GEOM_Object theTopRightPoint,
                                         in GEOM_Object theBottomLeftPoint,
                                         in GEOM_Object theBottomRightPoint,
                                         in shape_state theState);
 
    ListOfLong GetShapesOnBoxIDs (in GEOM_Object theBox,
                                  in GEOM_Object theShape,
                                  in long        theShapeType,
                                  in shape_state theState);
 
    ListOfGO GetShapesOnBox (in GEOM_Object theBox,
                             in GEOM_Object theShape,
                             in long        theShapeType,
                             in shape_state theState);
 
    ListOfLong GetShapesOnShapeIDs (in GEOM_Object theCheckShape,
                                    in GEOM_Object theShape,
                                    in short       theShapeType,
                                    in shape_state theState);
 
    ListOfGO GetShapesOnShape (in GEOM_Object theCheckShape,
                               in GEOM_Object theShape,
                               in short       theShapeType,
                               in shape_state theState);
 
    GEOM_Object GetShapesOnShapeAsCompound (in GEOM_Object theCheckShape,
                                            in GEOM_Object theShape,
                                            in short       theShapeType,
                                            in shape_state theState);
 
    GEOM_Object GetInPlace (in GEOM_Object theShapeWhere,
                            in GEOM_Object theShapeWhat);
 
    GEOM_Object GetInPlaceOld (in GEOM_Object theShapeWhere,
                               in GEOM_Object theShapeWhat);
 
    GEOM_Object GetInPlaceByHistory (in GEOM_Object theShapeWhere,
                                     in GEOM_Object theShapeWhat);
 
    ListOfListOfLong GetInPlaceMap (in GEOM_Object theShapeWhere,
                                    in GEOM_Object theShapeWhat);
 
    GEOM_Object GetSame (in GEOM_Object theShapeWhere,
                         in GEOM_Object theShapeWhat);
 
    ListOfLong GetSameIDs (in GEOM_Object theShapeWhere,
                           in GEOM_Object theShapeWhat);
 
    GEOM_Object ExtendEdge(in GEOM_Object theEdge,
                           in double      theMin,
                           in double      theMax);
 
    GEOM_Object ExtendFace(in GEOM_Object theFace,
                           in double      theUMin,
                           in double      theUMax,
                           in double      theVMin,
                           in double      theVMax);
 
    GEOM_Object MakeSurfaceFromFace(in GEOM_Object theFace);
 
    ListOfGO GetSubShapeEdgeSorted (in GEOM_Object theShape,
                                    in GEOM_Object theStartPoint);
 
    ListOfGO GetSubShapesWithTolerance(in GEOM_Object          theShape,
                                       in short                theShapeType,
                                       in comparison_condition theCondition,
                                       in double               theTolerance);
 
    enum ExtractionStatType
    {
      EST_Removed,  
      EST_Modified, 
      EST_Added     
    };
 
    struct ExtractionStat
    {
      ExtractionStatType type;    
      ListOfLong         indices; 
    };
 
    typedef sequence<ExtractionStat> ExtractionStats;
 
    GEOM_Object MakeExtraction(in GEOM_Object      theShape,
                               in ListOfLong       theSubShapeIDs,
                               out ExtractionStats theStats);
 
  };
 
 // # GEOM_IBlocksOperations: 
  interface GEOM_IBlocksOperations : GEOM_IOperations
  {
   
  //  # Creation of blocks
 
    GEOM_Object MakeQuad (in GEOM_Object theEdge1,
                          in GEOM_Object theEdge2,
                          in GEOM_Object theEdge3,
                          in GEOM_Object theEdge4);
 
    GEOM_Object MakeQuad2Edges (in GEOM_Object theEdge1,
                                in GEOM_Object theEdge2);
 
    GEOM_Object MakeQuad4Vertices (in GEOM_Object thePnt1,
                                   in GEOM_Object thePnt2,
                                   in GEOM_Object thePnt3,
                                   in GEOM_Object thePnt4);
 
    GEOM_Object MakeHexa (in GEOM_Object theFace1,
                          in GEOM_Object theFace2,
                          in GEOM_Object theFace3,
                          in GEOM_Object theFace4,
                          in GEOM_Object theFace5,
                          in GEOM_Object theFace6);
 
    GEOM_Object MakeHexa2Faces (in GEOM_Object theFace1,
                                in GEOM_Object theFace2);
 
    
  //  # Extract elements of blocks and blocks compounds
     
 
    GEOM_Object GetPoint (in GEOM_Object theShape,
                          in double      theX,
                          in double      theY,
                          in double      theZ,
                          in double      theEpsilon);
 
    GEOM_Object GetVertexNearPoint (in GEOM_Object theShape,
                                    in GEOM_Object thePoint);
 
    GEOM_Object GetEdge (in GEOM_Object theShape,
                         in GEOM_Object thePoint1,
                         in GEOM_Object thePoint2);
 
    GEOM_Object GetEdgeNearPoint (in GEOM_Object theShape,
                                  in GEOM_Object thePoint);
 
    GEOM_Object GetFaceByPoints (in GEOM_Object theShape,
                                 in GEOM_Object thePoint1,
                                 in GEOM_Object thePoint2,
                                 in GEOM_Object thePoint3,
                                 in GEOM_Object thePoint4);
 
    GEOM_Object GetFaceByEdges (in GEOM_Object theShape,
                                in GEOM_Object theEdge1,
                                in GEOM_Object theEdge2);
 
    GEOM_Object GetOppositeFace (in GEOM_Object theBlock,
                                 in GEOM_Object theFace);
 
    GEOM_Object GetFaceNearPoint (in GEOM_Object theShape,
                                  in GEOM_Object thePoint);
 
    GEOM_Object GetFaceByNormale (in GEOM_Object theBlock,
                                  in GEOM_Object theVector);
 
    GEOM_Object GetShapesNearPoint (in GEOM_Object theShape,
                                    in GEOM_Object thePoint,
                                    in long        theShapeType,
                                    in double      theTolerance);
 
   //  #  Extract blocks from blocks compounds
     
 
    boolean IsCompoundOfBlocks (in GEOM_Object theCompound,
                                in long        theMinNbFaces,
                                in long        theMaxNbFaces,
                                out long       theNbBlocks);
 
    enum BCErrorType
    {
      /* Each element of the compound should be a Block */
      NOT_BLOCK,
 
      /* An element is a potential block, but has degenerated and/or seam edge(s). */
      EXTRA_EDGE,
 
      /* A connection between two Blocks should be an entire face or an entire edge */
      INVALID_CONNECTION,
 
      /* The compound should be connexe */
      NOT_CONNECTED,
 
      /* The glue between two quadrangle faces should be applied */
      NOT_GLUED
    };
 
    struct BCError
    {
      BCErrorType error;
      ListOfLong  incriminated;
    };
 
    typedef sequence<BCError> BCErrors;
 
    boolean CheckCompoundOfBlocks (in GEOM_Object theCompound,
                                   in double      theToleranceC1,
                                   out BCErrors   theErrors);
 
    string PrintBCErrors (in GEOM_Object theCompound,
                          in BCErrors    theErrors);
 
    GEOM_Object GetNonBlocks (in GEOM_Object  theShape,
                              in double       theToleranceC1,
                              out GEOM_Object theNonQuads);
 
    GEOM_Object RemoveExtraEdges (in GEOM_Object theShape,
                                  in long        theOptimumNbFaces);
 
    GEOM_Object UnionFaces (in GEOM_Object theShape);
 
    GEOM_Object CheckAndImprove (in GEOM_Object theCompound);
 
    ListOfGO ExplodeCompoundOfBlocks (in GEOM_Object theCompound,
                                      in long        theMinNbFaces,
                                      in long        theMaxNbFaces);
 
    GEOM_Object GetBlockNearPoint (in GEOM_Object theCompound,
                                   in GEOM_Object thePoint);
 
    GEOM_Object GetBlockByParts (in GEOM_Object theCompound,
                                 in ListOfGO    theParts);
 
    ListOfGO GetBlocksByParts (in GEOM_Object theCompound,
                               in ListOfGO    theParts);
 
  // #  Operations on blocks with gluing of result
 
    GEOM_Object MakeMultiTransformation1D (in GEOM_Object theBlock,
                                           in long        theDirFace1,
                                           in long        theDirFace2,
                                           in long        theNbTimes);
 
    GEOM_Object MakeMultiTransformation2D (in GEOM_Object theBlock,
                                           in long        theDirFace1U,
                                           in long        theDirFace2U,
                                           in long        theNbTimesU,
                                           in long        theDirFace1V,
                                           in long        theDirFace2V,
                                           in long        theNbTimesV);
 
  // # Special operation - propagation
   
 
    ListOfGO Propagate (in GEOM_Object theShape);
  };
 
 // # GEOM_IBooleanOperations
  interface GEOM_IBooleanOperations : GEOM_IOperations
  {
    GEOM_Object MakeBoolean (in GEOM_Object theShape1,
                             in GEOM_Object theShape2,
                             in long        theOperation,
                             in boolean     IsCheckSelfInte);
    GEOM_Object MakeFuse (in GEOM_Object theShape1,
                          in GEOM_Object theShape2,
                          in boolean     IsCheckSelfInte,
                          in boolean     IsRmExtraEdges);
 
    GEOM_Object MakeFuseList (in ListOfGO theShapes,
                              in boolean  IsCheckSelfInte,
                              in boolean  IsRmExtraEdges);
 
    GEOM_Object MakeCommonList (in ListOfGO theShapes,
                                in boolean  IsCheckSelfInte);
 
    GEOM_Object MakeCutList (in GEOM_Object theMainShape,
                             in ListOfGO theShapes,
                             in boolean  IsCheckSelfInte);
 
    GEOM_Object MakePartition (in ListOfGO   theShapes,
                               in ListOfGO   theTools,
                               in ListOfGO   theKeepInside,
                               in ListOfGO   theRemoveInside,
                               in short      theLimit,
                               in boolean    theRemoveWebs,
                               in ListOfLong theMaterials,
                               in short      theKeepNonlimitShapes);
 
    GEOM_Object MakePartitionNonSelfIntersectedShape (in ListOfGO   theShapes,
                                                      in ListOfGO   theTools,
                                                      in ListOfGO   theKeepInside,
                                                      in ListOfGO   theRemoveInside,
                                                      in short      theLimit,
                                                      in boolean    theRemoveWebs,
                                                      in ListOfLong theMaterials,
                                                      in short      theKeepNonlimitShapes,
                                                      in boolean    IsCheckSelfInte);
 
    GEOM_Object MakeHalfPartition (in GEOM_Object theShape,
                                   in GEOM_Object thePlane);
 
    GEOM_Object MakeBooleanWithFuzzy (in GEOM_Object theShape1,
                                      in GEOM_Object theShape2,
                                      in long        theOperation,
                                      in boolean     IsCheckSelfInte,
                                      in double      theFuzzyParam);
    GEOM_Object MakeFuseWithFuzzy (in GEOM_Object theShape1,
                                   in GEOM_Object theShape2,
                                   in boolean     IsCheckSelfInte,
                                   in boolean     IsRmExtraEdges,
                                   in double      theFuzzyParam);
 
    GEOM_Object MakeFuseListWithFuzzy (in ListOfGO theShapes,
                                       in boolean  IsCheckSelfInte,
                                       in boolean  IsRmExtraEdges,
                                       in double   theFuzzyParam);
 
    GEOM_Object MakeCommonListWithFuzzy (in ListOfGO theShapes,
                                         in boolean  IsCheckSelfInte,
                                         in double   theFuzzyParam);
 
    GEOM_Object MakeCutListWithFuzzy (in GEOM_Object theMainShape,
                                      in ListOfGO    theShapes,
                                      in boolean     IsCheckSelfInte,
                                      in double      theFuzzyParam);
 
    GEOM_Object MakePartitionWithFuzzy (in ListOfGO   theShapes,
                                        in ListOfGO   theTools,
                                        in ListOfGO   theKeepInside,
                                        in ListOfGO   theRemoveInside,
                                        in short      theLimit,
                                        in boolean    theRemoveWebs,
                                        in ListOfLong theMaterials,
                                        in short      theKeepNonlimitShapes,
                                        in double     theFuzzyParam);
 
    GEOM_Object MakePartitionNonSelfIntersectedShapeWithFuzzy (in ListOfGO   theShapes,
                                                               in ListOfGO   theTools,
                                                               in ListOfGO   theKeepInside,
                                                               in ListOfGO   theRemoveInside,
                                                               in short      theLimit,
                                                               in boolean    theRemoveWebs,
                                                               in ListOfLong theMaterials,
                                                               in short      theKeepNonlimitShapes,
                                                               in boolean    IsCheckSelfInte,
                                                               in double     theFuzzyParam);
 
    GEOM_Object MakeHalfPartitionWithFuzzy (in GEOM_Object theShape,
                                            in GEOM_Object thePlane,
                                            in double      theFuzzyParam);
  };
 
 // # GEOM_ICurvesOperations:
  interface GEOM_ICurvesOperations : GEOM_IOperations
  {
    GEOM_Object MakeCirclePntVecR (in GEOM_Object thePnt,
                                   in GEOM_Object theVec,
                                   in double theR);
    GEOM_Object MakeCircleThreePnt (in GEOM_Object thePnt1,
                                    in GEOM_Object thePnt2,
                                    in GEOM_Object thePnt3);
    GEOM_Object MakeCircleCenter2Pnt (in GEOM_Object thePnt1,
                                      in GEOM_Object thePnt2,
                                      in GEOM_Object thePnt3);
    GEOM_Object MakeEllipse (in GEOM_Object thePnt,
                             in GEOM_Object theVec,
                             in double theRMajor,
                             in double theRMinor);
 
    GEOM_Object MakeEllipseVec (in GEOM_Object thePnt,
                                in GEOM_Object theVec,
                                in double theRMajor,
                                in double theRMinor,
                                in GEOM_Object theVecMaj);
 
    GEOM_Object MakeArc (in GEOM_Object thePnt1,
                         in GEOM_Object thePnt2,
                         in GEOM_Object thePnt3);
 
    GEOM_Object MakeArcCenter (in GEOM_Object theCenter,
                               in GEOM_Object thePnt1,
                               in GEOM_Object thePnt2,
                               in boolean theSense);
 
    GEOM_Object MakeArcOfEllipse (in GEOM_Object theCenter,
                                  in GEOM_Object thePnt1,
                                  in GEOM_Object thePnt2);
 
 
    GEOM_Object MakePolyline (in ListOfGO thePoints,
                              in boolean  theIsClosed);
 
    GEOM_Object MakeSplineBezier (in ListOfGO thePoints,
                                  in boolean  theIsClosed);
 
    GEOM_Object MakeSplineInterpolation (in ListOfGO thePoints,
                                         in boolean  theIsClosed,
                                         in boolean  theDoReordering);
 
    GEOM_Object MakeSplineInterpolWithTangents (in ListOfGO    thePoints,
                                                in GEOM_Object theFirstVec,
                                                in GEOM_Object theLastVec);
 
    GEOM_Object MakeCurveParametric(in string thexExpr,
                        in string theyExpr,
                        in string thezExpr,
                        in double theParamMin,
                        in double theParamMax,
                        in double theParamStep,
                        in curve_type theCurveType);
 
    GEOM_Object MakeCurveParametricNew(in string thexExpr,
                    in string theyExpr,
                    in string thezExpr,
                    in double theParamMin,
                    in double theParamMax,
                    in long   theParamNbStep,
                    in curve_type theCurveType);
 
    GEOM_Object MakeIsoline(in GEOM_Object theFace,
                            in boolean     IsUIsoline,
                            in double      theParameter);
 
    GEOM_Object MakeSketcher (in string theCommand, in ListOfDouble theWorkingPlane);
 
    GEOM_Object MakeSketcherOnPlane (in string theCommand, in GEOM_Object theWorkingPlane);
 
    GEOM_Object Make3DSketcherCommand (in string theCommand);
 
    GEOM_Object Make3DSketcher (in ListOfDouble theCoordinates);
 
    GEOM_Object MakePolyline2D (in ListOfListOfDouble theCoordsList,
                                in string_array       theNamesList,
                                in short_array        theTypesList,
                                in ListOfBool         theClosedList,
                                in ListOfDouble       theWorkingPlane);
 
    GEOM_Object MakePolyline2DOnPlane (in ListOfListOfDouble theCoordsList,
                                       in string_array       theNamesList,
                                       in short_array        theTypesList,
                                       in ListOfBool         theClosedList,
                                       in GEOM_Object        theWorkingPlane);
 
  };
 
 // # GEOM_ILocalOperations:
  interface GEOM_ILocalOperations : GEOM_IOperations
  {
    GEOM_Object MakeFilletAll (in GEOM_Object theShape,
                               in double      theR);
 
    GEOM_Object MakeFilletEdges (in GEOM_Object theShape,
                                 in double      theR,
                                 in ListOfLong  theEdges);
    GEOM_Object MakeFilletEdgesR1R2 (in GEOM_Object theShape,
                                     in double      theR1,
                                     in double      theR2,
                                     in ListOfLong  theEdges);
 
    GEOM_Object MakeFilletFaces (in GEOM_Object theShape,
                                 in double      theR,
                                 in ListOfLong  theFaces);
 
    GEOM_Object MakeFilletFacesR1R2 (in GEOM_Object theShape,
                                     in double      theR1,
                                     in double      theR2,
                                     in ListOfLong  theFaces);
 
    GEOM_Object MakeFillet2D (in GEOM_Object theShape,
                              in double      theR,
                              in ListOfLong  theVertexes);
 
    GEOM_Object MakeFillet1D (in GEOM_Object theShape,
                              in double      theR,
                              in ListOfLong  theVertexes,
                              in boolean     doIgnoreSecantVertices);
 
    GEOM_Object MakeChamferAll (in GEOM_Object theShape,
                                in double      theD);
 
    GEOM_Object MakeChamferEdge (in GEOM_Object theShape,
                                 in double theD1, in double theD2,
                                 in long theFace1, in long theFace2);
    GEOM_Object MakeChamferEdgeAD (in GEOM_Object theShape,
                                   in double theD, in double theAngle,
                                   in long theFace1, in long theFace2);
 
    GEOM_Object MakeChamferFaces (in GEOM_Object theShape,
                                  in double theD1, in double theD2,
                                  in ListOfLong theFaces);
    GEOM_Object MakeChamferFacesAD (in GEOM_Object theShape,
                                    in double theD, in double theAngle,
                                    in ListOfLong theFaces);
 
    GEOM_Object MakeChamferEdges (in GEOM_Object theShape,
                                  in double theD1, in double theD2,
                                  in ListOfLong theEdges);
    GEOM_Object MakeChamferEdgesAD (in GEOM_Object theShape,
                                    in double theD, in double theAngle,
                                    in ListOfLong theEdges);
 
    GEOM_Object MakeArchimede (in GEOM_Object theShape,
                               in double theWeight,
                               in double theWaterDensity,
                               in double theMeshDeflection);
 
    long GetSubShapeIndex (in GEOM_Object theShape, in GEOM_Object theSubShape);
  };
 
 // #  GEOM_IHealingOperations: 
  interface GEOM_IHealingOperations : GEOM_IOperations
  {
    GEOM_Object ProcessShape (in GEOM_Object theShapes,
                              in string_array theOperators,
                              in string_array theParameters,
                              in string_array theValues);
 
    void GetShapeProcessParameters (out string_array theOperators,
                                    out string_array theParameters,
                                    out string_array theValues);
    void GetOperatorParameters (in string theOperator,
                                out string_array theParameters,
                                out string_array theValues);
 
    GEOM_Object SuppressFaces (in GEOM_Object theObject, in short_array theFaces);
 
    GEOM_Object CloseContour (in GEOM_Object theObject, in short_array theWires,
                              in boolean isCommonVertex);
 
    GEOM_Object RemoveIntWires (in GEOM_Object theObject, in short_array theWires);
 
    GEOM_Object FillHoles (in GEOM_Object theObject, in short_array theWires);
 
    GEOM_Object Sew (in ListOfGO theObjects, in double theTolerance);
 
    GEOM_Object SewAllowNonManifold(in ListOfGO theObjects, in double theTolerance);
 
    GEOM_Object RemoveInternalFaces (in ListOfGO theSolids);
 
    GEOM_Object DivideEdge (in GEOM_Object theObject, in short theEdgeIndex,
                            in double theValue, in boolean isByParameter);
 
    GEOM_Object DivideEdgeByPoint (in GEOM_Object theObject,
                                   in short       theEdgeIndex,
                                   in ListOfGO    thePoints);
 
    GEOM_Object FuseCollinearEdgesWithinWire (in GEOM_Object theWire,
                                              in ListOfGO theVertices);
 
    boolean GetFreeBoundary (in  ListOfGO theObjects,
                             out ListOfGO theClosedWires,
                             out ListOfGO theOpenWires);
 
    GEOM_Object ChangeOrientation (in GEOM_Object theObject);
    GEOM_Object ChangeOrientationCopy (in GEOM_Object theObject);
 
    GEOM_Object LimitTolerance (in GEOM_Object theObject, in double theTolerance);
 
    void FuncToPythonDump(in GEOM_Object theObject, in GEOM_Object result, in string imports, in string funcName, in string args);
 
 
    ModifStatistics GetStatistics();
  };
 
 // # GEOM_IInsertOperations:
  interface GEOM_IInsertOperations : GEOM_IOperations
  {
    GEOM_Object MakeCopy (in GEOM_Object theOriginal);
 
    void Export (in GEOM_Object theObject, in string theFileName, in string theFormatName);
 
    ListOfGBO ImportFile (in string theFileName, in string theFormatName);
 
    string ReadValue (in string theFileName, in string theFormatName, in string theParameterName);
 
    GEOM_Object RestoreShape (in SALOMEDS::TMPFile theStream);
 
    long LoadTexture(in string theTextureFile);
 
    long AddTexture(in long theWidth, in long theHeight, in SALOMEDS::TMPFile theTexture);
 
    SALOMEDS::TMPFile GetTexture(in long theID, out long theWidth, out long theHeight);
 
    ListOfLong GetAllTextures();
 
    struct TransferDatum
    {
      string myName;
      long   myNumber;
      long   myMaxNumber;
    };
 
    typedef sequence<TransferDatum> ListOfTransferDatum;
 
    boolean TransferData(in  GEOM_Object         theObjectFrom,
                         in  GEOM_Object         theObjectTo,
                         in  find_shape_method   theFindMethod,
                         out ListOfTransferDatum theResult);
 
  };
 
 // # GEOM_IKindOfShape:
  interface GEOM_IKindOfShape
  {
    enum shape_kind {
      NO_SHAPE,
      //COMPOSITEs
      COMPOUND,
      COMPSOLID,
      SHELL,
      WIRE,
      // SOLIDs
      SPHERE,
      CYLINDER,
      BOX,
      ROTATED_BOX, 
      TORUS,   
      CONE,   
      POLYHEDRON,  
      SOLID,       
      // FACEs
      SPHERE2D,    
      CYLINDER2D,
      TORUS2D,     
      CONE2D,
      DISK_CIRCLE,
      DISK_ELLIPSE,
      POLYGON,     
      PLANE,        
      PLANAR,      
      FACE,      
      // EDGEs
      CIRCLE,      
      ARC_CIRCLE, 
      ELLIPSE,    
      ARC_ELLIPSE,  
      LINE,         
      SEGMENT,      
      CRV_BSPLINE,  
      CRV_BEZIER,  
      HYPERBOLA,  
      PARABOLA,  
      EDGE,       
      // VERTEX
      VERTEX,
      // ADVANCED shapes
      LCS,
      ADVANCED    
    };
  };
 
 // # GEOM_IMeasureOperations:
  interface GEOM_IMeasureOperations : GEOM_IOperations
  {
    //short KindOfShape (in GEOM_Object   theShape,
    GEOM_IKindOfShape::shape_kind KindOfShape (in  GEOM_Object  theShape,
                                               out ListOfLong   theIntegers,
                                               out ListOfDouble theDoubles);
 
    void GetPosition (in GEOM_Object theShape,
                      out double Ox, out double Oy, out double Oz,
                      out double Zx, out double Zy, out double Zz,
                      out double Xx, out double Xy, out double Xz);
 
    void GetBasicProperties (in GEOM_Object theShape,
                             in double theTolerance,
                             out double theLength,
                             out double theSurfArea,
                             out double theVolume);
 
    GEOM_Object GetCentreOfMass (in GEOM_Object theShape);
 
    /*
     *  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 theUseOri To consider edge/wire orientation or not
     *  \return New GEOM_Object, vertex.
     */
    GEOM_Object GetVertexByIndex( in GEOM_Object theShape, in long theIndex, in boolean theUseOri );
 
    GEOM_Object GetNormal (in GEOM_Object theFace,
                           in GEOM_Object theOptionalPoint);
 
    void GetInertia (in GEOM_Object theShape,
                     out double I11, out double I12, out double I13,
                     out double I21, out double I22, out double I23,
                     out double I31, out double I32, out double I33,
                     out double Ix , out double Iy , out double Iz);
 
    void GetBoundingBox (in GEOM_Object theShape,
                         in boolean precise,
                         out double Xmin, out double Xmax,
                         out double Ymin, out double Ymax,
                         out double Zmin, out double Zmax);
 
    GEOM_Object MakeBoundingBox (in GEOM_Object theShape,
                                 in boolean precise);
 
    void GetTolerance (in GEOM_Object theShape,
                       out double FaceMin, out double FaceMax,
                       out double EdgeMin, out double EdgeMax,
                       out double VertMin, out double VertMax);
 
    enum ShapeErrorType
    {
      /* for vertices */
      InvalidPointOnCurve,
      InvalidPointOnCurveOnSurface,
      InvalidPointOnSurface,
 
      /* for edges */
      No3DCurve,
      Multiple3DCurve,
      Invalid3DCurve,
      NoCurveOnSurface,
      InvalidCurveOnSurface,
      InvalidCurveOnClosedSurface,
      InvalidSameRangeFlag,
      InvalidSameParameterFlag,
      InvalidDegeneratedFlag,
 
      FreeEdge,
      InvalidMultiConnexity,
      InvalidRange,
 
      /* for wires */
      EmptyWire,
      RedundantEdge,
      SelfIntersectingWire, /* on a face */
 
      /* for faces */
      NoSurface,
      InvalidWire,
      RedundantWire,
      IntersectingWires,
      InvalidImbricationOfWires,
 
      /* for shells */
      EmptyShell,
      RedundantFace,
 
      /* for shapes */
      UnorientableShape,
      NotClosed,
      NotConnected,
 
      SubshapeNotInShape,
 
      BadOrientation,
      BadOrientationOfSubshape,
 
      InvalidToleranceValue,
 
      /* for exception */
      CheckFail
    };
 
    struct ShapeError
    {
      ShapeErrorType error;
      ListOfLong     incriminated;
    };
 
    typedef sequence<ShapeError> ShapeErrors;
 
    boolean CheckShape (in GEOM_Object  theShape,
                        out ShapeErrors theErrors);
 
    boolean CheckShapeWithGeometry (in GEOM_Object  theShape,
                                    out ShapeErrors theErrors);
 
    string PrintShapeErrors (in GEOM_Object theShape,
                             in ShapeErrors theErrors);
 
    // /*!
    //  *  \brief Extract and identify any problem in the source shapes used in a Boolean Operation.
    //  *  \param theShapes Shapes being used in the Boolean Operation
    //  *  \param theUseTimer Whether to chronometrize computation time
    //  *  \param theTopoOnly Whether to check topology only
    //  *  \param theRunParallel Whether to run the computations in parallel
    //  *  \param theDoExact Whether to perform exact checking
    //  *  \param theResultShape Output parameter. The result of BOP General Fuse. Indices of its sub-shapes are reported in theErrors structure.
    //  *  \param theErrors Output parameter. Structure, containing discovered errors and incriminated sub-shapes.
    //  *  \return TRUE, if the input shapes "seem to be valid" for BOP.
    //  */
    boolean ExtractBOPFailure (in ListOfGO     theShapes,
                               in boolean      theUseTimer,
                               in boolean      theTopoOnly,
                               in boolean      theRunParallel,
                               in boolean      theDoExact,
                               out GEOM_Object theResultShape,
                               out ShapeErrors theErrors);
 
    boolean CheckSelfIntersections (in GEOM_Object theShape,
                                    in long        theCheckLevel,
                                    out ListOfLong theIntersections);
 
    boolean CheckSelfIntersectionsFast (in GEOM_Object theShape,
                         in float       theDeflection,
                         in double      theTolerance,
                         out ListOfLong theIntersections);
 
    boolean CheckBOPArguments (in GEOM_Object theShape);
 
    boolean FastIntersect (in GEOM_Object theShape1,
                  in GEOM_Object theShape2,
                  in double      theTolerance,
                  in float       theDeflection,
                  out ListOfLong theIntersections1,
                  out ListOfLong theIntersections2);
 
    string IsGoodForSolid (in GEOM_Object theShape);
 
    string WhatIs (in GEOM_Object theShape);
 
    ListOfBool AreCoordsInside(in GEOM_Object theShape, in ListOfDouble coords, in double tolerance);
 
    double GetMinDistance (in GEOM_Object theShape1, in GEOM_Object theShape2,
                           out double X1, out double Y1, out double Z1,
                           out double X2, out double Y2, out double Z2);
 
    long ClosestPoints (in GEOM_Object theShape1,
                        in GEOM_Object theShape2,
                        out ListOfDouble theCoords);
 
    double GetAngle (in GEOM_Object theShape1, in GEOM_Object theShape2);
 
    double GetAngleBtwVectors (in GEOM_Object theShape1, in GEOM_Object theShape2);
 
    ListOfGO PatchFace(in GEOM_Object theShape);
 
    void PointCoordinates (in GEOM_Object theShape, out double X, out double Y, out double Z);
 
    double CurveCurvatureByParam (in GEOM_Object theShape, in double theParam);
 
    double CurveCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
 
    double MaxSurfaceCurvatureByParam (in GEOM_Object theShape, in double theUParam,
                                       in double theVParam);
 
    double MaxSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
 
    double MinSurfaceCurvatureByParam (in GEOM_Object theShape, in double theUParam,
                                       in double theVParam);
 
    double MinSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
 
    GEOM_Object SurfaceCurvatureByPointAndDirection (in GEOM_Object theShape,
                                                     in GEOM_Object thePoint,
                                                     in GEOM_Object theDirection);
 
    ListOfDouble XYZtoUV(in GEOM_Object  theSurf,
                         in ListOfDouble theXYZlist,
                         in boolean      theIsNormalized);
 
    ListOfDouble UVtoXYZ(in GEOM_Object  theSurf,
                         in ListOfDouble theUVlist,
                         in boolean      theIsNormalized);
 
 
    struct PairOfShape
    {
      GEOM_Object first;
      GEOM_Object second;
    };
 
    struct CheckResult
    {
      long  type;
      PairOfShape failedShapes;
    };
 
    typedef sequence<PairOfShape> SequenceOfPairOfShape;
    typedef sequence<CheckResult> CheckResults;
 
    CheckResults CheckConformityShape(in GEOM_Object theShape);
 
    SequenceOfPairOfShape SelfIntersected2D(in CheckResults theResults);
 
    SequenceOfPairOfShape InterferingSubshapes(in CheckResults theResults,
                                               in long theShapeType1,
                                               in long theShapeType2);
 
    ListOfGO SmallEdges(in CheckResults theResults);
 
    SequenceOfPairOfShape DistantShapes(in CheckResults theResults,
                                        in long theShapeType,
                                        in long theSubShapeType,
                                        in double theTolerance);
 
    double UpdateTolerance(in GEOM_Object theShape);
 
    GEOM_Object ShapeProximityCalculator(in GEOM_Object theShape1, in GEOM_Object theShape2);
 
    void SetShapeSampling(in GEOM_Object theCalculator,
                          in GEOM_Object theShape,
                          in long theNbSamples);
 
    double GetCoarseProximity(in GEOM_Object theCalculator);
 
    double GetPreciseProximity(in GEOM_Object theCalculator);
 
  };
 
 // # GEOM_IGroupOperations:
  interface GEOM_IGroupOperations : GEOM_IOperations
  {
    GEOM_Object CreateGroup (in GEOM_Object theMainShape, in long theShapeType);
 
    void AddObject (in GEOM_Object theGroup, in long theSubShapeId);
 
    void RemoveObject (in GEOM_Object theGroup, in long theSubShapeId);
 
    void UnionList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
 
    void DifferenceList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
 
    void UnionIDs (in GEOM_Object theGroup, in ListOfLong theSubShapes);
 
    void DifferenceIDs (in GEOM_Object theGroup, in ListOfLong theSubShapes);
 
    GEOM_Object UnionGroups (in GEOM_Object theGroup1, in GEOM_Object theGroup2);
 
    GEOM_Object IntersectGroups (in GEOM_Object theGroup1, in GEOM_Object theGroup2);
 
    GEOM_Object CutGroups (in GEOM_Object theGroup1, in GEOM_Object theGroup2);
 
    GEOM_Object UnionListOfGroups (in ListOfGO theGList);
 
    GEOM_Object IntersectListOfGroups (in ListOfGO theGList);
 
    GEOM_Object CutListOfGroups (in ListOfGO theGList1,
                                 in ListOfGO theGList2);
 
    long GetType (in GEOM_Object theGroup);
 
    GEOM_Object GetMainShape (in GEOM_Object theGroup);
 
    ListOfLong GetObjects (in GEOM_Object theGroup);
  };
 
  // # GEOM_IFieldOperations:
  interface GEOM_IFieldOperations : GEOM_IOperations
  {
    GEOM_Field CreateField(in GEOM_Object     shape, 
                           in string          name,
                           in field_data_type type,
                           in short           dimension,
                           in string_array    componentNames);
    long CountFields(in GEOM_Object shape);
 
    ListOfFields GetFields(in GEOM_Object shape);
 
    GEOM_Field GetField(in GEOM_Object shape, in string name);
 
    long GetNbSubShapes(in GEOM_Object shape, in short fieldDim);
  };
 
  // # GEOM_ITestOperations:
  interface GEOM_ITestOperations : GEOM_IOperations
  {
    boolean Tesselate(in GEOM_Object shape, in double linearDeflection,
                      in boolean isRelative, in double angularDeflection);
  };
 
  // # GEOM_ICanonicalRecognition:
  interface GEOM_ICanonicalRecognition : GEOM_IOperations
  {
    boolean isPlane(in GEOM_Object shape, in double tolerance, inout ListOfDouble normal, inout ListOfDouble origin);
 
    boolean isSphere(in GEOM_Object shape, in double tolerance, inout ListOfDouble origin, inout double radius);
 
    boolean isCone(in GEOM_Object shape, in double tolerance, inout ListOfDouble axis, inout ListOfDouble apex, inout double halfAngle);
 
    boolean isCylinder(in GEOM_Object shape, in double tolerance, inout ListOfDouble axis, inout ListOfDouble origin, inout double radius);
 
    boolean isLine(in GEOM_Object edge, in double tolerance, inout ListOfDouble direction, inout ListOfDouble origin);
 
    boolean isCircle(in GEOM_Object edge, in double tolerance, inout ListOfDouble normal, inout ListOfDouble origin, inout double radius);
 
    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:
  interface GEOM_Gen : Engines::EngineComponent,SALOMEDS::Driver
  {
    void Undo ();
 
    void Redo ();
 
    SALOMEDS::SObject AddInStudy (in GEOM_BaseObject theObject,
                                  in string          theName,
                                  in GEOM_BaseObject theFather);
 
    ListOfGO RestoreSubShapesO (in GEOM_Object       theObject,
                                in ListOfGO          theArgs,
                                in find_shape_method theFindMethod,
                                in boolean           theInheritFirstArg,
                                in boolean           theAddPrefix);
 
    ListOfGO RestoreGivenSubShapesO (in GEOM_Object       theObject,
                                     in ListOfGO          theArgs,
                                     in find_shape_method theFindMethod,
                                     in boolean           theInheritFirstArg,
                                     in boolean           theAddPrefix);
 
    ListOfGO RestoreSubShapesSO (in SALOMEDS::SObject theSObject,
                                 in ListOfGO          theArgs,
                                 in find_shape_method theFindMethod,
                                 in boolean           theInheritFirstArg,
                                 in boolean           theAddPrefix);
 
    // #  Methods to access interfaces for objects creation and transformation
 
    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
 
 
    void RemoveObject (in GEOM_BaseObject theObject);
 
    GEOM_BaseObject GetObject (in string theEntry);
 
    GEOM_Object AddSubShape (in GEOM_Object theMainShape, in ListOfLong theIndices);
 
 // #  GEOM_Objects IOR Management
    
    GEOM_Object GetIORFromString (in string theIOR);
 
    string GetStringFromIOR (in GEOM_Object theObject);
 
    string GetDumpName (in string theStudyEntry);
 
    string_array GetAllDumpNames();
 
    ListOfGO PublishNamedShapesInStudy(//in SObject theSObject,
                                       in Object theObject);
 
    SALOMEDS::SObject CreateFolder (in string theName,
                        in SALOMEDS::SObject theFather);
 
    void MoveToFolder (in GEOM_Object theObject,
                 in SALOMEDS::SObject theFolder);
 
    void MoveListToFolder (in ListOfGO theListOfGO,
                  in SALOMEDS::SObject theFolder);
 
    void Move( in object_list what, 
            in SALOMEDS::SObject where, 
            in long row );
 
    SALOMEDS::TMPFile GetDependencyTree(in string_array theListOfEntries);
 
    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);
  };
};
 
#endif