src/Controls/SMESH_ControlsDef.hxx

   1 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 //  This library is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU Lesser General Public
   6 //  License as published by the Free Software Foundation; either
   7 //  version 2.1 of the License.
   8 //
   9 //  This library is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 //  Lesser General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU Lesser General Public
  15 //  License along with this library; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  19
  20 #ifndef _SMESH_CONTROLSDEF_HXX_
  21 #define _SMESH_CONTROLSDEF_HXX_
  22
  23 #include <set>
  24 #include <map>
  25 #include <vector>
  26 #include <boost/shared_ptr.hpp>
  27 #include <gp_XYZ.hxx>
  28 #include <Geom_Surface.hxx>
  29 #include <TColStd_SequenceOfInteger.hxx>
  30 #include <TColStd_MapOfInteger.hxx>
  31 #include <TCollection_AsciiString.hxx>
  32
  33 #include "SMDSAbs_ElementType.hxx"
  34 #include "SMDS_MeshNode.hxx"
  35
  36 #include "SMESH_Controls.hxx"
  37
  38 class SMDS_MeshElement;
  39 class SMDS_MeshFace;
  40 class SMDS_MeshNode;
  41 class SMDS_Mesh;
  42
  43 class SMESHDS_Mesh;
  44 class SMESHDS_SubMesh;
  45
  46 class gp_Pnt;
  47 class TopoDS_Shape;
  48
  49
  50 namespace SMESH{
  51   namespace Controls{
  52
  53     class TSequenceOfXYZ: public std::vector<gp_XYZ>
  54     {
  55     public:
  56       typedef std::vector<gp_XYZ> TSuperClass;
  57       TSequenceOfXYZ()
  58       {}
  59
  60       TSequenceOfXYZ(size_type n):
  61         TSuperClass(n)
  62       {}
  63
  64       TSequenceOfXYZ(size_type n, const value_type& t):
  65         TSuperClass(n,t)
  66       {}
  67
  68       TSequenceOfXYZ(const TSequenceOfXYZ& theSequenceOfXYZ):
  69         TSuperClass(theSequenceOfXYZ)
  70       {}
  71
  72       template <class InputIterator>
  73       TSequenceOfXYZ(InputIterator theBegin, InputIterator theEnd):
  74         TSuperClass(theBegin,theEnd)
  75       {}
  76
  77       TSequenceOfXYZ& operator=(const TSequenceOfXYZ& theSequenceOfXYZ){
  78         TSuperClass::operator=(theSequenceOfXYZ);
  79         return *this;
  80       }
  81
  82       reference operator()(size_type n){
  83         return TSuperClass::operator[](n-1);
  84       }
  85
  86       const_reference operator()(size_type n) const{
  87         return TSuperClass::operator[](n-1);
  88       }
  89
  90     private:
  91       reference operator[](size_type n);
  92
  93       const_reference operator[](size_type n) const;
  94     };
  95
  96     class Functor
  97     {
  98     public:
  99       ~Functor(){}
 100       virtual void SetMesh( SMDS_Mesh* theMesh ) = 0;
 101       virtual SMDSAbs_ElementType GetType() const = 0;
 102     };
 103
 104     class NumericalFunctor: public virtual Functor{
 105     public:
 106       NumericalFunctor();
 107       virtual void SetMesh( SMDS_Mesh* theMesh );
 108       virtual double GetValue( long theElementId );
 109       virtual double GetValue(const TSequenceOfXYZ& thePoints) {};
 110       virtual SMDSAbs_ElementType GetType() const = 0;
 111       virtual double GetBadRate( double Value, int nbNodes ) const = 0;
 112       long  GetPrecision() const;
 113       void  SetPrecision( const long thePrecision );
 114
 115       bool GetPoints(const int theId,
 116                      TSequenceOfXYZ& theRes) const;
 117       static bool GetPoints(const SMDS_MeshElement* theElem,
 118                             TSequenceOfXYZ& theRes);
 119     protected:
 120       SMDS_Mesh* myMesh;
 121       long       myPrecision;
 122     };
 123
 124
 125     /*
 126       Class       : SMESH_MinimumAngle
 127       Description : Functor for calculation of minimum angle
 128     */
 129     class MinimumAngle: public virtual NumericalFunctor{
 130     public:
 131       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 132       virtual double GetBadRate( double Value, int nbNodes ) const;
 133       virtual SMDSAbs_ElementType GetType() const;
 134     };
 135
 136
 137     /*
 138       Class       : AspectRatio
 139       Description : Functor for calculating aspect ratio
 140     */
 141     class AspectRatio: public virtual NumericalFunctor{
 142     public:
 143       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 144       virtual double GetBadRate( double Value, int nbNodes ) const;
 145       virtual SMDSAbs_ElementType GetType() const;
 146     };
 147
 148
 149     /*
 150       Class       : AspectRatio3D
 151       Description : Functor for calculating aspect ratio of 3D elems.
 152     */
 153     class AspectRatio3D: public virtual NumericalFunctor{
 154     public:
 155       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 156       virtual double GetBadRate( double Value, int nbNodes ) const;
 157       virtual SMDSAbs_ElementType GetType() const;
 158     };
 159
 160
 161     /*
 162       Class       : Warping
 163       Description : Functor for calculating warping
 164     */
 165     class Warping: public virtual NumericalFunctor{
 166     public:
 167       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 168       virtual double GetBadRate( double Value, int nbNodes ) const;
 169       virtual SMDSAbs_ElementType GetType() const;
 170
 171     private:
 172       double ComputeA( const gp_XYZ&, const gp_XYZ&, const gp_XYZ&, const gp_XYZ& ) const;
 173     };
 174
 175
 176     /*
 177       Class       : Taper
 178       Description : Functor for calculating taper
 179     */
 180     class Taper: public virtual NumericalFunctor{
 181     public:
 182       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 183       virtual double GetBadRate( double Value, int nbNodes ) const;
 184       virtual SMDSAbs_ElementType GetType() const;
 185     };
 186
 187
 188     /*
 189       Class       : Skew
 190       Description : Functor for calculating skew in degrees
 191     */
 192     class Skew: public virtual NumericalFunctor{
 193     public:
 194       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 195       virtual double GetBadRate( double Value, int nbNodes ) const;
 196       virtual SMDSAbs_ElementType GetType() const;
 197     };
 198
 199
 200     /*
 201       Class       : Area
 202       Description : Functor for calculating area
 203     */
 204     class Area: public virtual NumericalFunctor{
 205     public:
 206       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 207       virtual double GetBadRate( double Value, int nbNodes ) const;
 208       virtual SMDSAbs_ElementType GetType() const;
 209     };
 210
 211
 212     /*
 213       Class       : Length
 214       Description : Functor for calculating length of edge
 215     */
 216     class Length: public virtual NumericalFunctor{
 217     public:
 218       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 219       virtual double GetBadRate( double Value, int nbNodes ) const;
 220       virtual SMDSAbs_ElementType GetType() const;
 221     };
 222
 223     /*
 224       Class       : Length2D
 225       Description : Functor for calculating length of edge
 226     */
 227     class Length2D: public virtual NumericalFunctor{
 228     public:
 229       virtual double GetValue( long theElementId );
 230       virtual double GetBadRate( double Value, int nbNodes ) const;
 231       virtual SMDSAbs_ElementType GetType() const;
 232       struct Value{
 233         double myLength;
 234         long myPntId[2];
 235         Value(double theLength, long thePntId1, long thePntId2);
 236         bool operator<(const Value& x) const;
 237       };
 238       typedef std::set<Value> TValues;
 239       void GetValues(TValues& theValues);
 240
 241     };
 242     typedef boost::shared_ptr<Length2D> Length2DPtr;
 243
 244     /*
 245       Class       : MultiConnection
 246       Description : Functor for calculating number of faces conneted to the edge
 247     */
 248     class MultiConnection: public virtual NumericalFunctor{
 249     public:
 250       virtual double GetValue( long theElementId );
 251       virtual double GetValue( const TSequenceOfXYZ& thePoints );
 252       virtual double GetBadRate( double Value, int nbNodes ) const;
 253       virtual SMDSAbs_ElementType GetType() const;
 254     };
 255
 256
 257     /*
 258       PREDICATES
 259     */
 260     /*
 261       Class       : Predicate
 262       Description : Base class for all predicates
 263     */
 264     class Predicate: public virtual Functor{
 265     public:
 266       virtual bool IsSatisfy( long theElementId ) = 0;
 267       virtual SMDSAbs_ElementType GetType() const = 0;
 268     };
 269
 270
 271
 272     /*
 273       Class       : FreeBorders
 274       Description : Predicate for free borders
 275     */
 276     class FreeBorders: public virtual Predicate{
 277     public:
 278       FreeBorders();
 279       virtual void SetMesh( SMDS_Mesh* theMesh );
 280       virtual bool IsSatisfy( long theElementId );
 281       virtual SMDSAbs_ElementType GetType() const;
 282
 283     protected:
 284       SMDS_Mesh* myMesh;
 285     };
 286
 287
 288     /*
 289       Class       : FreeEdges
 290       Description : Predicate for free Edges
 291     */
 292     class FreeEdges: public virtual Predicate{
 293     public:
 294       FreeEdges();
 295       virtual void SetMesh( SMDS_Mesh* theMesh );
 296       virtual bool IsSatisfy( long theElementId );
 297       virtual SMDSAbs_ElementType GetType() const;
 298       static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId  );
 299       typedef long TElemId;
 300       struct Border{
 301         TElemId myElemId;
 302         TElemId myPntId[2];
 303         Border(long theElemId, long thePntId1, long thePntId2);
 304         bool operator<(const Border& x) const;
 305       };
 306       typedef std::set<Border> TBorders;
 307       void GetBoreders(TBorders& theBorders);
 308
 309     protected:
 310       SMDS_Mesh* myMesh;
 311     };
 312     typedef boost::shared_ptr<FreeEdges> FreeEdgesPtr;
 313
 314
 315     /*
 316       Class       : RangeOfIds
 317       Description : Predicate for Range of Ids.
 318                     Range may be specified with two ways.
 319                     1. Using AddToRange method
 320                     2. With SetRangeStr method. Parameter of this method is a string
 321                        like as "1,2,3,50-60,63,67,70-"
 322     */
 323     class RangeOfIds: public virtual Predicate
 324     {
 325     public:
 326                                     RangeOfIds();
 327       virtual void                  SetMesh( SMDS_Mesh* theMesh );
 328       virtual bool                  IsSatisfy( long theNodeId );
 329       virtual SMDSAbs_ElementType   GetType() const;
 330       virtual void                  SetType( SMDSAbs_ElementType theType );
 331
 332       bool                          AddToRange( long theEntityId );
 333       void                          GetRangeStr( TCollection_AsciiString& );
 334       bool                          SetRangeStr( const TCollection_AsciiString& );
 335
 336     protected:
 337       SMDS_Mesh*                    myMesh;
 338
 339       TColStd_SequenceOfInteger     myMin;
 340       TColStd_SequenceOfInteger     myMax;
 341       TColStd_MapOfInteger          myIds;
 342
 343       SMDSAbs_ElementType           myType;
 344     };
 345
 346     typedef boost::shared_ptr<RangeOfIds> RangeOfIdsPtr;
 347
 348
 349     /*
 350       Class       : Comparator
 351       Description : Base class for comparators
 352     */
 353     class Comparator: public virtual Predicate{
 354     public:
 355       Comparator();
 356       virtual ~Comparator();
 357       virtual void SetMesh( SMDS_Mesh* theMesh );
 358       virtual void SetMargin(double theValue);
 359       virtual void SetNumFunctor(NumericalFunctorPtr theFunct);
 360       virtual bool IsSatisfy( long theElementId ) = 0;
 361       virtual SMDSAbs_ElementType GetType() const;
 362       double  GetMargin();
 363
 364     protected:
 365       double myMargin;
 366       NumericalFunctorPtr myFunctor;
 367     };
 368     typedef boost::shared_ptr<Comparator> ComparatorPtr;
 369
 370
 371     /*
 372       Class       : LessThan
 373       Description : Comparator "<"
 374     */
 375     class LessThan: public virtual Comparator{
 376     public:
 377       virtual bool IsSatisfy( long theElementId );
 378     };
 379
 380
 381     /*
 382       Class       : MoreThan
 383       Description : Comparator ">"
 384     */
 385     class MoreThan: public virtual Comparator{
 386     public:
 387       virtual bool IsSatisfy( long theElementId );
 388     };
 389
 390
 391     /*
 392       Class       : EqualTo
 393       Description : Comparator "="
 394     */
 395     class EqualTo: public virtual Comparator{
 396     public:
 397       EqualTo();
 398       virtual bool IsSatisfy( long theElementId );
 399       virtual void SetTolerance( double theTol );
 400       virtual double GetTolerance();
 401
 402     private:
 403       double myToler;
 404     };
 405     typedef boost::shared_ptr<EqualTo> EqualToPtr;
 406
 407
 408     /*
 409       Class       : LogicalNOT
 410       Description : Logical NOT predicate
 411     */
 412     class LogicalNOT: public virtual Predicate{
 413     public:
 414       LogicalNOT();
 415       virtual ~LogicalNOT();
 416       virtual bool IsSatisfy( long theElementId );
 417       virtual void SetMesh( SMDS_Mesh* theMesh );
 418       virtual void SetPredicate(PredicatePtr thePred);
 419       virtual SMDSAbs_ElementType GetType() const;
 420
 421     private:
 422       PredicatePtr myPredicate;
 423     };
 424     typedef boost::shared_ptr<LogicalNOT> LogicalNOTPtr;
 425
 426
 427     /*
 428       Class       : LogicalBinary
 429       Description : Base class for binary logical predicate
 430     */
 431     class LogicalBinary: public virtual Predicate{
 432     public:
 433       LogicalBinary();
 434       virtual ~LogicalBinary();
 435       virtual void SetMesh( SMDS_Mesh* theMesh );
 436       virtual void SetPredicate1(PredicatePtr thePred);
 437       virtual void SetPredicate2(PredicatePtr thePred);
 438       virtual SMDSAbs_ElementType GetType() const;
 439
 440     protected:
 441       PredicatePtr myPredicate1;
 442       PredicatePtr myPredicate2;
 443     };
 444     typedef boost::shared_ptr<LogicalBinary> LogicalBinaryPtr;
 445
 446
 447     /*
 448       Class       : LogicalAND
 449       Description : Logical AND
 450     */
 451     class LogicalAND: public virtual LogicalBinary{
 452     public:
 453       virtual bool IsSatisfy( long theElementId );
 454     };
 455
 456
 457     /*
 458       Class       : LogicalOR
 459       Description : Logical OR
 460     */
 461     class LogicalOR: public virtual LogicalBinary{
 462     public:
 463       virtual bool IsSatisfy( long theElementId );
 464     };
 465
 466
 467     /*
 468       Class       : ManifoldPart
 469       Description : Predicate for manifold part of mesh
 470     */
 471     class ManifoldPart: public virtual Predicate{
 472     public:
 473
 474       /* internal class for algorithm uses */
 475       class Link
 476       {
 477       public:
 478         Link( SMDS_MeshNode* theNode1,
 479               SMDS_MeshNode* theNode2 );
 480         ~Link();
 481
 482         bool IsEqual( const ManifoldPart::Link& theLink ) const;
 483         bool operator<(const ManifoldPart::Link& x) const;
 484
 485         SMDS_MeshNode* myNode1;
 486         SMDS_MeshNode* myNode2;
 487       };
 488
 489       bool IsEqual( const ManifoldPart::Link& theLink1,
 490                     const ManifoldPart::Link& theLink2 );
 491
 492       typedef std::set<ManifoldPart::Link>                TMapOfLink;
 493       typedef std::vector<SMDS_MeshFace*>                 TVectorOfFacePtr;
 494       typedef std::vector<ManifoldPart::Link>             TVectorOfLink;
 495       typedef std::map<SMDS_MeshFace*,int>                TDataMapFacePtrInt;
 496       typedef std::map<ManifoldPart::Link,SMDS_MeshFace*> TDataMapOfLinkFacePtr;
 497
 498       ManifoldPart();
 499       ~ManifoldPart();
 500       virtual void SetMesh( SMDS_Mesh* theMesh );
 501       // inoke when all parameters already set
 502       virtual bool IsSatisfy( long theElementId );
 503       virtual      SMDSAbs_ElementType GetType() const;
 504
 505       void    SetAngleTolerance( const double theAngToler );
 506       double  GetAngleTolerance() const;
 507       void    SetIsOnlyManifold( const bool theIsOnly );
 508       void    SetStartElem( const long  theStartElemId );
 509
 510     private:
 511       bool    process();
 512       bool    findConnected( const TDataMapFacePtrInt& theAllFacePtrInt,
 513                              SMDS_MeshFace*            theStartFace,
 514                              TMapOfLink&               theNonManifold,
 515                              TColStd_MapOfInteger&     theResFaces );
 516       bool    isInPlane( const SMDS_MeshFace* theFace1,
 517                           const SMDS_MeshFace* theFace2 );
 518       void    expandBoundary( TMapOfLink&            theMapOfBoundary,
 519                               TVectorOfLink&         theSeqOfBoundary,
 520                               TDataMapOfLinkFacePtr& theDMapLinkFacePtr,
 521                               TMapOfLink&            theNonManifold,
 522                               SMDS_MeshFace*         theNextFace ) const;
 523
 524      void     getFacesByLink( const Link& theLink,
 525                               TVectorOfFacePtr& theFaces ) const;
 526
 527     private:
 528       SMDS_Mesh*            myMesh;
 529       TColStd_MapOfInteger  myMapIds;
 530       TColStd_MapOfInteger  myMapBadGeomIds;
 531       TVectorOfFacePtr      myAllFacePtr;
 532       TDataMapFacePtrInt    myAllFacePtrIntDMap;
 533       double                myAngToler;
 534       bool                  myIsOnlyManifold;
 535       long                  myStartElemId;
 536
 537     };
 538     typedef boost::shared_ptr<ManifoldPart> ManifoldPartPtr;
 539
 540
 541     /*
 542       Class       : ElementsOnSurface
 543       Description : Predicate elements that lying on indicated surface
 544                     (plane or cylinder)
 545     */
 546     class ElementsOnSurface : public virtual Predicate {
 547     public:
 548       ElementsOnSurface();
 549       ~ElementsOnSurface();
 550       virtual void SetMesh( SMDS_Mesh* theMesh );
 551       virtual bool IsSatisfy( long theElementId );
 552       virtual      SMDSAbs_ElementType GetType() const;
 553
 554       void    SetTolerance( const double theToler );
 555       double  GetTolerance() const;
 556       void    SetSurface( const TopoDS_Shape& theShape,
 557                           const SMDSAbs_ElementType theType );
 558
 559     private:
 560       void    process();
 561       void    process( const SMDS_MeshElement* theElem  );
 562       bool    isOnSurface( const SMDS_MeshNode* theNode ) const;
 563
 564     private:
 565       SMDS_Mesh*            myMesh;
 566       TColStd_MapOfInteger  myIds;
 567       SMDSAbs_ElementType   myType;
 568       Handle(Geom_Surface)  mySurf;
 569       double                myToler;
 570     };
 571
 572     typedef boost::shared_ptr<ElementsOnSurface> ElementsOnSurfacePtr;
 573
 574
 575     /*
 576       FILTER
 577     */
 578     class Filter{
 579     public:
 580       Filter();
 581       virtual ~Filter();
 582       virtual void SetPredicate(PredicatePtr thePred);
 583       typedef std::vector<long> TIdSequence;
 584       virtual TIdSequence GetElementsId( SMDS_Mesh* theMesh );
 585
 586     protected:
 587       PredicatePtr myPredicate;
 588     };
 589   };
 590 };
 591
 592
 593 #endif