src/SMESH_I/SMESH_Filter_i.hxx

   1 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Filter_i.hxx
  25 //  Author : Alexey Petrov, OCC
  26 //  Module : SMESH
  27
  28 #ifndef _SMESH_FILTER_I_HXX_
  29 #define _SMESH_FILTER_I_HXX_
  30
  31 #include <SALOMEconfig.h>
  32 #include CORBA_SERVER_HEADER(SMESH_Filter)
  33
  34 #include <LDOM_Document.hxx>
  35 #include <TopoDS_Shape.hxx>
  36
  37 #include "SALOME_GenericObj_i.hh"
  38 #include "SMESH_ControlsDef.hxx"
  39
  40 class SMESHDS_Mesh;
  41
  42 namespace SMESH
  43 {
  44
  45   namespace Controls
  46   {
  47
  48     /*
  49       Class       : BelongToGeom
  50       Description : Predicate for verifying whether entiy belong to
  51       specified geometrical support
  52     */
  53     class BelongToGeom: public virtual Predicate
  54     {
  55     public:
  56       BelongToGeom();
  57
  58       virtual void                    SetMesh( const SMDS_Mesh* theMesh );
  59       virtual void                    SetGeom( const TopoDS_Shape& theShape );
  60
  61       virtual bool                    IsSatisfy( long theElementId );
  62
  63       virtual void                    SetType( SMDSAbs_ElementType theType );
  64       virtual                         SMDSAbs_ElementType GetType() const;
  65
  66       TopoDS_Shape                    GetShape();
  67       const SMESHDS_Mesh*             GetMeshDS() const;
  68
  69     private:
  70       TopoDS_Shape                    myShape;
  71       const SMESHDS_Mesh*             myMeshDS;
  72       SMDSAbs_ElementType             myType;
  73     };
  74     typedef boost::shared_ptr<BelongToGeom> BelongToGeomPtr;
  75
  76     /*
  77       Class       : LyingOnGeom
  78       Description : Predicate for verifying whether entiy lying or partially lying on
  79       specified geometrical support
  80     */
  81     class LyingOnGeom: public virtual Predicate
  82     {
  83     public:
  84       LyingOnGeom();
  85
  86       virtual void                    SetMesh( const SMDS_Mesh* theMesh );
  87       virtual void                    SetGeom( const TopoDS_Shape& theShape );
  88
  89       virtual bool                    IsSatisfy( long theElementId );
  90
  91       virtual void                    SetType( SMDSAbs_ElementType theType );
  92       virtual                         SMDSAbs_ElementType GetType() const;
  93
  94       TopoDS_Shape                    GetShape();
  95       const SMESHDS_Mesh*             GetMeshDS() const;
  96
  97       virtual bool                    Contains( const SMESHDS_Mesh*     theMeshDS,
  98                                                 const TopoDS_Shape&     theShape,
  99                                                 const SMDS_MeshElement* theElem,
 100                                                 TopAbs_ShapeEnum        theFindShapeEnum,
 101                                                 TopAbs_ShapeEnum        theAvoidShapeEnum = TopAbs_SHAPE );
 102     private:
 103       TopoDS_Shape                    myShape;
 104       const SMESHDS_Mesh*             myMeshDS;
 105       SMDSAbs_ElementType             myType;
 106     };
 107     typedef boost::shared_ptr<LyingOnGeom> LyingOnGeomPtr;
 108   }
 109
 110   /*
 111     FUNCTORS
 112   */
 113
 114   /*
 115     Class       : Functor_i
 116     Description : An abstact class for all functors
 117   */
 118   class Functor_i: public virtual POA_SMESH::Functor,
 119                    public virtual SALOME::GenericObj_i
 120   {
 121   public:
 122     void                            SetMesh( SMESH_Mesh_ptr theMesh );
 123     Controls::FunctorPtr            GetFunctor(){ return myFunctorPtr;}
 124     ElementType                     GetElementType();
 125
 126   protected:
 127     Functor_i();
 128     ~Functor_i();
 129   protected:
 130     Controls::FunctorPtr            myFunctorPtr;
 131   };
 132
 133   /*
 134     Class       : NumericalFunctor_i
 135     Description : Base class for numerical functors
 136   */
 137   class NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
 138                             public virtual Functor_i
 139   {
 140   public:
 141     CORBA::Double                   GetValue( CORBA::Long theElementId );
 142     void                            SetPrecision( CORBA::Long thePrecision );
 143     CORBA::Long                     GetPrecision();
 144     Controls::NumericalFunctorPtr   GetNumericalFunctor();
 145
 146   protected:
 147     Controls::NumericalFunctorPtr   myNumericalFunctorPtr;
 148   };
 149
 150
 151   /*
 152     Class       : SMESH_MinimumAngleFunct
 153     Description : Functor for calculation of minimum angle
 154   */
 155   class MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
 156                         public virtual NumericalFunctor_i
 157   {
 158   public:
 159     MinimumAngle_i();
 160     FunctorType                     GetFunctorType();
 161   };
 162
 163
 164   /*
 165     Class       : AspectRatio_i
 166     Description : Functor for calculating aspect ratio
 167   */
 168   class AspectRatio_i: public virtual POA_SMESH::AspectRatio,
 169                        public virtual NumericalFunctor_i
 170   {
 171   public:
 172     AspectRatio_i();
 173     FunctorType                     GetFunctorType();
 174   };
 175
 176
 177   /*
 178     Class       : AspectRatio3D_i
 179     Description : Functor for calculating aspect ratio for 3D
 180   */
 181   class AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
 182                          public virtual NumericalFunctor_i
 183   {
 184   public:
 185     AspectRatio3D_i();
 186     FunctorType                     GetFunctorType();
 187   };
 188
 189
 190   /*
 191     Class       : Warping_i
 192     Description : Functor for calculating warping
 193   */
 194   class Warping_i: public virtual POA_SMESH::Warping,
 195                    public virtual NumericalFunctor_i
 196   {
 197   public:
 198     Warping_i();
 199     FunctorType                     GetFunctorType();
 200   };
 201
 202
 203   /*
 204     Class       : Taper_i
 205     Description : Functor for calculating taper
 206   */
 207   class Taper_i: public virtual POA_SMESH::Taper,
 208                  public virtual NumericalFunctor_i
 209   {
 210   public:
 211     Taper_i();
 212     FunctorType                     GetFunctorType();
 213   };
 214
 215
 216   /*
 217     Class       : Skew_i
 218     Description : Functor for calculating skew in degrees
 219   */
 220   class Skew_i: public virtual POA_SMESH::Skew,
 221                 public virtual NumericalFunctor_i
 222   {
 223   public:
 224     Skew_i();
 225     FunctorType                     GetFunctorType();
 226   };
 227
 228
 229   /*
 230     Class       : Area_i
 231     Description : Functor for calculating area
 232   */
 233   class Area_i: public virtual POA_SMESH::Area,
 234                 public virtual NumericalFunctor_i
 235   {
 236   public:
 237     Area_i();
 238     FunctorType                     GetFunctorType();
 239   };
 240
 241
 242   /*
 243     Class       : Volume3D_i
 244     Description : Functor for calculating volume of 3D element
 245   */
 246   class Volume3D_i: public virtual POA_SMESH::Volume3D,
 247                     public virtual NumericalFunctor_i
 248   {
 249   public:
 250     Volume3D_i();
 251     FunctorType                     GetFunctorType();
 252   };
 253
 254
 255   /*
 256     Class       : Length_i
 257     Description : Functor for calculating length of edge
 258   */
 259   class Length_i: public virtual POA_SMESH::Length,
 260                   public virtual NumericalFunctor_i
 261   {
 262   public:
 263     Length_i();
 264     FunctorType                     GetFunctorType();
 265   };
 266
 267   /*
 268     Class       : Length2D_i
 269     Description : Functor for calculating length of edge
 270   */
 271   class Length2D_i: public virtual POA_SMESH::Length2D,
 272                     public virtual NumericalFunctor_i
 273   {
 274   public:
 275     Length2D_i();
 276     SMESH::Length2D::Values*        GetValues();
 277     FunctorType                     GetFunctorType();
 278
 279   protected:
 280     Controls::Length2DPtr          myLength2DPtr;
 281   };
 282
 283
 284   /*
 285     Class       : MultiConnection_i
 286     Description : Functor for calculating number of faces conneted to the edge
 287   */
 288   class MultiConnection_i: public virtual POA_SMESH::MultiConnection,
 289                            public virtual NumericalFunctor_i
 290   {
 291   public:
 292     MultiConnection_i();
 293     FunctorType                     GetFunctorType();
 294   };
 295
 296   /*
 297     Class       : MultiConnection2D_i
 298     Description : Functor for calculating number of faces conneted to the edge
 299   */
 300   class MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
 301                              public virtual NumericalFunctor_i
 302   {
 303   public:
 304     MultiConnection2D_i();
 305     SMESH::MultiConnection2D::Values*  GetValues();
 306     FunctorType                        GetFunctorType();
 307
 308   protected:
 309     Controls::MultiConnection2DPtr     myMulticonnection2DPtr;
 310   };
 311
 312
 313   /*
 314     PREDICATES
 315   */
 316   /*
 317     Class       : Predicate_i
 318     Description : Base class for all predicates
 319   */
 320   class Predicate_i: public virtual POA_SMESH::Predicate,
 321                      public virtual Functor_i
 322   {
 323   public:
 324     CORBA::Boolean                  IsSatisfy( CORBA::Long theElementId );
 325     Controls::PredicatePtr          GetPredicate();
 326
 327   protected:
 328     Controls::PredicatePtr          myPredicatePtr;
 329   };
 330
 331
 332   /*
 333     Class       : BadOrientedVolume_i
 334     Description : Verify whether a mesh volume is incorrectly oriented from
 335     the point of view of MED convention
 336   */
 337   class BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
 338                              public virtual Predicate_i
 339   {
 340   public:
 341     BadOrientedVolume_i();
 342     FunctorType                     GetFunctorType();
 343   };
 344
 345   /*
 346     Class       : BelongToGeom_i
 347     Description : Predicate for selection on geometrical support
 348   */
 349   class BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
 350                         public virtual Predicate_i
 351   {
 352   public:
 353     BelongToGeom_i();
 354     virtual                         ~BelongToGeom_i();
 355
 356     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 357     void                            SetElementType( ElementType theType );
 358     FunctorType                     GetFunctorType();
 359
 360     void                            SetGeom( const TopoDS_Shape& theShape );
 361
 362     void                            SetShapeName( const char* theName );
 363     char*                           GetShapeName();
 364
 365   protected:
 366     Controls::BelongToGeomPtr       myBelongToGeomPtr;
 367     char*                           myShapeName;
 368   };
 369
 370   /*
 371     Class       : BelongToSurface_i
 372     Description : Verify whether mesh element lie in pointed Geom planar object
 373   */
 374   class BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
 375                            public virtual Predicate_i
 376   {
 377   public:
 378     BelongToSurface_i( const Handle(Standard_Type)& );
 379     virtual                         ~BelongToSurface_i();
 380
 381     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 382
 383     void                            SetShapeName( const char* theName, ElementType theType );
 384     char*                           GetShapeName();
 385
 386     void                            SetTolerance( CORBA::Double );
 387     CORBA::Double                   GetTolerance();
 388
 389   protected:
 390     Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
 391     char*                           myShapeName;
 392     Handle(Standard_Type)           mySurfaceType;
 393   };
 394
 395   /*
 396     Class       : BelongToPlane_i
 397     Description : Verify whether mesh element lie in pointed Geom planar object
 398   */
 399   class BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
 400                          public virtual BelongToSurface_i
 401   {
 402   public:
 403     BelongToPlane_i();
 404     void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 405     FunctorType                     GetFunctorType();
 406   };
 407
 408   /*
 409     Class       : BelongToCylinder_i
 410     Description : Verify whether mesh element lie in pointed Geom cylindrical object
 411   */
 412   class BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
 413                             public virtual BelongToSurface_i
 414   {
 415   public:
 416     BelongToCylinder_i();
 417     void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 418     FunctorType                     GetFunctorType();
 419   };
 420
 421   /*
 422     Class       : LyingOnGeom_i
 423     Description : Predicate for selection on geometrical support(lying or partially lying)
 424   */
 425   class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
 426                        public virtual Predicate_i
 427   {
 428   public:
 429     LyingOnGeom_i();
 430     virtual                         ~LyingOnGeom_i();
 431
 432     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 433     void                            SetElementType( ElementType theType );
 434     FunctorType                     GetFunctorType();
 435
 436     void                            SetGeom( const TopoDS_Shape& theShape );
 437
 438     void                            SetShapeName( const char* theName );
 439     char*                           GetShapeName();
 440
 441   protected:
 442     Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
 443     char*                           myShapeName;
 444   };
 445
 446   /*
 447     Class       : FreeBorders_i
 448     Description : Predicate for free borders
 449   */
 450   class FreeBorders_i: public virtual POA_SMESH::FreeBorders,
 451                        public virtual Predicate_i
 452   {
 453   public:
 454     FreeBorders_i();
 455     FunctorType                     GetFunctorType();
 456   };
 457
 458
 459   /*
 460     Class       : FreeEdges_i
 461     Description : Predicate for free edges
 462   */
 463   class FreeEdges_i: public virtual POA_SMESH::FreeEdges,
 464                      public virtual Predicate_i
 465   {
 466   public:
 467     FreeEdges_i();
 468     SMESH::FreeEdges::Borders*      GetBorders();
 469     FunctorType                     GetFunctorType();
 470
 471   protected:
 472     Controls::FreeEdgesPtr          myFreeEdgesPtr;
 473   };
 474
 475
 476   /*
 477     Class       : RangeOfIds_i
 478     Description : Predicate for Range of Ids
 479   */
 480   class RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
 481                       public virtual Predicate_i
 482   {
 483   public:
 484     RangeOfIds_i();
 485     void                            SetRange( const SMESH::long_array& theIds );
 486     CORBA::Boolean                  SetRangeStr( const char* theRange );
 487     char*                           GetRangeStr();
 488
 489     void                            SetElementType( ElementType theType );
 490     FunctorType                     GetFunctorType();
 491
 492   protected:
 493     Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
 494   };
 495
 496   /*
 497     Class       : Comparator_i
 498     Description : Base class for comparators
 499   */
 500   class Comparator_i: public virtual POA_SMESH::Comparator,
 501                       public virtual Predicate_i
 502   {
 503   public:
 504     virtual                         ~Comparator_i();
 505
 506     virtual void                    SetMargin( CORBA::Double );
 507     virtual void                    SetNumFunctor( NumericalFunctor_ptr );
 508
 509     Controls::ComparatorPtr         GetComparator();
 510     NumericalFunctor_i*             GetNumFunctor_i();
 511     CORBA::Double                   GetMargin();
 512
 513   protected:
 514     Comparator_i();
 515   protected:
 516     Controls::ComparatorPtr         myComparatorPtr;
 517     NumericalFunctor_i*             myNumericalFunctor;
 518   };
 519
 520
 521   /*
 522     Class       : LessThan_i
 523     Description : Comparator "<"
 524   */
 525   class LessThan_i: public virtual POA_SMESH::LessThan,
 526                     public virtual Comparator_i
 527   {
 528   public:
 529     LessThan_i();
 530     FunctorType                     GetFunctorType();
 531   };
 532
 533
 534   /*
 535     Class       : MoreThan_i
 536     Description : Comparator ">"
 537   */
 538   class MoreThan_i: public virtual POA_SMESH::MoreThan,
 539                     public virtual Comparator_i
 540   {
 541   public:
 542     MoreThan_i();
 543     FunctorType                     GetFunctorType();
 544   };
 545
 546
 547   /*
 548     Class       : EqualTo_i
 549     Description : Comparator "="
 550   */
 551   class EqualTo_i: public virtual POA_SMESH::EqualTo,
 552                    public virtual Comparator_i
 553   {
 554   public:
 555     EqualTo_i();
 556     virtual void                    SetTolerance( CORBA::Double );
 557     CORBA::Double                   GetTolerance();
 558     FunctorType                     GetFunctorType();
 559
 560   protected:
 561     Controls::EqualToPtr            myEqualToPtr;
 562   };
 563
 564
 565   /*
 566     Class       : LogicalNOT_i
 567     Description : Logical NOT predicate
 568   */
 569   class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
 570                       public virtual Predicate_i
 571   {
 572   public:
 573     LogicalNOT_i();
 574   virtual                         ~LogicalNOT_i();
 575
 576     virtual void                    SetPredicate( Predicate_ptr );
 577     Predicate_i*                    GetPredicate_i();
 578     FunctorType                     GetFunctorType();
 579
 580   protected:
 581     Controls::LogicalNOTPtr         myLogicalNOTPtr;
 582     Predicate_i*                    myPredicate;
 583   };
 584
 585
 586   /*
 587     Class       : LogicalBinary_i
 588     Description : Base class for binary logical predicate
 589   */
 590   class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
 591                          public virtual Predicate_i
 592   {
 593   public:
 594     virtual                         ~LogicalBinary_i();
 595     virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
 596     virtual void                    SetPredicate1( Predicate_ptr );
 597     virtual void                    SetPredicate2( Predicate_ptr );
 598
 599     Controls::LogicalBinaryPtr      GetLogicalBinary();
 600     Predicate_i*                    GetPredicate1_i();
 601     Predicate_i*                    GetPredicate2_i();
 602
 603   protected:
 604     LogicalBinary_i();
 605   protected:
 606     Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
 607     Predicate_i*                    myPredicate1;
 608     Predicate_i*                    myPredicate2;
 609   };
 610
 611
 612   /*
 613     Class       : LogicalAND_i
 614     Description : Logical AND
 615   */
 616   class LogicalAND_i: public virtual POA_SMESH::LogicalAND,
 617                       public virtual LogicalBinary_i
 618   {
 619   public:
 620     LogicalAND_i();
 621     FunctorType                     GetFunctorType();
 622   };
 623
 624
 625   /*
 626     Class       : LogicalOR_i
 627     Description : Logical OR
 628   */
 629   class LogicalOR_i: public virtual POA_SMESH::LogicalOR,
 630                      public virtual LogicalBinary_i
 631   {
 632   public:
 633     LogicalOR_i();
 634     FunctorType                     GetFunctorType();
 635   };
 636
 637
 638   /*
 639     FILTER
 640   */
 641   class Filter_i: public virtual POA_SMESH::Filter,
 642                   public virtual SALOME::GenericObj_i
 643   {
 644   public:
 645     Filter_i();
 646     ~Filter_i();
 647
 648     virtual
 649     void
 650     SetPredicate( Predicate_ptr );
 651
 652     virtual
 653     void
 654     SetMesh( SMESH_Mesh_ptr );
 655
 656     virtual
 657     SMESH::long_array*
 658     GetIDs();
 659
 660     static
 661     void
 662     GetElementsId( Predicate_i*,
 663                    const SMDS_Mesh*,
 664                    Controls::Filter::TIdSequence& );
 665     static
 666     void
 667     GetElementsId( Predicate_i*,
 668                    SMESH_Mesh_ptr,
 669                    Controls::Filter::TIdSequence& );
 670
 671     virtual
 672     long_array*
 673     GetElementsId( SMESH_Mesh_ptr );
 674
 675     virtual
 676     ElementType
 677     GetElementType();
 678
 679     virtual
 680     CORBA::Boolean
 681     GetCriteria( SMESH::Filter::Criteria_out theCriteria );
 682
 683     virtual
 684     CORBA::Boolean
 685     SetCriteria( const SMESH::Filter::Criteria& theCriteria );
 686
 687     virtual
 688     Predicate_ptr
 689     GetPredicate();
 690
 691     Predicate_i*     GetPredicate_i();
 692
 693   private:
 694     Controls::Filter myFilter;
 695     Predicate_i*     myPredicate;
 696     SMESH_Mesh_var   myMesh;
 697   };
 698
 699
 700   /*
 701     FILTER LIBRARY
 702   */
 703   class FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
 704                          public virtual SALOME::GenericObj_i
 705   {
 706   public:
 707     FilterLibrary_i( const char* theFileName );
 708     FilterLibrary_i();
 709     ~FilterLibrary_i();
 710
 711     Filter_ptr              Copy( const char* theFilterName );
 712
 713     CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
 714     CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
 715     CORBA::Boolean          Delete  ( const char* theFilterName );
 716     CORBA::Boolean          Replace ( const char* theFilterName,
 717                                       const char* theNewName,
 718                                       Filter_ptr  theFilter );
 719
 720     CORBA::Boolean          Save();
 721     CORBA::Boolean          SaveAs( const char* aFileName );
 722
 723     CORBA::Boolean          IsPresent( const char* aFilterName );
 724     CORBA::Long             NbFilters( ElementType );
 725     string_array*           GetNames( ElementType );
 726     string_array*           GetAllNames();
 727     void                    SetFileName( const char* theFileName );
 728     char*                   GetFileName();
 729
 730   private:
 731     char*                   myFileName;
 732     LDOM_Document           myDoc;
 733     FilterManager_var       myFilterMgr;
 734   };
 735
 736
 737   /*
 738     FILTER MANAGER
 739   */
 740
 741   class FilterManager_i: public virtual POA_SMESH::FilterManager,
 742                          public virtual SALOME::GenericObj_i
 743   {
 744   public:
 745     FilterManager_i();
 746     ~FilterManager_i();
 747
 748     MinimumAngle_ptr          CreateMinimumAngle();
 749     AspectRatio_ptr           CreateAspectRatio();
 750     AspectRatio3D_ptr         CreateAspectRatio3D();
 751     Warping_ptr               CreateWarping();
 752     Taper_ptr                 CreateTaper();
 753     Skew_ptr                  CreateSkew();
 754     Area_ptr                  CreateArea();
 755     Volume3D_ptr              CreateVolume3D();
 756     Length_ptr                CreateLength();
 757     Length2D_ptr              CreateLength2D();
 758     MultiConnection_ptr       CreateMultiConnection();
 759     MultiConnection2D_ptr     CreateMultiConnection2D();
 760
 761     BelongToGeom_ptr          CreateBelongToGeom();
 762     BelongToPlane_ptr         CreateBelongToPlane();
 763     BelongToCylinder_ptr      CreateBelongToCylinder();
 764
 765     LyingOnGeom_ptr           CreateLyingOnGeom();
 766
 767     FreeBorders_ptr           CreateFreeBorders();
 768     FreeEdges_ptr             CreateFreeEdges();
 769
 770     RangeOfIds_ptr            CreateRangeOfIds();
 771
 772     BadOrientedVolume_ptr     CreateBadOrientedVolume();
 773
 774     LessThan_ptr              CreateLessThan();
 775     MoreThan_ptr              CreateMoreThan();
 776     EqualTo_ptr               CreateEqualTo();
 777
 778     LogicalNOT_ptr            CreateLogicalNOT();
 779     LogicalAND_ptr            CreateLogicalAND();
 780     LogicalOR_ptr             CreateLogicalOR();
 781
 782     Filter_ptr                CreateFilter();
 783
 784     FilterLibrary_ptr         LoadLibrary( const char* aFileName );
 785     FilterLibrary_ptr         CreateLibrary();
 786     CORBA::Boolean            DeleteLibrary( const char* aFileName );
 787   };
 788
 789
 790   Predicate_i*
 791   GetPredicate( SMESH::Predicate_ptr thePredicate );
 792 }
 793
 794
 795 #endif