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     void                            SetShape( const char* theID, const char* theName );
 364     char*                           GetShapeName();
 365     char*                           GetShapeID();
 366
 367   protected:
 368     Controls::BelongToGeomPtr       myBelongToGeomPtr;
 369     char*                           myShapeName;
 370     char*                           myShapeID;
 371   };
 372
 373   /*
 374     Class       : BelongToSurface_i
 375     Description : Verify whether mesh element lie in pointed Geom planar object
 376   */
 377   class BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
 378                            public virtual Predicate_i
 379   {
 380   public:
 381     BelongToSurface_i( const Handle(Standard_Type)& );
 382     virtual                         ~BelongToSurface_i();
 383
 384     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 385
 386     void                            SetShapeName( const char* theName, ElementType theType );
 387     void                            SetShape( const char* theID, const char* theName, ElementType theType );
 388     char*                           GetShapeName();
 389     char*                           GetShapeID();
 390
 391     void                            SetTolerance( CORBA::Double );
 392     CORBA::Double                   GetTolerance();
 393
 394   protected:
 395     Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
 396     char*                           myShapeName;
 397     char*                           myShapeID;
 398     Handle(Standard_Type)           mySurfaceType;
 399   };
 400
 401   /*
 402     Class       : BelongToPlane_i
 403     Description : Verify whether mesh element lie in pointed Geom planar object
 404   */
 405   class BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
 406                          public virtual BelongToSurface_i
 407   {
 408   public:
 409     BelongToPlane_i();
 410     void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 411     FunctorType                     GetFunctorType();
 412   };
 413
 414   /*
 415     Class       : BelongToCylinder_i
 416     Description : Verify whether mesh element lie in pointed Geom cylindrical object
 417   */
 418   class BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
 419                             public virtual BelongToSurface_i
 420   {
 421   public:
 422     BelongToCylinder_i();
 423     void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 424     FunctorType                     GetFunctorType();
 425   };
 426
 427   /*
 428     Class       : LyingOnGeom_i
 429     Description : Predicate for selection on geometrical support(lying or partially lying)
 430   */
 431   class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
 432                        public virtual Predicate_i
 433   {
 434   public:
 435     LyingOnGeom_i();
 436     virtual                         ~LyingOnGeom_i();
 437
 438     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 439     void                            SetElementType( ElementType theType );
 440     FunctorType                     GetFunctorType();
 441
 442     void                            SetGeom( const TopoDS_Shape& theShape );
 443
 444     void                            SetShapeName( const char* theName );
 445     void                            SetShape( const char* theID, const char* theName );
 446     char*                           GetShapeName();
 447     char*                           GetShapeID();
 448
 449   protected:
 450     Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
 451     char*                           myShapeName;
 452     char*                           myShapeID;
 453   };
 454
 455   /*
 456     Class       : FreeBorders_i
 457     Description : Predicate for free borders
 458   */
 459   class FreeBorders_i: public virtual POA_SMESH::FreeBorders,
 460                        public virtual Predicate_i
 461   {
 462   public:
 463     FreeBorders_i();
 464     FunctorType                     GetFunctorType();
 465   };
 466
 467
 468   /*
 469     Class       : FreeEdges_i
 470     Description : Predicate for free edges
 471   */
 472   class FreeEdges_i: public virtual POA_SMESH::FreeEdges,
 473                      public virtual Predicate_i
 474   {
 475   public:
 476     FreeEdges_i();
 477     SMESH::FreeEdges::Borders*      GetBorders();
 478     FunctorType                     GetFunctorType();
 479
 480   protected:
 481     Controls::FreeEdgesPtr          myFreeEdgesPtr;
 482   };
 483
 484
 485   /*
 486     Class       : RangeOfIds_i
 487     Description : Predicate for Range of Ids
 488   */
 489   class RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
 490                       public virtual Predicate_i
 491   {
 492   public:
 493     RangeOfIds_i();
 494     void                            SetRange( const SMESH::long_array& theIds );
 495     CORBA::Boolean                  SetRangeStr( const char* theRange );
 496     char*                           GetRangeStr();
 497
 498     void                            SetElementType( ElementType theType );
 499     FunctorType                     GetFunctorType();
 500
 501   protected:
 502     Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
 503   };
 504
 505   /*
 506     Class       : Comparator_i
 507     Description : Base class for comparators
 508   */
 509   class Comparator_i: public virtual POA_SMESH::Comparator,
 510                       public virtual Predicate_i
 511   {
 512   public:
 513     virtual                         ~Comparator_i();
 514
 515     virtual void                    SetMargin( CORBA::Double );
 516     virtual void                    SetNumFunctor( NumericalFunctor_ptr );
 517
 518     Controls::ComparatorPtr         GetComparator();
 519     NumericalFunctor_i*             GetNumFunctor_i();
 520     CORBA::Double                   GetMargin();
 521
 522   protected:
 523     Comparator_i();
 524   protected:
 525     Controls::ComparatorPtr         myComparatorPtr;
 526     NumericalFunctor_i*             myNumericalFunctor;
 527   };
 528
 529
 530   /*
 531     Class       : LessThan_i
 532     Description : Comparator "<"
 533   */
 534   class LessThan_i: public virtual POA_SMESH::LessThan,
 535                     public virtual Comparator_i
 536   {
 537   public:
 538     LessThan_i();
 539     FunctorType                     GetFunctorType();
 540   };
 541
 542
 543   /*
 544     Class       : MoreThan_i
 545     Description : Comparator ">"
 546   */
 547   class MoreThan_i: public virtual POA_SMESH::MoreThan,
 548                     public virtual Comparator_i
 549   {
 550   public:
 551     MoreThan_i();
 552     FunctorType                     GetFunctorType();
 553   };
 554
 555
 556   /*
 557     Class       : EqualTo_i
 558     Description : Comparator "="
 559   */
 560   class EqualTo_i: public virtual POA_SMESH::EqualTo,
 561                    public virtual Comparator_i
 562   {
 563   public:
 564     EqualTo_i();
 565     virtual void                    SetTolerance( CORBA::Double );
 566     CORBA::Double                   GetTolerance();
 567     FunctorType                     GetFunctorType();
 568
 569   protected:
 570     Controls::EqualToPtr            myEqualToPtr;
 571   };
 572
 573
 574   /*
 575     Class       : LogicalNOT_i
 576     Description : Logical NOT predicate
 577   */
 578   class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
 579                       public virtual Predicate_i
 580   {
 581   public:
 582     LogicalNOT_i();
 583   virtual                         ~LogicalNOT_i();
 584
 585     virtual void                    SetPredicate( Predicate_ptr );
 586     Predicate_i*                    GetPredicate_i();
 587     FunctorType                     GetFunctorType();
 588
 589   protected:
 590     Controls::LogicalNOTPtr         myLogicalNOTPtr;
 591     Predicate_i*                    myPredicate;
 592   };
 593
 594
 595   /*
 596     Class       : LogicalBinary_i
 597     Description : Base class for binary logical predicate
 598   */
 599   class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
 600                          public virtual Predicate_i
 601   {
 602   public:
 603     virtual                         ~LogicalBinary_i();
 604     virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
 605     virtual void                    SetPredicate1( Predicate_ptr );
 606     virtual void                    SetPredicate2( Predicate_ptr );
 607
 608     Controls::LogicalBinaryPtr      GetLogicalBinary();
 609     Predicate_i*                    GetPredicate1_i();
 610     Predicate_i*                    GetPredicate2_i();
 611
 612   protected:
 613     LogicalBinary_i();
 614   protected:
 615     Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
 616     Predicate_i*                    myPredicate1;
 617     Predicate_i*                    myPredicate2;
 618   };
 619
 620
 621   /*
 622     Class       : LogicalAND_i
 623     Description : Logical AND
 624   */
 625   class LogicalAND_i: public virtual POA_SMESH::LogicalAND,
 626                       public virtual LogicalBinary_i
 627   {
 628   public:
 629     LogicalAND_i();
 630     FunctorType                     GetFunctorType();
 631   };
 632
 633
 634   /*
 635     Class       : LogicalOR_i
 636     Description : Logical OR
 637   */
 638   class LogicalOR_i: public virtual POA_SMESH::LogicalOR,
 639                      public virtual LogicalBinary_i
 640   {
 641   public:
 642     LogicalOR_i();
 643     FunctorType                     GetFunctorType();
 644   };
 645
 646
 647   /*
 648     FILTER
 649   */
 650   class Filter_i: public virtual POA_SMESH::Filter,
 651                   public virtual SALOME::GenericObj_i
 652   {
 653   public:
 654     Filter_i();
 655     ~Filter_i();
 656
 657     virtual
 658     void
 659     SetPredicate( Predicate_ptr );
 660
 661     virtual
 662     void
 663     SetMesh( SMESH_Mesh_ptr );
 664
 665     virtual
 666     SMESH::long_array*
 667     GetIDs();
 668
 669     static
 670     void
 671     GetElementsId( Predicate_i*,
 672                    const SMDS_Mesh*,
 673                    Controls::Filter::TIdSequence& );
 674     static
 675     void
 676     GetElementsId( Predicate_i*,
 677                    SMESH_Mesh_ptr,
 678                    Controls::Filter::TIdSequence& );
 679
 680     virtual
 681     long_array*
 682     GetElementsId( SMESH_Mesh_ptr );
 683
 684     virtual
 685     ElementType
 686     GetElementType();
 687
 688     virtual
 689     CORBA::Boolean
 690     GetCriteria( SMESH::Filter::Criteria_out theCriteria );
 691
 692     virtual
 693     CORBA::Boolean
 694     SetCriteria( const SMESH::Filter::Criteria& theCriteria );
 695
 696     virtual
 697     Predicate_ptr
 698     GetPredicate();
 699
 700     Predicate_i*     GetPredicate_i();
 701
 702   private:
 703     Controls::Filter myFilter;
 704     Predicate_i*     myPredicate;
 705     SMESH_Mesh_var   myMesh;
 706   };
 707
 708
 709   /*
 710     FILTER LIBRARY
 711   */
 712   class FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
 713                          public virtual SALOME::GenericObj_i
 714   {
 715   public:
 716     FilterLibrary_i( const char* theFileName );
 717     FilterLibrary_i();
 718     ~FilterLibrary_i();
 719
 720     Filter_ptr              Copy( const char* theFilterName );
 721
 722     CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
 723     CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
 724     CORBA::Boolean          Delete  ( const char* theFilterName );
 725     CORBA::Boolean          Replace ( const char* theFilterName,
 726                                       const char* theNewName,
 727                                       Filter_ptr  theFilter );
 728
 729     CORBA::Boolean          Save();
 730     CORBA::Boolean          SaveAs( const char* aFileName );
 731
 732     CORBA::Boolean          IsPresent( const char* aFilterName );
 733     CORBA::Long             NbFilters( ElementType );
 734     string_array*           GetNames( ElementType );
 735     string_array*           GetAllNames();
 736     void                    SetFileName( const char* theFileName );
 737     char*                   GetFileName();
 738
 739   private:
 740     char*                   myFileName;
 741     LDOM_Document           myDoc;
 742     FilterManager_var       myFilterMgr;
 743   };
 744
 745
 746   /*
 747     FILTER MANAGER
 748   */
 749
 750   class FilterManager_i: public virtual POA_SMESH::FilterManager,
 751                          public virtual SALOME::GenericObj_i
 752   {
 753   public:
 754     FilterManager_i();
 755     ~FilterManager_i();
 756
 757     MinimumAngle_ptr          CreateMinimumAngle();
 758     AspectRatio_ptr           CreateAspectRatio();
 759     AspectRatio3D_ptr         CreateAspectRatio3D();
 760     Warping_ptr               CreateWarping();
 761     Taper_ptr                 CreateTaper();
 762     Skew_ptr                  CreateSkew();
 763     Area_ptr                  CreateArea();
 764     Volume3D_ptr              CreateVolume3D();
 765     Length_ptr                CreateLength();
 766     Length2D_ptr              CreateLength2D();
 767     MultiConnection_ptr       CreateMultiConnection();
 768     MultiConnection2D_ptr     CreateMultiConnection2D();
 769
 770     BelongToGeom_ptr          CreateBelongToGeom();
 771     BelongToPlane_ptr         CreateBelongToPlane();
 772     BelongToCylinder_ptr      CreateBelongToCylinder();
 773
 774     LyingOnGeom_ptr           CreateLyingOnGeom();
 775
 776     FreeBorders_ptr           CreateFreeBorders();
 777     FreeEdges_ptr             CreateFreeEdges();
 778
 779     RangeOfIds_ptr            CreateRangeOfIds();
 780
 781     BadOrientedVolume_ptr     CreateBadOrientedVolume();
 782
 783     LessThan_ptr              CreateLessThan();
 784     MoreThan_ptr              CreateMoreThan();
 785     EqualTo_ptr               CreateEqualTo();
 786
 787     LogicalNOT_ptr            CreateLogicalNOT();
 788     LogicalAND_ptr            CreateLogicalAND();
 789     LogicalOR_ptr             CreateLogicalOR();
 790
 791     Filter_ptr                CreateFilter();
 792
 793     FilterLibrary_ptr         LoadLibrary( const char* aFileName );
 794     FilterLibrary_ptr         CreateLibrary();
 795     CORBA::Boolean            DeleteLibrary( const char* aFileName );
 796   };
 797
 798
 799   Predicate_i*
 800   GetPredicate( SMESH::Predicate_ptr thePredicate );
 801 }
 802
 803
 804 #endif