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       PREDICATES
 258     */
 259     /*
 260       Class       : Predicate
 261       Description : Base class for all predicates
 262     */
 263     class Predicate: public virtual Functor{
 264     public:
 265       virtual bool IsSatisfy( long theElementId ) = 0;
 266       virtual SMDSAbs_ElementType GetType() const = 0;
 267     };
 268
 269
 270
 271     /*
 272       Class       : FreeBorders
 273       Description : Predicate for free borders
 274     */
 275     class FreeBorders: public virtual Predicate{
 276     public:
 277       FreeBorders();
 278       virtual void SetMesh( SMDS_Mesh* theMesh );
 279       virtual bool IsSatisfy( long theElementId );
 280       virtual SMDSAbs_ElementType GetType() const;
 281
 282     protected:
 283       SMDS_Mesh* myMesh;
 284     };
 285
 286
 287     /*
 288       Class       : FreeEdges
 289       Description : Predicate for free Edges
 290     */
 291     class FreeEdges: public virtual Predicate{
 292     public:
 293       FreeEdges();
 294       virtual void SetMesh( SMDS_Mesh* theMesh );
 295       virtual bool IsSatisfy( long theElementId );
 296       virtual SMDSAbs_ElementType GetType() const;
 297       static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId  );
 298       typedef long TElemId;
 299       struct Border{
 300         TElemId myElemId;
 301         TElemId myPntId[2];
 302         Border(long theElemId, long thePntId1, long thePntId2);
 303         bool operator<(const Border& x) const;
 304       };
 305       typedef std::set<Border> TBorders;
 306       void GetBoreders(TBorders& theBorders);
 307
 308     protected:
 309       SMDS_Mesh* myMesh;
 310     };
 311     typedef boost::shared_ptr<FreeEdges> FreeEdgesPtr;
 312
 313
 314     /*
 315       Class       : RangeOfIds
 316       Description : Predicate for Range of Ids.
 317                     Range may be specified with two ways.
 318                     1. Using AddToRange method
 319                     2. With SetRangeStr method. Parameter of this method is a string
 320                        like as "1,2,3,50-60,63,67,70-"
 321     */
 322     class RangeOfIds: public virtual Predicate
 323     {
 324     public:
 325                                     RangeOfIds();
 326       virtual void                  SetMesh( SMDS_Mesh* theMesh );
 327       virtual bool                  IsSatisfy( long theNodeId );
 328       virtual SMDSAbs_ElementType   GetType() const;
 329       virtual void                  SetType( SMDSAbs_ElementType theType );
 330
 331       bool                          AddToRange( long theEntityId );
 332       void                          GetRangeStr( TCollection_AsciiString& );
 333       bool                          SetRangeStr( const TCollection_AsciiString& );
 334
 335     protected:
 336       SMDS_Mesh*                    myMesh;
 337
 338       TColStd_SequenceOfInteger     myMin;
 339       TColStd_SequenceOfInteger     myMax;
 340       TColStd_MapOfInteger          myIds;
 341
 342       SMDSAbs_ElementType           myType;
 343     };
 344
 345     typedef boost::shared_ptr<RangeOfIds> RangeOfIdsPtr;
 346
 347
 348     /*
 349       Class       : Comparator
 350       Description : Base class for comparators
 351     */
 352     class Comparator: public virtual Predicate{
 353     public:
 354       Comparator();
 355       virtual ~Comparator();
 356       virtual void SetMesh( SMDS_Mesh* theMesh );
 357       virtual void SetMargin(double theValue);
 358       virtual void SetNumFunctor(NumericalFunctorPtr theFunct);
 359       virtual bool IsSatisfy( long theElementId ) = 0;
 360       virtual SMDSAbs_ElementType GetType() const;
 361       double  GetMargin();
 362
 363     protected:
 364       double myMargin;
 365       NumericalFunctorPtr myFunctor;
 366     };
 367     typedef boost::shared_ptr<Comparator> ComparatorPtr;
 368
 369
 370     /*
 371       Class       : LessThan
 372       Description : Comparator "<"
 373     */
 374     class LessThan: public virtual Comparator{
 375     public:
 376       virtual bool IsSatisfy( long theElementId );
 377     };
 378
 379
 380     /*
 381       Class       : MoreThan
 382       Description : Comparator ">"
 383     */
 384     class MoreThan: public virtual Comparator{
 385     public:
 386       virtual bool IsSatisfy( long theElementId );
 387     };
 388
 389
 390     /*
 391       Class       : EqualTo
 392       Description : Comparator "="
 393     */
 394     class EqualTo: public virtual Comparator{
 395     public:
 396       EqualTo();
 397       virtual bool IsSatisfy( long theElementId );
 398       virtual void SetTolerance( double theTol );
 399       virtual double GetTolerance();
 400
 401     private:
 402       double myToler;
 403     };
 404     typedef boost::shared_ptr<EqualTo> EqualToPtr;
 405
 406
 407     /*
 408       Class       : LogicalNOT
 409       Description : Logical NOT predicate
 410     */
 411     class LogicalNOT: public virtual Predicate{
 412     public:
 413       LogicalNOT();
 414       virtual ~LogicalNOT();
 415       virtual bool IsSatisfy( long theElementId );
 416       virtual void SetMesh( SMDS_Mesh* theMesh );
 417       virtual void SetPredicate(PredicatePtr thePred);
 418       virtual SMDSAbs_ElementType GetType() const;
 419
 420     private:
 421       PredicatePtr myPredicate;
 422     };
 423     typedef boost::shared_ptr<LogicalNOT> LogicalNOTPtr;
 424
 425
 426     /*
 427       Class       : LogicalBinary
 428       Description : Base class for binary logical predicate
 429     */
 430     class LogicalBinary: public virtual Predicate{
 431     public:
 432       LogicalBinary();
 433       virtual ~LogicalBinary();
 434       virtual void SetMesh( SMDS_Mesh* theMesh );
 435       virtual void SetPredicate1(PredicatePtr thePred);
 436       virtual void SetPredicate2(PredicatePtr thePred);
 437       virtual SMDSAbs_ElementType GetType() const;
 438
 439     protected:
 440       PredicatePtr myPredicate1;
 441       PredicatePtr myPredicate2;
 442     };
 443     typedef boost::shared_ptr<LogicalBinary> LogicalBinaryPtr;
 444
 445
 446     /*
 447       Class       : LogicalAND
 448       Description : Logical AND
 449     */
 450     class LogicalAND: public virtual LogicalBinary{
 451     public:
 452       virtual bool IsSatisfy( long theElementId );
 453     };
 454
 455
 456     /*
 457       Class       : LogicalOR
 458       Description : Logical OR
 459     */
 460     class LogicalOR: public virtual LogicalBinary{
 461     public:
 462       virtual bool IsSatisfy( long theElementId );
 463     };
 464
 465
 466     /*
 467       Class       : ManifoldPart
 468       Description : Predicate for manifold part of mesh
 469     */
 470     class ManifoldPart: public virtual Predicate{
 471     public:
 472
 473       /* internal class for algorithm uses */
 474       class Link
 475       {
 476       public:
 477         Link( SMDS_MeshNode* theNode1,
 478               SMDS_MeshNode* theNode2 );
 479         ~Link();
 480
 481         bool IsEqual( const ManifoldPart::Link& theLink ) const;
 482         bool operator<(const ManifoldPart::Link& x) const;
 483
 484         SMDS_MeshNode* myNode1;
 485         SMDS_MeshNode* myNode2;
 486       };
 487
 488       bool IsEqual( const ManifoldPart::Link& theLink1,
 489                     const ManifoldPart::Link& theLink2 );
 490
 491       typedef std::set<ManifoldPart::Link>                TMapOfLink;
 492       typedef std::vector<SMDS_MeshFace*>                 TVectorOfFacePtr;
 493       typedef std::vector<ManifoldPart::Link>             TVectorOfLink;
 494       typedef std::map<SMDS_MeshFace*,int>                TDataMapFacePtrInt;
 495       typedef std::map<ManifoldPart::Link,SMDS_MeshFace*> TDataMapOfLinkFacePtr;
 496
 497       ManifoldPart();
 498       ~ManifoldPart();
 499       virtual void SetMesh( SMDS_Mesh* theMesh );
 500       // inoke when all parameters already set
 501       virtual bool IsSatisfy( long theElementId );
 502       virtual      SMDSAbs_ElementType GetType() const;
 503
 504       void    SetAngleTolerance( const double theAngToler );
 505       double  GetAngleTolerance() const;
 506       void    SetIsOnlyManifold( const bool theIsOnly );
 507       void    SetStartElem( const long  theStartElemId );
 508
 509     private:
 510       bool    process();
 511       bool    findConnected( const TDataMapFacePtrInt& theAllFacePtrInt,
 512                              SMDS_MeshFace*            theStartFace,
 513                              TMapOfLink&               theNonManifold,
 514                              TColStd_MapOfInteger&     theResFaces );
 515       bool    isInPlane( const SMDS_MeshFace* theFace1,
 516                           const SMDS_MeshFace* theFace2 );
 517       void    expandBoundary( TMapOfLink&            theMapOfBoundary,
 518                               TVectorOfLink&         theSeqOfBoundary,
 519                               TDataMapOfLinkFacePtr& theDMapLinkFacePtr,
 520                               TMapOfLink&            theNonManifold,
 521                               SMDS_MeshFace*         theNextFace ) const;
 522
 523      void     getFacesByLink( const Link& theLink,
 524                               TVectorOfFacePtr& theFaces ) const;
 525
 526     private:
 527       SMDS_Mesh*            myMesh;
 528       TColStd_MapOfInteger  myMapIds;
 529       TColStd_MapOfInteger  myMapBadGeomIds;
 530       TVectorOfFacePtr      myAllFacePtr;
 531       TDataMapFacePtrInt    myAllFacePtrIntDMap;
 532       double                myAngToler;
 533       bool                  myIsOnlyManifold;
 534       long                  myStartElemId;
 535
 536     };
 537     typedef boost::shared_ptr<ManifoldPart> ManifoldPartPtr;
 538
 539
 540     /*
 541       Class       : ElementsOnSurface
 542       Description : Predicate elements that lying on indicated surface
 543                     (plane or cylinder)
 544     */
 545     class ElementsOnSurface : public virtual Predicate {
 546     public:
 547       ElementsOnSurface();
 548       ~ElementsOnSurface();
 549       virtual void SetMesh( SMDS_Mesh* theMesh );
 550       virtual bool IsSatisfy( long theElementId );
 551       virtual      SMDSAbs_ElementType GetType() const;
 552
 553       void    SetTolerance( const double theToler );
 554       double  GetTolerance() const;
 555       void    SetSurface( const TopoDS_Shape& theShape,
 556                           const SMDSAbs_ElementType theType );
 557
 558     private:
 559       void    process();
 560       void    process( const SMDS_MeshElement* theElem  );
 561       bool    isOnSurface( const SMDS_MeshNode* theNode ) const;
 562
 563     private:
 564       SMDS_Mesh*            myMesh;
 565       TColStd_MapOfInteger  myIds;
 566       SMDSAbs_ElementType   myType;
 567       Handle(Geom_Surface)  mySurf;
 568       double                myToler;
 569     };
 570
 571     typedef boost::shared_ptr<ElementsOnSurface> ElementsOnSurfacePtr;
 572
 573
 574     /*
 575       FILTER
 576     */
 577     class Filter{
 578     public:
 579       Filter();
 580       virtual ~Filter();
 581       virtual void SetPredicate(PredicatePtr thePred);
 582       typedef std::vector<long> TIdSequence;
 583       virtual TIdSequence GetElementsId( SMDS_Mesh* theMesh );
 584
 585     protected:
 586       PredicatePtr myPredicate;
 587     };
 588   };
 589 };
 590
 591
 592 #endif