src/Controls/SMESH_ControlsDef.hxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  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, or (at your option) any later version.
  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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #ifndef _SMESH_CONTROLSDEF_HXX_
  24 #define _SMESH_CONTROLSDEF_HXX_
  25
  26 #include "SMESH_Controls.hxx"
  27
  28 #include "SMESH_TypeDefs.hxx"
  29
  30 #include <BRepClass3d_SolidClassifier.hxx>
  31 #include <Bnd_B3d.hxx>
  32 #include <GeomAPI_ProjectPointOnCurve.hxx>
  33 #include <GeomAPI_ProjectPointOnSurf.hxx>
  34 #include <Quantity_Color.hxx>
  35 #include <TColStd_MapOfInteger.hxx>
  36 #include <TColStd_SequenceOfInteger.hxx>
  37 #include <TCollection_AsciiString.hxx>
  38 #include <TopAbs.hxx>
  39 #include <TopoDS_Face.hxx>
  40 #include <gp_XYZ.hxx>
  41
  42 #include <set>
  43 #include <map>
  44 #include <vector>
  45
  46 #include <boost/shared_ptr.hpp>
  47
  48 class SMDS_MeshElement;
  49 class SMDS_MeshFace;
  50 class SMDS_MeshNode;
  51 class SMDS_Mesh;
  52
  53 class SMESHDS_Mesh;
  54 class SMESHDS_SubMesh;
  55 class SMESHDS_GroupBase;
  56
  57 class gp_Pnt;
  58
  59 namespace SMESH{
  60   namespace Controls{
  61
  62     class SMESHCONTROLS_EXPORT TSequenceOfXYZ
  63     {
  64       typedef std::vector<gp_XYZ>::size_type size_type;
  65
  66     public:
  67       TSequenceOfXYZ();
  68
  69       explicit TSequenceOfXYZ(size_type n);
  70
  71       TSequenceOfXYZ(size_type n, const gp_XYZ& t);
  72
  73       TSequenceOfXYZ(const TSequenceOfXYZ& theSequenceOfXYZ);
  74
  75       template <class InputIterator>
  76       TSequenceOfXYZ(InputIterator theBegin, InputIterator theEnd);
  77
  78       ~TSequenceOfXYZ();
  79
  80       TSequenceOfXYZ& operator=(const TSequenceOfXYZ& theSequenceOfXYZ);
  81
  82       gp_XYZ& operator()(size_type n);
  83
  84       const gp_XYZ& operator()(size_type n) const;
  85
  86       void clear();
  87
  88       void reserve(size_type n);
  89
  90       void push_back(const gp_XYZ& v);
  91
  92       size_type size() const;
  93
  94
  95       void setElement(const SMDS_MeshElement* e) { myElem = e; }
  96
  97       const SMDS_MeshElement* getElement() const { return myElem; }
  98
  99       SMDSAbs_EntityType getElementEntity() const;
 100
 101     private:
 102       std::vector<gp_XYZ>     myArray;
 103       const SMDS_MeshElement* myElem;
 104     };
 105
 106     /*!
 107      * \brief Class used to detect mesh modification: IsMeshModified() returns
 108      * true if a mesh has changed since last calling IsMeshModified()
 109      */
 110     class SMESHCONTROLS_EXPORT TMeshModifTracer
 111     {
 112       unsigned long    myMeshModifTime;
 113       const SMDS_Mesh* myMesh;
 114     public:
 115       TMeshModifTracer();
 116       void SetMesh( const SMDS_Mesh* theMesh );
 117       const SMDS_Mesh* GetMesh() const { return myMesh; }
 118       bool IsMeshModified();
 119     };
 120
 121     /*
 122       Class       : NumericalFunctor
 123       Description : Root of all Functors returning numeric value
 124     */
 125     class SMESHCONTROLS_EXPORT NumericalFunctor: public virtual Functor{
 126     public:
 127       NumericalFunctor();
 128       virtual void SetMesh( const SMDS_Mesh* theMesh );
 129       virtual double GetValue( long theElementId );
 130       virtual double GetValue(const TSequenceOfXYZ& thePoints) { return -1.0;};
 131       void GetHistogram(int                     nbIntervals,
 132                         std::vector<int>&       nbEvents,
 133                         std::vector<double>&    funValues,
 134                         const std::vector<int>& elements,
 135                         const double*           minmax=0,
 136                         const bool              isLogarithmic = false);
 137       virtual SMDSAbs_ElementType GetType() const = 0;
 138       virtual double GetBadRate( double Value, int nbNodes ) const = 0;
 139       long  GetPrecision() const;
 140       void  SetPrecision( const long thePrecision );
 141       double Round( const double & value );
 142
 143       bool GetPoints(const int theId, TSequenceOfXYZ& theRes) const;
 144       static bool GetPoints(const SMDS_MeshElement* theElem, TSequenceOfXYZ& theRes);
 145     protected:
 146       const SMDS_Mesh*        myMesh;
 147       const SMDS_MeshElement* myCurrElement;
 148       long                    myPrecision;
 149       double                  myPrecisionValue;
 150     };
 151
 152
 153     /*
 154       Class       : Volume
 155       Description : Functor calculating volume of 3D mesh element
 156     */
 157     class SMESHCONTROLS_EXPORT Volume: public virtual NumericalFunctor{
 158     public:
 159       virtual double GetValue( long theElementId );
 160       //virtual double GetValue( const TSequenceOfXYZ& thePoints );
 161       virtual double GetBadRate( double Value, int nbNodes ) const;
 162       virtual SMDSAbs_ElementType GetType() const;
 163     };
 164
 165
 166     /*
 167       Class       : MaxElementLength2D
 168       Description : Functor calculating maximum length of 2D element
 169     */
 170     class SMESHCONTROLS_EXPORT MaxElementLength2D: public virtual NumericalFunctor{
 171     public:
 172       virtual double GetValue( long theElementId );
 173       virtual double GetValue( const TSequenceOfXYZ& P );
 174       virtual double GetBadRate( double Value, int nbNodes ) const;
 175       virtual SMDSAbs_ElementType GetType() const;
 176     };
 177
 178
 179     /*
 180       Class       : MaxElementLength3D
 181       Description : Functor calculating maximum length of 3D element
 182     */
 183     class SMESHCONTROLS_EXPORT MaxElementLength3D: public virtual NumericalFunctor{
 184     public:
 185       virtual double GetValue( long theElementId );
 186       virtual double GetBadRate( double Value, int nbNodes ) const;
 187       virtual SMDSAbs_ElementType GetType() const;
 188     };
 189
 190
 191     /*
 192       Class       : SMESH_MinimumAngle
 193       Description : Functor for calculation of minimum angle
 194     */
 195     class SMESHCONTROLS_EXPORT MinimumAngle: public virtual NumericalFunctor{
 196     public:
 197       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 198       virtual double GetBadRate( double Value, int nbNodes ) const;
 199       virtual SMDSAbs_ElementType GetType() const;
 200     };
 201
 202
 203     /*
 204       Class       : AspectRatio
 205       Description : Functor for calculating aspect ratio
 206     */
 207     class SMESHCONTROLS_EXPORT AspectRatio: public virtual NumericalFunctor{
 208     public:
 209       virtual double GetValue( long theElementId );
 210       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 211       virtual double GetBadRate( double Value, int nbNodes ) const;
 212       virtual SMDSAbs_ElementType GetType() const;
 213     };
 214
 215
 216     /*
 217       Class       : AspectRatio3D
 218       Description : Functor for calculating aspect ratio of 3D elems.
 219     */
 220     class SMESHCONTROLS_EXPORT AspectRatio3D: public virtual NumericalFunctor{
 221     public:
 222       virtual double GetValue( long theElementId );
 223       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 224       virtual double GetBadRate( double Value, int nbNodes ) const;
 225       virtual SMDSAbs_ElementType GetType() const;
 226     };
 227
 228
 229     /*
 230       Class       : Warping
 231       Description : Functor for calculating warping
 232     */
 233     class SMESHCONTROLS_EXPORT Warping: public virtual NumericalFunctor{
 234     public:
 235       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 236       virtual double GetBadRate( double Value, int nbNodes ) const;
 237       virtual SMDSAbs_ElementType GetType() const;
 238
 239     private:
 240       double ComputeA( const gp_XYZ&, const gp_XYZ&, const gp_XYZ&, const gp_XYZ& ) const;
 241     };
 242
 243
 244     /*
 245       Class       : Taper
 246       Description : Functor for calculating taper
 247     */
 248     class SMESHCONTROLS_EXPORT Taper: public virtual NumericalFunctor{
 249     public:
 250       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 251       virtual double GetBadRate( double Value, int nbNodes ) const;
 252       virtual SMDSAbs_ElementType GetType() const;
 253     };
 254
 255     /*
 256       Class       : Skew
 257       Description : Functor for calculating skew in degrees
 258     */
 259     class SMESHCONTROLS_EXPORT Skew: public virtual NumericalFunctor{
 260     public:
 261       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 262       virtual double GetBadRate( double Value, int nbNodes ) const;
 263       virtual SMDSAbs_ElementType GetType() const;
 264     };
 265
 266
 267     /*
 268       Class       : Area
 269       Description : Functor for calculating area
 270     */
 271     class SMESHCONTROLS_EXPORT Area: public virtual NumericalFunctor{
 272     public:
 273       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 274       virtual double GetBadRate( double Value, int nbNodes ) const;
 275       virtual SMDSAbs_ElementType GetType() const;
 276     };
 277
 278
 279     /*
 280       Class       : Length
 281       Description : Functor for calculating length of edge
 282     */
 283     class SMESHCONTROLS_EXPORT Length: public virtual NumericalFunctor{
 284     public:
 285       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 286       virtual double GetBadRate( double Value, int nbNodes ) const;
 287       virtual SMDSAbs_ElementType GetType() const;
 288     };
 289
 290     /*
 291       Class       : Length2D
 292       Description : Functor for calculating length of edge
 293     */
 294     class SMESHCONTROLS_EXPORT Length2D: public virtual NumericalFunctor{
 295     public:
 296       virtual double GetValue( long theElementId );
 297       virtual double GetBadRate( double Value, int nbNodes ) const;
 298       virtual SMDSAbs_ElementType GetType() const;
 299       struct Value{
 300         double myLength;
 301         long myPntId[2];
 302         Value(double theLength, long thePntId1, long thePntId2);
 303         bool operator<(const Value& x) const;
 304       };
 305       typedef std::set<Value> TValues;
 306       void GetValues(TValues& theValues);
 307     };
 308     typedef boost::shared_ptr<Length2D> Length2DPtr;
 309
 310     /*
 311       Class       : MultiConnection
 312       Description : Functor for calculating number of faces connected to the edge
 313     */
 314     class SMESHCONTROLS_EXPORT MultiConnection: public virtual NumericalFunctor{
 315     public:
 316       virtual double GetValue( long theElementId );
 317       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 318       virtual double GetBadRate( double Value, int nbNodes ) const;
 319       virtual SMDSAbs_ElementType GetType() const;
 320     };
 321
 322     /*
 323       Class       : MultiConnection2D
 324       Description : Functor for calculating number of faces connected to the edge
 325     */
 326     class SMESHCONTROLS_EXPORT MultiConnection2D: public virtual NumericalFunctor{
 327     public:
 328       virtual double GetValue( long theElementId );
 329       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 330       virtual double GetBadRate( double Value, int nbNodes ) const;
 331       virtual SMDSAbs_ElementType GetType() const;
 332       struct Value{
 333         long myPntId[2];
 334         Value(long thePntId1, long thePntId2);
 335         bool operator<(const Value& x) const;
 336       };
 337       typedef std::map<Value,int> MValues;
 338
 339       void GetValues(MValues& theValues);
 340     };
 341     typedef boost::shared_ptr<MultiConnection2D> MultiConnection2DPtr;
 342
 343     /*
 344       Class       : BallDiameter
 345       Description : Functor returning diameter of a ball element
 346     */
 347     class SMESHCONTROLS_EXPORT BallDiameter: public virtual NumericalFunctor{
 348     public:
 349       virtual double GetValue( long theElementId );
 350       virtual double GetBadRate( double Value, int nbNodes ) const;
 351       virtual SMDSAbs_ElementType GetType() const;
 352     };
 353
 354     /*
 355       Class       : NodeConnectivityNumber
 356       Description : Functor returning number of elements connected to a node
 357     */
 358     class SMESHCONTROLS_EXPORT NodeConnectivityNumber: public virtual NumericalFunctor{
 359     public:
 360       virtual double GetValue( long theNodeId );
 361       virtual double GetBadRate( double Value, int nbNodes ) const;
 362       virtual SMDSAbs_ElementType GetType() const;
 363     };
 364
 365
 366     /*
 367       PREDICATES
 368     */
 369     /*
 370       Class       : CoincidentNodes
 371       Description : Predicate of Coincident Nodes
 372       Note        : This class is suitable only for visualization of Coincident Nodes
 373     */
 374     class SMESHCONTROLS_EXPORT CoincidentNodes: public Predicate {
 375     public:
 376       CoincidentNodes();
 377       //virtual Predicate* clone() const { return new CoincidentNodes( *this ); }
 378       virtual void SetMesh( const SMDS_Mesh* theMesh );
 379       virtual bool IsSatisfy( long theElementId );
 380       virtual SMDSAbs_ElementType GetType() const;
 381
 382       void SetTolerance (const double theToler)  { myToler = theToler; }
 383       double GetTolerance () const { return myToler; }
 384
 385     private:
 386       double               myToler;
 387       TColStd_MapOfInteger myCoincidentIDs;
 388       TMeshModifTracer     myMeshModifTracer;
 389     };
 390     typedef boost::shared_ptr<CoincidentNodes> CoincidentNodesPtr;
 391
 392     /*
 393       Class       : CoincidentElements
 394       Description : Predicate of Coincident Elements
 395       Note        : This class is suitable only for visualization of Coincident Elements
 396     */
 397     class SMESHCONTROLS_EXPORT CoincidentElements: public Predicate {
 398     public:
 399       CoincidentElements();
 400       virtual void SetMesh( const SMDS_Mesh* theMesh );
 401       virtual bool IsSatisfy( long theElementId );
 402
 403     private:
 404       const SMDS_Mesh* myMesh;
 405     };
 406     class SMESHCONTROLS_EXPORT CoincidentElements1D: public CoincidentElements {
 407     public:
 408       virtual SMDSAbs_ElementType GetType() const;
 409       //virtual Predicate* clone() const { return new CoincidentElements1D( *this ); }
 410     };
 411     class SMESHCONTROLS_EXPORT CoincidentElements2D: public CoincidentElements {
 412     public:
 413       virtual SMDSAbs_ElementType GetType() const;
 414       //virtual Predicate* clone() const { return new CoincidentElements2D( *this ); }
 415     };
 416     class SMESHCONTROLS_EXPORT CoincidentElements3D: public CoincidentElements {
 417     public:
 418       virtual SMDSAbs_ElementType GetType() const;
 419       //virtual Predicate* clone() const { return new CoincidentElements3D( *this ); }
 420     };
 421
 422     /*
 423       Class       : FreeBorders
 424       Description : Predicate for free borders
 425     */
 426     class SMESHCONTROLS_EXPORT FreeBorders: public virtual Predicate{
 427     public:
 428       FreeBorders();
 429       //virtual Predicate* clone() const { return new FreeBorders( *this ); }
 430       virtual void SetMesh( const SMDS_Mesh* theMesh );
 431       virtual bool IsSatisfy( long theElementId );
 432       virtual SMDSAbs_ElementType GetType() const;
 433
 434     protected:
 435       const SMDS_Mesh* myMesh;
 436     };
 437
 438
 439     /*
 440       Class       : BadOrientedVolume
 441       Description : Predicate bad oriented volumes
 442     */
 443     class SMESHCONTROLS_EXPORT BadOrientedVolume: public virtual Predicate{
 444     public:
 445       BadOrientedVolume();
 446       //virtual Predicate* clone() const { return new BadOrientedVolume( *this ); }
 447       virtual void SetMesh( const SMDS_Mesh* theMesh );
 448       virtual bool IsSatisfy( long theElementId );
 449       virtual SMDSAbs_ElementType GetType() const;
 450
 451     protected:
 452       const SMDS_Mesh* myMesh;
 453     };
 454
 455     /*
 456       Class       : ElemEntityType
 457       Description : Functor for calculating entity type
 458     */
 459     class SMESHCONTROLS_EXPORT ElemEntityType: public virtual Predicate{
 460       public:
 461       ElemEntityType();
 462       //virtual Predicate*   clone() const { return new ElemEntityType( *this ); }
 463       virtual void         SetMesh( const SMDS_Mesh* theMesh );
 464       virtual bool         IsSatisfy( long theElementId );
 465       void                 SetType( SMDSAbs_ElementType theType );
 466       virtual              SMDSAbs_ElementType GetType() const;
 467       void                 SetElemEntityType( SMDSAbs_EntityType theEntityType );
 468       SMDSAbs_EntityType   GetElemEntityType() const;
 469
 470     private:
 471       const SMDS_Mesh*     myMesh;
 472       SMDSAbs_ElementType  myType;
 473       SMDSAbs_EntityType   myEntityType;
 474     };
 475     typedef boost::shared_ptr<ElemEntityType> ElemEntityTypePtr;
 476
 477
 478     /*
 479       BareBorderVolume
 480     */
 481     class SMESHCONTROLS_EXPORT BareBorderVolume: public Predicate
 482     {
 483     public:
 484       BareBorderVolume():myMesh(0) {}
 485       virtual Predicate* clone() const { return new BareBorderVolume( *this ); }
 486       virtual void SetMesh( const SMDS_Mesh* theMesh ) { myMesh = theMesh; }
 487       virtual SMDSAbs_ElementType GetType() const      { return SMDSAbs_Volume; }
 488       virtual bool IsSatisfy( long theElementId );
 489     protected:
 490       const SMDS_Mesh* myMesh;
 491     };
 492     typedef boost::shared_ptr<BareBorderVolume> BareBorderVolumePtr;
 493
 494     /*
 495       BareBorderFace
 496     */
 497     class SMESHCONTROLS_EXPORT BareBorderFace: public Predicate
 498     {
 499     public:
 500       BareBorderFace():myMesh(0) {}
 501       //virtual Predicate* clone() const { return new BareBorderFace( *this ); }
 502       virtual void SetMesh( const SMDS_Mesh* theMesh ) { myMesh = theMesh; }
 503       virtual SMDSAbs_ElementType GetType() const      { return SMDSAbs_Face; }
 504       virtual bool IsSatisfy( long theElementId );
 505     protected:
 506       const SMDS_Mesh* myMesh;
 507       std::vector< const SMDS_MeshNode* > myLinkNodes;
 508     };
 509     typedef boost::shared_ptr<BareBorderFace> BareBorderFacePtr;
 510
 511     /*
 512       OverConstrainedVolume
 513     */
 514     class SMESHCONTROLS_EXPORT OverConstrainedVolume: public Predicate
 515     {
 516     public:
 517       OverConstrainedVolume():myMesh(0) {}
 518       virtual Predicate* clone() const { return new OverConstrainedVolume( *this ); }
 519       virtual void SetMesh( const SMDS_Mesh* theMesh ) { myMesh = theMesh; }
 520       virtual SMDSAbs_ElementType GetType() const      { return SMDSAbs_Volume; }
 521       virtual bool IsSatisfy( long theElementId );
 522     protected:
 523       const SMDS_Mesh* myMesh;
 524     };
 525     typedef boost::shared_ptr<OverConstrainedVolume> OverConstrainedVolumePtr;
 526
 527     /*
 528       OverConstrainedFace
 529     */
 530     class SMESHCONTROLS_EXPORT OverConstrainedFace: public Predicate
 531     {
 532     public:
 533       OverConstrainedFace():myMesh(0) {}
 534       //virtual Predicate* clone() const { return new OverConstrainedFace( *this ); }
 535       virtual void SetMesh( const SMDS_Mesh* theMesh ) { myMesh = theMesh; }
 536       virtual SMDSAbs_ElementType GetType() const      { return SMDSAbs_Face; }
 537       virtual bool IsSatisfy( long theElementId );
 538     protected:
 539       const SMDS_Mesh* myMesh;
 540     };
 541     typedef boost::shared_ptr<OverConstrainedFace> OverConstrainedFacePtr;
 542
 543     /*
 544       Class       : FreeEdges
 545       Description : Predicate for free Edges
 546     */
 547     class SMESHCONTROLS_EXPORT FreeEdges: public virtual Predicate{
 548     public:
 549       FreeEdges();
 550       //virtual Predicate* clone() const { return new FreeEdges( *this ); }
 551       virtual void SetMesh( const SMDS_Mesh* theMesh );
 552       virtual bool IsSatisfy( long theElementId );
 553       virtual SMDSAbs_ElementType GetType() const;
 554       static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId  );
 555       typedef long TElemId;
 556       struct Border{
 557         TElemId myElemId;
 558         TElemId myPntId[2];
 559         Border(long theElemId, long thePntId1, long thePntId2);
 560         bool operator<(const Border& x) const;
 561       };
 562       typedef std::set<Border> TBorders;
 563       void GetBoreders(TBorders& theBorders);
 564
 565     protected:
 566       const SMDS_Mesh* myMesh;
 567     };
 568     typedef boost::shared_ptr<FreeEdges> FreeEdgesPtr;
 569
 570
 571     /*
 572       Class       : FreeNodes
 573       Description : Predicate for free nodes
 574     */
 575     class SMESHCONTROLS_EXPORT FreeNodes: public virtual Predicate{
 576     public:
 577       FreeNodes();
 578       //virtual Predicate* clone() const { return new FreeNodes( *this ); }
 579       virtual void SetMesh( const SMDS_Mesh* theMesh );
 580       virtual bool IsSatisfy( long theNodeId );
 581       virtual SMDSAbs_ElementType GetType() const;
 582
 583     protected:
 584       const SMDS_Mesh* myMesh;
 585     };
 586
 587
 588     /*
 589       Class       : RangeOfIds
 590       Description : Predicate for Range of Ids.
 591                     Range may be specified with two ways.
 592                     1. Using AddToRange method
 593                     2. With SetRangeStr method. Parameter of this method is a string
 594                        like as "1,2,3,50-60,63,67,70-"
 595     */
 596     class SMESHCONTROLS_EXPORT RangeOfIds: public virtual Predicate
 597     {
 598     public:
 599       RangeOfIds();
 600       //virtual Predicate*            clone() const { return new RangeOfIds( *this ); }
 601       virtual void                  SetMesh( const SMDS_Mesh* theMesh );
 602       virtual bool                  IsSatisfy( long theNodeId );
 603       virtual SMDSAbs_ElementType   GetType() const;
 604       virtual void                  SetType( SMDSAbs_ElementType theType );
 605
 606       bool                          AddToRange( long theEntityId );
 607       void                          GetRangeStr( TCollection_AsciiString& );
 608       bool                          SetRangeStr( const TCollection_AsciiString& );
 609
 610     protected:
 611       const SMDS_Mesh*              myMesh;
 612
 613       TColStd_SequenceOfInteger     myMin;
 614       TColStd_SequenceOfInteger     myMax;
 615       TColStd_MapOfInteger          myIds;
 616
 617       SMDSAbs_ElementType           myType;
 618     };
 619
 620     typedef boost::shared_ptr<RangeOfIds> RangeOfIdsPtr;
 621
 622
 623     /*
 624       Class       : Comparator
 625       Description : Base class for comparators
 626     */
 627     class SMESHCONTROLS_EXPORT Comparator: public virtual Predicate{
 628     public:
 629       Comparator();
 630       virtual ~Comparator();
 631       virtual void SetMesh( const SMDS_Mesh* theMesh );
 632       virtual void SetMargin(double theValue);
 633       virtual void SetNumFunctor(NumericalFunctorPtr theFunct);
 634       virtual bool IsSatisfy( long theElementId ) = 0;
 635       virtual SMDSAbs_ElementType GetType() const;
 636       double  GetMargin();
 637
 638     protected:
 639       double myMargin;
 640       NumericalFunctorPtr myFunctor;
 641     };
 642     typedef boost::shared_ptr<Comparator> ComparatorPtr;
 643
 644
 645     /*
 646       Class       : LessThan
 647       Description : Comparator "<"
 648     */
 649     class SMESHCONTROLS_EXPORT LessThan: public virtual Comparator{
 650     public:
 651       virtual bool IsSatisfy( long theElementId );
 652       //virtual Predicate* clone() const { return new LessThan( *this ); }
 653     };
 654
 655
 656     /*
 657       Class       : MoreThan
 658       Description : Comparator ">"
 659     */
 660     class SMESHCONTROLS_EXPORT MoreThan: public virtual Comparator{
 661     public:
 662       virtual bool IsSatisfy( long theElementId );
 663       //virtual Predicate* clone() const { return new MoreThan( *this ); }
 664     };
 665
 666
 667     /*
 668       Class       : EqualTo
 669       Description : Comparator "="
 670     */
 671     class SMESHCONTROLS_EXPORT EqualTo: public virtual Comparator{
 672     public:
 673       EqualTo();
 674       //virtual Predicate* clone() const { return new EqualTo( *this ); }
 675       virtual bool IsSatisfy( long theElementId );
 676       virtual void SetTolerance( double theTol );
 677       virtual double GetTolerance();
 678
 679     private:
 680       double myToler;
 681     };
 682     typedef boost::shared_ptr<EqualTo> EqualToPtr;
 683
 684
 685     /*
 686       Class       : LogicalNOT
 687       Description : Logical NOT predicate
 688     */
 689     class SMESHCONTROLS_EXPORT LogicalNOT: public virtual Predicate{
 690     public:
 691       LogicalNOT();
 692       //virtual Predicate* clone() const { return new LogicalNOT( *this ); }
 693       virtual ~LogicalNOT();
 694       virtual bool IsSatisfy( long theElementId );
 695       virtual void SetMesh( const SMDS_Mesh* theMesh );
 696       virtual void SetPredicate(PredicatePtr thePred);
 697       virtual SMDSAbs_ElementType GetType() const;
 698
 699     private:
 700       PredicatePtr myPredicate;
 701     };
 702     typedef boost::shared_ptr<LogicalNOT> LogicalNOTPtr;
 703
 704
 705     /*
 706       Class       : LogicalBinary
 707       Description : Base class for binary logical predicate
 708     */
 709     class SMESHCONTROLS_EXPORT LogicalBinary: public virtual Predicate{
 710     public:
 711       LogicalBinary();
 712       virtual ~LogicalBinary();
 713       virtual void SetMesh( const SMDS_Mesh* theMesh );
 714       virtual void SetPredicate1(PredicatePtr thePred);
 715       virtual void SetPredicate2(PredicatePtr thePred);
 716       virtual SMDSAbs_ElementType GetType() const;
 717
 718     protected:
 719       PredicatePtr myPredicate1;
 720       PredicatePtr myPredicate2;
 721     };
 722     typedef boost::shared_ptr<LogicalBinary> LogicalBinaryPtr;
 723
 724
 725     /*
 726       Class       : LogicalAND
 727       Description : Logical AND
 728     */
 729     class SMESHCONTROLS_EXPORT LogicalAND: public virtual LogicalBinary{
 730     public:
 731       virtual bool IsSatisfy( long theElementId );
 732       //virtual Predicate* clone() const { return new LogicalAND( *this ); }
 733     };
 734
 735
 736     /*
 737       Class       : LogicalOR
 738       Description : Logical OR
 739     */
 740     class SMESHCONTROLS_EXPORT LogicalOR: public virtual LogicalBinary{
 741     public:
 742       virtual bool IsSatisfy( long theElementId );
 743       //virtual Predicate* clone() const { return new LogicalOR( *this ); }
 744     };
 745
 746
 747     /*
 748       Class       : ManifoldPart
 749       Description : Predicate for manifold part of mesh
 750     */
 751     class SMESHCONTROLS_EXPORT ManifoldPart: public virtual Predicate{
 752     public:
 753
 754       /* internal class for algorithm uses */
 755       class Link
 756       {
 757       public:
 758         Link( SMDS_MeshNode* theNode1,
 759               SMDS_MeshNode* theNode2 );
 760         ~Link();
 761
 762         bool IsEqual( const ManifoldPart::Link& theLink ) const;
 763         bool operator<(const ManifoldPart::Link& x) const;
 764
 765         SMDS_MeshNode* myNode1;
 766         SMDS_MeshNode* myNode2;
 767       };
 768
 769       bool IsEqual( const ManifoldPart::Link& theLink1,
 770                     const ManifoldPart::Link& theLink2 );
 771
 772       typedef std::set<ManifoldPart::Link>                TMapOfLink;
 773       typedef std::vector<SMDS_MeshFace*>                 TVectorOfFacePtr;
 774       typedef std::vector<ManifoldPart::Link>             TVectorOfLink;
 775       typedef std::map<SMDS_MeshFace*,int>                TDataMapFacePtrInt;
 776       typedef std::map<ManifoldPart::Link,SMDS_MeshFace*> TDataMapOfLinkFacePtr;
 777
 778       ManifoldPart();
 779       ~ManifoldPart();
 780       //virtual Predicate* clone() const { return new ManifoldPart( *this ); }
 781       virtual void SetMesh( const SMDS_Mesh* theMesh );
 782       // inoke when all parameters already set
 783       virtual bool IsSatisfy( long theElementId );
 784       virtual      SMDSAbs_ElementType GetType() const;
 785
 786       void    SetAngleTolerance( const double theAngToler );
 787       double  GetAngleTolerance() const;
 788       void    SetIsOnlyManifold( const bool theIsOnly );
 789       void    SetStartElem( const long  theStartElemId );
 790
 791     private:
 792       bool    process();
 793       bool    findConnected( const TDataMapFacePtrInt& theAllFacePtrInt,
 794                              SMDS_MeshFace*            theStartFace,
 795                              TMapOfLink&               theNonManifold,
 796                              TColStd_MapOfInteger&     theResFaces );
 797       bool    isInPlane( const SMDS_MeshFace* theFace1,
 798                           const SMDS_MeshFace* theFace2 );
 799       void    expandBoundary( TMapOfLink&            theMapOfBoundary,
 800                               TVectorOfLink&         theSeqOfBoundary,
 801                               TDataMapOfLinkFacePtr& theDMapLinkFacePtr,
 802                               TMapOfLink&            theNonManifold,
 803                               SMDS_MeshFace*         theNextFace ) const;
 804
 805       void     getFacesByLink( const Link& theLink,
 806                                TVectorOfFacePtr& theFaces ) const;
 807
 808     private:
 809       const SMDS_Mesh*      myMesh;
 810       TColStd_MapOfInteger  myMapIds;
 811       TColStd_MapOfInteger  myMapBadGeomIds;
 812       TVectorOfFacePtr      myAllFacePtr;
 813       TDataMapFacePtrInt    myAllFacePtrIntDMap;
 814       double                myAngToler;
 815       bool                  myIsOnlyManifold;
 816       long                  myStartElemId;
 817
 818     };
 819     typedef boost::shared_ptr<ManifoldPart> ManifoldPartPtr;
 820
 821     /*
 822       Class       : BelongToMeshGroup
 823       Description : Verify whether a mesh element is included into a mesh group
 824     */
 825     class SMESHCONTROLS_EXPORT BelongToMeshGroup : public virtual Predicate
 826     {
 827     public:
 828       BelongToMeshGroup();
 829       //virtual Predicate* clone() const { return new BelongToMeshGroup( *this ); }
 830       virtual void SetMesh( const SMDS_Mesh* theMesh );
 831       virtual bool IsSatisfy( long theElementId );
 832       virtual SMDSAbs_ElementType GetType() const;
 833
 834       void SetGroup( SMESHDS_GroupBase* g );
 835       void SetStoreName( const std::string& sn );
 836       const SMESHDS_GroupBase* GetGroup() const { return myGroup; }
 837
 838     private:
 839       SMESHDS_GroupBase* myGroup;
 840       std::string        myStoreName;
 841     };
 842     typedef boost::shared_ptr<BelongToMeshGroup> BelongToMeshGroupPtr;
 843
 844     /*
 845       Class       : ElementsOnSurface
 846       Description : Predicate elements that lying on indicated surface
 847                     (plane or cylinder)
 848     */
 849     class SMESHCONTROLS_EXPORT ElementsOnSurface : public virtual Predicate {
 850     public:
 851       ElementsOnSurface();
 852       ~ElementsOnSurface();
 853       //virtual Predicate* clone() const { return new ElementsOnSurface( *this ); }
 854       virtual void SetMesh( const SMDS_Mesh* theMesh );
 855       virtual bool IsSatisfy( long theElementId );
 856       virtual      SMDSAbs_ElementType GetType() const;
 857
 858       void    SetTolerance( const double theToler );
 859       double  GetTolerance() const;
 860       void    SetSurface( const TopoDS_Shape& theShape,
 861                           const SMDSAbs_ElementType theType );
 862       void    SetUseBoundaries( bool theUse );
 863       bool    GetUseBoundaries() const { return myUseBoundaries; }
 864
 865     private:
 866       void    process();
 867       void    process( const SMDS_MeshElement* theElem  );
 868       bool    isOnSurface( const SMDS_MeshNode* theNode );
 869
 870     private:
 871       TMeshModifTracer      myMeshModifTracer;
 872       TColStd_MapOfInteger  myIds;
 873       SMDSAbs_ElementType   myType;
 874       TopoDS_Face           mySurf;
 875       double                myToler;
 876       bool                  myUseBoundaries;
 877       GeomAPI_ProjectPointOnSurf myProjector;
 878     };
 879
 880     typedef boost::shared_ptr<ElementsOnSurface> ElementsOnSurfacePtr;
 881
 882
 883     /*
 884       Class       : ElementsOnShape
 885       Description : Predicate elements that lying on indicated shape
 886                     (1D, 2D or 3D)
 887     */
 888     class SMESHCONTROLS_EXPORT ElementsOnShape : public Predicate
 889     {
 890     public:
 891       ElementsOnShape();
 892       ~ElementsOnShape();
 893
 894       virtual Predicate* clone() const;
 895       virtual void SetMesh (const SMDS_Mesh* theMesh);
 896       virtual bool IsSatisfy (long theElementId);
 897       virtual SMDSAbs_ElementType GetType() const;
 898
 899       void    SetTolerance (const double theToler);
 900       double  GetTolerance() const;
 901       void    SetAllNodes (bool theAllNodes);
 902       bool    GetAllNodes() const { return myAllNodesFlag; }
 903       void    SetShape (const TopoDS_Shape& theShape,
 904                         const SMDSAbs_ElementType theType);
 905
 906     private:
 907
 908       struct Classifier;
 909       struct OctreeClassifier;
 910
 911       void clearClassifiers();
 912       bool getNodeIsOut( const SMDS_MeshNode* n, bool& isOut );
 913       void setNodeIsOut( const SMDS_MeshNode* n, bool  isOut );
 914
 915       std::vector< Classifier >  myClassifiers;
 916       std::vector< Classifier* > myWorkClassifiers;
 917       OctreeClassifier*          myOctree;
 918       SMDSAbs_ElementType        myType;
 919       TopoDS_Shape               myShape;
 920       double                     myToler;
 921       bool                       myAllNodesFlag;
 922
 923       TMeshModifTracer           myMeshModifTracer;
 924       std::vector<bool>          myNodeIsChecked;
 925       std::vector<bool>          myNodeIsOut;
 926     };
 927
 928     typedef boost::shared_ptr<ElementsOnShape> ElementsOnShapePtr;
 929
 930
 931     /*
 932       Class       : BelongToGeom
 933       Description : Predicate for verifying whether entiy belong to
 934       specified geometrical support
 935     */
 936     class SMESHCONTROLS_EXPORT BelongToGeom: public virtual Predicate
 937     {
 938     public:
 939       BelongToGeom();
 940       virtual Predicate* clone() const;
 941
 942       virtual void                    SetMesh( const SMDS_Mesh* theMesh );
 943       virtual void                    SetGeom( const TopoDS_Shape& theShape );
 944
 945       virtual bool                    IsSatisfy( long theElementId );
 946
 947       virtual void                    SetType( SMDSAbs_ElementType theType );
 948       virtual                         SMDSAbs_ElementType GetType() const;
 949
 950       TopoDS_Shape                    GetShape();
 951       const SMESHDS_Mesh*             GetMeshDS() const;
 952
 953       void                            SetTolerance( double );
 954       double                          GetTolerance();
 955
 956     private:
 957       virtual void                    init();
 958
 959       TopoDS_Shape                    myShape;
 960       TColStd_MapOfInteger            mySubShapesIDs;
 961       const SMESHDS_Mesh*             myMeshDS;
 962       SMDSAbs_ElementType             myType;
 963       bool                            myIsSubshape;
 964       double                          myTolerance;          // only if myIsSubshape == false
 965       Controls::ElementsOnShapePtr    myElementsOnShapePtr; // only if myIsSubshape == false
 966     };
 967     typedef boost::shared_ptr<BelongToGeom> BelongToGeomPtr;
 968
 969     /*
 970       Class       : LyingOnGeom
 971       Description : Predicate for verifying whether entiy lying or partially lying on
 972       specified geometrical support
 973     */
 974     class SMESHCONTROLS_EXPORT LyingOnGeom: public virtual Predicate
 975     {
 976     public:
 977       LyingOnGeom();
 978       virtual Predicate* clone() const;
 979
 980       virtual void                    SetMesh( const SMDS_Mesh* theMesh );
 981       virtual void                    SetGeom( const TopoDS_Shape& theShape );
 982
 983       virtual bool                    IsSatisfy( long theElementId );
 984
 985       virtual void                    SetType( SMDSAbs_ElementType theType );
 986       virtual                         SMDSAbs_ElementType GetType() const;
 987
 988       TopoDS_Shape                    GetShape();
 989       const SMESHDS_Mesh*             GetMeshDS() const;
 990
 991       void                            SetTolerance( double );
 992       double                          GetTolerance();
 993
 994    private:
 995       virtual void                    init();
 996
 997       TopoDS_Shape                    myShape;
 998       TColStd_MapOfInteger            mySubShapesIDs;
 999       const SMESHDS_Mesh*             myMeshDS;
1000       SMDSAbs_ElementType             myType;
1001       bool                            myIsSubshape;
1002       double                          myTolerance;          // only if myIsSubshape == false
1003       Controls::ElementsOnShapePtr    myElementsOnShapePtr; // only if myIsSubshape == false
1004     };
1005     typedef boost::shared_ptr<LyingOnGeom> LyingOnGeomPtr;
1006
1007     /*
1008       Class       : FreeFaces
1009       Description : Predicate for free faces
1010     */
1011     class SMESHCONTROLS_EXPORT FreeFaces: public virtual Predicate{
1012     public:
1013       FreeFaces();
1014       //virtual Predicate* clone() const { return new FreeFaces( *this ); }
1015       virtual void SetMesh( const SMDS_Mesh* theMesh );
1016       virtual bool IsSatisfy( long theElementId );
1017       virtual SMDSAbs_ElementType GetType() const;
1018
1019     private:
1020       const SMDS_Mesh* myMesh;
1021     };
1022
1023     /*
1024       Class       : LinearOrQuadratic
1025       Description : Predicate for free faces
1026     */
1027     class SMESHCONTROLS_EXPORT LinearOrQuadratic: public virtual Predicate{
1028     public:
1029       LinearOrQuadratic();
1030       //virtual Predicate*  clone() const { return new LinearOrQuadratic( *this ); }
1031       virtual void        SetMesh( const SMDS_Mesh* theMesh );
1032       virtual bool        IsSatisfy( long theElementId );
1033       void                SetType( SMDSAbs_ElementType theType );
1034       virtual SMDSAbs_ElementType GetType() const;
1035
1036     private:
1037       const SMDS_Mesh*    myMesh;
1038       SMDSAbs_ElementType myType;
1039     };
1040     typedef boost::shared_ptr<LinearOrQuadratic> LinearOrQuadraticPtr;
1041
1042     /*
1043       Class       : GroupColor
1044       Description : Functor for check color of group to which mesh element belongs to
1045     */
1046     class SMESHCONTROLS_EXPORT GroupColor: public virtual Predicate{
1047     public:
1048       GroupColor();
1049       //virtual Predicate*  clone() const { return new GroupColor( *this ); }
1050       virtual void        SetMesh( const SMDS_Mesh* theMesh );
1051       virtual bool        IsSatisfy( long theElementId );
1052       void                SetType( SMDSAbs_ElementType theType );
1053       virtual             SMDSAbs_ElementType GetType() const;
1054       void                SetColorStr( const TCollection_AsciiString& );
1055       void                GetColorStr( TCollection_AsciiString& ) const;
1056
1057     private:
1058       typedef std::set< long > TIDs;
1059
1060       Quantity_Color      myColor;
1061       SMDSAbs_ElementType myType;
1062       TIDs                myIDs;
1063     };
1064     typedef boost::shared_ptr<GroupColor> GroupColorPtr;
1065
1066     /*
1067       Class       : ElemGeomType
1068       Description : Predicate to check element geometry type
1069     */
1070     class SMESHCONTROLS_EXPORT ElemGeomType: public virtual Predicate{
1071     public:
1072       ElemGeomType();
1073       //virtual Predicate*   clone() const { return new ElemGeomType( *this ); }
1074       virtual void         SetMesh( const SMDS_Mesh* theMesh );
1075       virtual bool         IsSatisfy( long theElementId );
1076       void                 SetType( SMDSAbs_ElementType theType );
1077       virtual              SMDSAbs_ElementType GetType() const;
1078       void                 SetGeomType( SMDSAbs_GeometryType theType );
1079       SMDSAbs_GeometryType GetGeomType() const;
1080
1081     private:
1082       const SMDS_Mesh*     myMesh;
1083       SMDSAbs_ElementType  myType;
1084       SMDSAbs_GeometryType myGeomType;
1085     };
1086     typedef boost::shared_ptr<ElemGeomType> ElemGeomTypePtr;
1087
1088     /*
1089       Class       : CoplanarFaces
1090       Description : Predicate to check angle between faces
1091     */
1092     class SMESHCONTROLS_EXPORT CoplanarFaces: public virtual Predicate
1093     {
1094     public:
1095       CoplanarFaces();
1096       //virtual Predicate*   clone() const { return new CoplanarFaces( *this ); }
1097       void                 SetFace( long theID )                   { myFaceID = theID; }
1098       long                 GetFace() const                         { return myFaceID; }
1099       void                 SetTolerance (const double theToler)    { myToler = theToler; }
1100       double               GetTolerance () const                   { return myToler; }
1101       virtual              SMDSAbs_ElementType GetType() const     { return SMDSAbs_Face; }
1102
1103       virtual void         SetMesh( const SMDS_Mesh* theMesh );
1104       virtual bool         IsSatisfy( long theElementId );
1105
1106     private:
1107       TMeshModifTracer     myMeshModifTracer;
1108       long                 myFaceID;
1109       double               myToler;
1110       TColStd_MapOfInteger myCoplanarIDs;
1111     };
1112     typedef boost::shared_ptr<CoplanarFaces> CoplanarFacesPtr;
1113
1114     /*
1115       Class       : ConnectedElements
1116       Description : Predicate to get elements of one domain
1117     */
1118     class SMESHCONTROLS_EXPORT ConnectedElements: public virtual Predicate
1119     {
1120     public:
1121       ConnectedElements();
1122       //virtual Predicate*   clone() const { return new ConnectedElements( *this ); }
1123       void                 SetNode( int nodeID );
1124       void                 SetPoint( double x, double y, double z );
1125       int                  GetNode() const;
1126       std::vector<double>  GetPoint() const;
1127
1128       void                 SetType( SMDSAbs_ElementType theType );
1129       virtual              SMDSAbs_ElementType GetType() const;
1130
1131       virtual void         SetMesh( const SMDS_Mesh* theMesh );
1132       virtual bool         IsSatisfy( long theElementId );
1133
1134       //const std::set<long>& GetDomainIDs() const { return myOkIDs; }
1135
1136     private:
1137       int                 myNodeID;
1138       std::vector<double> myXYZ;
1139       SMDSAbs_ElementType myType;
1140       TMeshModifTracer    myMeshModifTracer;
1141
1142       void                clearOkIDs();
1143       bool                myOkIDsReady;
1144       std::set< int >     myOkIDs; // empty means that there is one domain
1145     };
1146     typedef boost::shared_ptr<ConnectedElements> ConnectedElementsPtr;
1147
1148     /*
1149       FILTER
1150     */
1151     class SMESHCONTROLS_EXPORT Filter {
1152     public:
1153       Filter();
1154       virtual ~Filter();
1155       virtual void SetPredicate(PredicatePtr thePred);
1156
1157       typedef std::vector<long> TIdSequence;
1158
1159       virtual
1160       void
1161       GetElementsId( const SMDS_Mesh* theMesh,
1162                      TIdSequence& theSequence );
1163
1164       static
1165       void
1166       GetElementsId( const SMDS_Mesh* theMesh,
1167                      PredicatePtr thePredicate,
1168                      TIdSequence& theSequence );
1169
1170     protected:
1171       PredicatePtr myPredicate;
1172     };
1173   };
1174 };
1175
1176
1177 #endif