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