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( 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   SMESHDS_Mesh*                   GetMeshDS();
  68
  69 private:
  70   TopoDS_Shape                    myShape;
  71   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( 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   SMESHDS_Mesh*                   GetMeshDS();
  96
  97   virtual bool                    Contains( 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   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 protected:
 129   Controls::FunctorPtr            myFunctorPtr;
 130 };
 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       : Length_i
 244   Description : Functor for calculating length of edge
 245 */
 246 class Length_i: public virtual POA_SMESH::Length,
 247                 public virtual NumericalFunctor_i
 248 {
 249 public:
 250                                   Length_i();
 251   FunctorType                     GetFunctorType();
 252 };
 253
 254 /*
 255   Class       : Length2D_i
 256   Description : Functor for calculating length of edge
 257 */
 258 class Length2D_i: public virtual POA_SMESH::Length2D,
 259                   public virtual NumericalFunctor_i
 260 {
 261 public:
 262                                   Length2D_i();
 263   SMESH::Length2D::Values*        GetValues();
 264   FunctorType                     GetFunctorType();
 265
 266 protected:
 267   Controls::Length2DPtr          myLength2DPtr;
 268 };
 269
 270
 271 /*
 272   Class       : MultiConnection_i
 273   Description : Functor for calculating number of faces conneted to the edge
 274 */
 275 class MultiConnection_i: public virtual POA_SMESH::MultiConnection,
 276                          public virtual NumericalFunctor_i
 277 {
 278 public:
 279                                   MultiConnection_i();
 280   FunctorType                     GetFunctorType();
 281 };
 282
 283 /*
 284   Class       : MultiConnection2D_i
 285   Description : Functor for calculating number of faces conneted to the edge
 286 */
 287 class MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
 288                            public virtual NumericalFunctor_i
 289 {
 290 public:
 291                                      MultiConnection2D_i();
 292   SMESH::MultiConnection2D::Values*  GetValues();
 293   FunctorType                        GetFunctorType();
 294
 295 protected:
 296   Controls::MultiConnection2DPtr     myMulticonnection2DPtr;
 297 };
 298
 299
 300 /*
 301                             PREDICATES
 302 */
 303 /*
 304   Class       : Predicate_i
 305   Description : Base class for all predicates
 306 */
 307 class Predicate_i: public virtual POA_SMESH::Predicate,
 308                    public virtual Functor_i
 309 {
 310 public:
 311   CORBA::Boolean                  IsSatisfy( CORBA::Long theElementId );
 312   Controls::PredicatePtr          GetPredicate();
 313
 314 protected:
 315   Controls::PredicatePtr          myPredicatePtr;
 316 };
 317
 318
 319 /*
 320   Class       : BadOrientedVolume_i
 321   Description : Verify whether a mesh volume is incorrectly oriented from
 322                 the point of view of MED convention
 323 */
 324 class BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
 325                            public virtual Predicate_i
 326 {
 327  public:
 328   BadOrientedVolume_i();
 329   FunctorType                     GetFunctorType();
 330 };
 331
 332 /*
 333   Class       : BelongToGeom_i
 334   Description : Predicate for selection on geometrical support
 335 */
 336 class BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
 337                       public virtual Predicate_i
 338 {
 339 public:
 340                                   BelongToGeom_i();
 341   virtual                         ~BelongToGeom_i();
 342
 343   void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 344   void                            SetElementType( ElementType theType );
 345   FunctorType                     GetFunctorType();
 346
 347   void                            SetGeom( const TopoDS_Shape& theShape );
 348
 349   void                            SetShapeName( const char* theName );
 350   void                            SetShape( const char* theID, const char* theName );
 351   char*                           GetShapeName();
 352   char*                           GetShapeID();
 353
 354 protected:
 355   Controls::BelongToGeomPtr       myBelongToGeomPtr;
 356   char*                           myShapeName;
 357   char*                           myShapeID;
 358 };
 359
 360 /*
 361   Class       : BelongToSurface_i
 362   Description : Verify whether mesh element lie in pointed Geom planar object
 363 */
 364 class BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
 365                          public virtual Predicate_i
 366 {
 367 public:
 368                                   BelongToSurface_i( const Handle(Standard_Type)& );
 369   virtual                         ~BelongToSurface_i();
 370
 371   void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 372
 373   void                            SetShapeName( const char* theName, ElementType theType );
 374   void                            SetShape( const char* theID, const char* theName, ElementType theType );
 375   char*                           GetShapeName();
 376   char*                           GetShapeID();
 377
 378   void                            SetTolerance( CORBA::Double );
 379   CORBA::Double                   GetTolerance();
 380
 381 protected:
 382   Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
 383   char*                           myShapeName;
 384   char*                           myShapeID;
 385   Handle(Standard_Type)           mySurfaceType;
 386 };
 387
 388 /*
 389   Class       : BelongToPlane_i
 390   Description : Verify whether mesh element lie in pointed Geom planar object
 391 */
 392 class BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
 393                        public virtual BelongToSurface_i
 394 {
 395 public:
 396                                   BelongToPlane_i();
 397   void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 398   FunctorType                     GetFunctorType();
 399 };
 400
 401 /*
 402   Class       : BelongToCylinder_i
 403   Description : Verify whether mesh element lie in pointed Geom cylindrical object
 404 */
 405 class BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
 406                           public virtual BelongToSurface_i
 407 {
 408 public:
 409                                   BelongToCylinder_i();
 410   void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 411   FunctorType                     GetFunctorType();
 412 };
 413
 414 /*
 415   Class       : LyingOnGeom_i
 416   Description : Predicate for selection on geometrical support(lying or partially lying)
 417 */
 418 class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
 419                      public virtual Predicate_i
 420 {
 421 public:
 422                                   LyingOnGeom_i();
 423   virtual                         ~LyingOnGeom_i();
 424
 425   void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 426   void                            SetElementType( ElementType theType );
 427   FunctorType                     GetFunctorType();
 428
 429   void                            SetGeom( const TopoDS_Shape& theShape );
 430
 431   void                            SetShapeName( const char* theName );
 432   void                            SetShape( const char* theID, const char* theName );
 433   char*                           GetShapeName();
 434   char*                           GetShapeID();
 435
 436 protected:
 437   Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
 438   char*                           myShapeName;
 439   char*                           myShapeID;
 440 };
 441
 442 /*
 443   Class       : FreeBorders_i
 444   Description : Predicate for free borders
 445 */
 446 class FreeBorders_i: public virtual POA_SMESH::FreeBorders,
 447                      public virtual Predicate_i
 448 {
 449 public:
 450                                   FreeBorders_i();
 451   FunctorType                     GetFunctorType();
 452 };
 453
 454
 455 /*
 456   Class       : FreeEdges_i
 457   Description : Predicate for free edges
 458 */
 459 class FreeEdges_i: public virtual POA_SMESH::FreeEdges,
 460                    public virtual Predicate_i
 461 {
 462 public:
 463                                   FreeEdges_i();
 464   SMESH::FreeEdges::Borders*      GetBorders();
 465   FunctorType                     GetFunctorType();
 466
 467 protected:
 468   Controls::FreeEdgesPtr          myFreeEdgesPtr;
 469 };
 470
 471
 472 /*
 473   Class       : RangeOfIds_i
 474   Description : Predicate for Range of Ids
 475 */
 476 class RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
 477                     public virtual Predicate_i
 478 {
 479 public:
 480                                   RangeOfIds_i();
 481   void                            SetRange( const SMESH::long_array& theIds );
 482   CORBA::Boolean                  SetRangeStr( const char* theRange );
 483   char*                           GetRangeStr();
 484
 485   void                            SetElementType( ElementType theType );
 486   FunctorType                     GetFunctorType();
 487
 488 protected:
 489   Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
 490 };
 491
 492 /*
 493   Class       : Comparator_i
 494   Description : Base class for comparators
 495 */
 496 class Comparator_i: public virtual POA_SMESH::Comparator,
 497                     public virtual Predicate_i
 498 {
 499 public:
 500   virtual                         ~Comparator_i();
 501
 502   virtual void                    SetMargin( CORBA::Double );
 503   virtual void                    SetNumFunctor( NumericalFunctor_ptr );
 504
 505   Controls::ComparatorPtr         GetComparator();
 506   NumericalFunctor_i*             GetNumFunctor_i();
 507   CORBA::Double                   GetMargin();
 508
 509 protected:
 510                                   Comparator_i();
 511 protected:
 512   Controls::ComparatorPtr         myComparatorPtr;
 513   NumericalFunctor_i*             myNumericalFunctor;
 514 };
 515
 516
 517 /*
 518   Class       : LessThan_i
 519   Description : Comparator "<"
 520 */
 521 class LessThan_i: public virtual POA_SMESH::LessThan,
 522                   public virtual Comparator_i
 523 {
 524 public:
 525                                   LessThan_i();
 526   FunctorType                     GetFunctorType();
 527 };
 528
 529
 530 /*
 531   Class       : MoreThan_i
 532   Description : Comparator ">"
 533 */
 534 class MoreThan_i: public virtual POA_SMESH::MoreThan,
 535                   public virtual Comparator_i
 536 {
 537 public:
 538                                   MoreThan_i();
 539   FunctorType                     GetFunctorType();
 540 };
 541
 542
 543 /*
 544   Class       : EqualTo_i
 545   Description : Comparator "="
 546 */
 547 class EqualTo_i: public virtual POA_SMESH::EqualTo,
 548                  public virtual Comparator_i
 549 {
 550 public:
 551                                   EqualTo_i();
 552   virtual void                    SetTolerance( CORBA::Double );
 553   CORBA::Double                   GetTolerance();
 554   FunctorType                     GetFunctorType();
 555
 556 protected:
 557   Controls::EqualToPtr            myEqualToPtr;
 558 };
 559
 560
 561 /*
 562   Class       : LogicalNOT_i
 563   Description : Logical NOT predicate
 564 */
 565 class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
 566                     public virtual Predicate_i
 567 {
 568 public:
 569                                   LogicalNOT_i();
 570   virtual                         ~LogicalNOT_i();
 571
 572   virtual void                    SetPredicate( Predicate_ptr );
 573   Predicate_i*                    GetPredicate_i();
 574   FunctorType                     GetFunctorType();
 575
 576 protected:
 577   Controls::LogicalNOTPtr         myLogicalNOTPtr;
 578   Predicate_i*                    myPredicate;
 579 };
 580
 581
 582 /*
 583   Class       : LogicalBinary_i
 584   Description : Base class for binary logical predicate
 585 */
 586 class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
 587                        public virtual Predicate_i
 588 {
 589 public:
 590   virtual                         ~LogicalBinary_i();
 591   virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
 592   virtual void                    SetPredicate1( Predicate_ptr );
 593   virtual void                    SetPredicate2( Predicate_ptr );
 594
 595   Controls::LogicalBinaryPtr      GetLogicalBinary();
 596   Predicate_i*                    GetPredicate1_i();
 597   Predicate_i*                    GetPredicate2_i();
 598
 599 protected:
 600                                   LogicalBinary_i();
 601 protected:
 602   Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
 603   Predicate_i*                    myPredicate1;
 604   Predicate_i*                    myPredicate2;
 605 };
 606
 607
 608 /*
 609   Class       : LogicalAND_i
 610   Description : Logical AND
 611 */
 612 class LogicalAND_i: public virtual POA_SMESH::LogicalAND,
 613                     public virtual LogicalBinary_i
 614 {
 615 public:
 616                                   LogicalAND_i();
 617   FunctorType                     GetFunctorType();
 618 };
 619
 620
 621 /*
 622   Class       : LogicalOR_i
 623   Description : Logical OR
 624 */
 625 class LogicalOR_i: public virtual POA_SMESH::LogicalOR,
 626                    public virtual LogicalBinary_i
 627 {
 628 public:
 629                                   LogicalOR_i();
 630   FunctorType                     GetFunctorType();
 631 };
 632
 633
 634 /*
 635                                FILTER
 636 */
 637 class Filter_i: public virtual POA_SMESH::Filter,
 638                 public virtual SALOME::GenericObj_i
 639 {
 640 public:
 641                                   Filter_i();
 642   virtual                         ~Filter_i();
 643
 644   void                            SetPredicate( Predicate_ptr );
 645   void                            SetMesh( SMESH_Mesh_ptr );
 646
 647   long_array*                     GetElementsId( SMESH_Mesh_ptr );
 648   ElementType                     GetElementType();
 649
 650   CORBA::Boolean                  GetCriteria( SMESH::Filter::Criteria_out theCriteria );
 651   CORBA::Boolean                  SetCriteria( const SMESH::Filter::Criteria& theCriteria );
 652
 653   Predicate_ptr                   GetPredicate();
 654   Predicate_i*                    GetPredicate_i();
 655
 656 private:
 657   Controls::Filter                myFilter;
 658   Predicate_i*                    myPredicate;
 659 };
 660
 661
 662 /*
 663                             FILTER LIBRARY
 664 */
 665 class FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
 666                        public virtual SALOME::GenericObj_i
 667 {
 668 public:
 669                           FilterLibrary_i( const char* theFileName );
 670                           FilterLibrary_i();
 671                           ~FilterLibrary_i();
 672
 673   Filter_ptr              Copy( const char* theFilterName );
 674
 675   CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
 676   CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
 677   CORBA::Boolean          Delete  ( const char* theFilterName );
 678   CORBA::Boolean          Replace ( const char* theFilterName,
 679                                     const char* theNewName,
 680                                     Filter_ptr  theFilter );
 681
 682   CORBA::Boolean          Save();
 683   CORBA::Boolean          SaveAs( const char* aFileName );
 684
 685   CORBA::Boolean          IsPresent( const char* aFilterName );
 686   CORBA::Long             NbFilters( ElementType );
 687   string_array*           GetNames( ElementType );
 688   string_array*           GetAllNames();
 689   void                    SetFileName( const char* theFileName );
 690   char*                   GetFileName();
 691
 692 private:
 693   char*                   myFileName;
 694   LDOM_Document           myDoc;
 695   FilterManager_var       myFilterMgr;
 696 };
 697
 698
 699 /*
 700                             FILTER MANAGER
 701 */
 702
 703 class FilterManager_i: public virtual POA_SMESH::FilterManager,
 704                        public virtual SALOME::GenericObj_i
 705 {
 706 public:
 707                             FilterManager_i();
 708   MinimumAngle_ptr          CreateMinimumAngle();
 709   AspectRatio_ptr           CreateAspectRatio();
 710   AspectRatio3D_ptr         CreateAspectRatio3D();
 711   Warping_ptr               CreateWarping();
 712   Taper_ptr                 CreateTaper();
 713   Skew_ptr                  CreateSkew();
 714   Area_ptr                  CreateArea();
 715   Length_ptr                CreateLength();
 716   Length2D_ptr              CreateLength2D();
 717   MultiConnection_ptr       CreateMultiConnection();
 718   MultiConnection2D_ptr     CreateMultiConnection2D();
 719
 720   BelongToGeom_ptr          CreateBelongToGeom();
 721   BelongToPlane_ptr         CreateBelongToPlane();
 722   BelongToCylinder_ptr      CreateBelongToCylinder();
 723
 724   LyingOnGeom_ptr           CreateLyingOnGeom();
 725
 726   FreeBorders_ptr           CreateFreeBorders();
 727   FreeEdges_ptr             CreateFreeEdges();
 728
 729   RangeOfIds_ptr            CreateRangeOfIds();
 730
 731   BadOrientedVolume_ptr     CreateBadOrientedVolume();
 732
 733   LessThan_ptr              CreateLessThan();
 734   MoreThan_ptr              CreateMoreThan();
 735   EqualTo_ptr               CreateEqualTo();
 736
 737   LogicalNOT_ptr            CreateLogicalNOT();
 738   LogicalAND_ptr            CreateLogicalAND();
 739   LogicalOR_ptr             CreateLogicalOR();
 740
 741   Filter_ptr                CreateFilter();
 742
 743   FilterLibrary_ptr         LoadLibrary( const char* aFileName );
 744   FilterLibrary_ptr         CreateLibrary();
 745   CORBA::Boolean            DeleteLibrary( const char* aFileName );
 746 };
 747
 748
 749
 750 };
 751
 752
 753 #endif