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