1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : StdMeshers_Quadrangle_2D.hxx
23 // Moved here from SMESH_Quadrangle_2D.hxx
24 // Author : Paul RASCLE, EDF
27 #ifndef _SMESH_QUADRANGLE_2D_HXX_
28 #define _SMESH_QUADRANGLE_2D_HXX_
30 #include "SMESH_Algo.hxx"
31 #include "SMESH_ProxyMesh.hxx"
32 #include "SMESH_StdMeshers.hxx"
33 #include "StdMeshers_FaceSide.hxx"
34 #include "StdMeshers_QuadrangleParams.hxx"
36 #include <TopoDS_Face.hxx>
37 #include <Bnd_B2d.hxx>
41 class SMESH_MesherHelper;
42 class SMESH_ProxyMesh;
46 enum TSideID { QUAD_BOTTOM_SIDE=0, QUAD_RIGHT_SIDE, QUAD_TOP_SIDE, QUAD_LEFT_SIDE, NB_QUAD_SIDES };
48 typedef uvPtStruct UVPtStruct;
51 struct Side // a side of FaceQuadStruct
53 struct Contact // contact of two sides
55 int point; // index of a grid point of this side where two sides meat
59 StdMeshers_FaceSidePtr grid;
60 int from, to; // indices of grid points used by the quad
61 int di; // +1 or -1 depending on IsReversed()
62 std::set<int> forced_nodes; // indices of forced grid points
63 std::vector<Contact> contacts; // contacts with sides of other quads
64 int nbNodeOut; // nb of missing nodes on an opposite shorter side
66 Side(StdMeshers_FaceSidePtr theGrid = StdMeshers_FaceSidePtr());
67 Side& operator=(const Side& otherSide);
68 operator StdMeshers_FaceSidePtr() { return grid; }
69 operator const StdMeshers_FaceSidePtr() const { return grid; }
70 void AddContact( int ip, Side* side, int iop );
71 int ToSideIndex( int quadNodeIndex ) const;
72 int ToQuadIndex( int sideNodeIndex ) const;
73 bool IsForced( int nodeIndex ) const;
74 bool IsReversed() const { return nbNodeOut ? false : to < from; }
75 bool Reverse(bool keepGrid);
76 int NbPoints() const { return Abs( to - from ); }
77 double Param( int nodeIndex ) const;
78 double Length( int from=-1, int to=-1) const;
79 gp_XY Value2d( double x ) const;
80 const UVPtStruct& First() const { return GetUVPtStruct()[ from ]; }
81 const UVPtStruct& Last() const {
82 return GetUVPtStruct()[ to-nbNodeOut-(IsReversed() ? -1 : +1)];
85 const std::vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
87 grid->SimulateUVPtStruct( NbPoints()-nbNodeOut-1, isXConst, constValue ) :
88 grid->GetUVPtStruct( isXConst, constValue );
91 struct SideIterator // iterator on UVPtStruct of a Side
93 const UVPtStruct *uvPtr, *uvEnd;
95 SideIterator(): uvPtr(0), uvEnd(0), dPtr(0), counter(0) {}
96 void Init( const Side& side ) {
99 if ( side.NbPoints() > 0 ) {
100 uvPtr = & side.First();
101 uvEnd = & side.Last();
102 dPtr = ( uvEnd > uvPtr ) ? +1 : -1;
106 bool More() const { return uvPtr != uvEnd; }
107 void Next() { uvPtr += dPtr; ++counter; }
108 UVPtStruct& UVPt() const { return (UVPtStruct&) *uvPtr; }
109 UVPtStruct& operator[](int i) { return (UVPtStruct&) uvPtr[ i*dPtr]; }
110 int Count() const { return counter; }
113 std::vector< Side > side;
114 std::vector< UVPtStruct> uv_grid;
118 std::string name; // to ease debugging
120 FaceQuadStruct ( const TopoDS_Face& F = TopoDS_Face(), const std::string& nm="main" );
121 UVPtStruct& UVPt( int i, int j ) { return uv_grid[ i + j * iSize ]; }
122 double& U( int i, int j ) { return UVPt( i, j ).u; }
123 double& V( int i, int j ) { return UVPt( i, j ).v; }
124 void shift ( size_t nb, bool keepUnitOri, bool keepGrid=false );
125 int & nbNodeOut( int iSide ) { return side[ iSide ].nbNodeOut; }
126 bool findCell ( const gp_XY& uv, int & i, int & j );
127 bool isNear ( const gp_XY& uv, int & i, int & j, int nbLoops=1 );
128 bool isEqual ( const gp_XY& uv, int i, int j );
129 void normPa2IJ( double x, double y, int & i, int & j );
130 void updateUV ( const gp_XY& uv, int i, int j, bool isVertical );
132 typedef boost::shared_ptr<FaceQuadStruct> Ptr;
135 class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
138 StdMeshers_Quadrangle_2D(int hypId, SMESH_Gen* gen);
139 virtual ~StdMeshers_Quadrangle_2D();
141 virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
142 const TopoDS_Shape& aShape,
143 Hypothesis_Status& aStatus);
145 virtual bool Compute(SMESH_Mesh& aMesh,
146 const TopoDS_Shape& aShape);
148 virtual bool Evaluate(SMESH_Mesh & aMesh,
149 const TopoDS_Shape & aShape,
150 MapShapeNbElems& aResMap);
152 FaceQuadStruct::Ptr CheckAnd2Dcompute(SMESH_Mesh& aMesh,
153 const TopoDS_Shape& aShape,
154 const bool CreateQuadratic);
156 FaceQuadStruct::Ptr CheckNbEdges(SMESH_Mesh& aMesh,
157 const TopoDS_Shape& aShape,
158 const bool considerMesh = false,
159 SMESH_MesherHelper* aFaceHelper = 0);
161 virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
163 return IsApplicable( shape, toCheckAll );
165 static bool IsApplicable(const TopoDS_Shape & aShape, bool toCheckAll);
169 bool checkNbEdgesForEvaluate(SMESH_Mesh& aMesh,
170 const TopoDS_Shape & aShape,
171 MapShapeNbElems& aResMap,
172 std::vector<int>& aNbNodes,
175 bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
177 void splitQuadFace(SMESHDS_Mesh * theMeshDS,
179 const SMDS_MeshNode* theNode1,
180 const SMDS_MeshNode* theNode2,
181 const SMDS_MeshNode* theNode3,
182 const SMDS_MeshNode* theNode4);
184 bool computeQuadDominant(SMESH_Mesh& aMesh,
185 const TopoDS_Face& aFace);
187 bool computeQuadDominant(SMESH_Mesh& aMesh,
188 const TopoDS_Face& aFace,
189 FaceQuadStruct::Ptr quad);
191 bool computeQuadPref(SMESH_Mesh& aMesh,
192 const TopoDS_Face& aFace,
193 FaceQuadStruct::Ptr quad);
195 bool computeTriangles(SMESH_Mesh& aMesh,
196 const TopoDS_Face& aFace,
197 FaceQuadStruct::Ptr quad);
199 bool evaluateQuadPref(SMESH_Mesh& aMesh,
200 const TopoDS_Shape& aShape,
201 std::vector<int>& aNbNodes,
202 MapShapeNbElems& aResMap,
205 bool computeReduced (SMESH_Mesh& aMesh,
206 const TopoDS_Face& aFace,
207 FaceQuadStruct::Ptr quad);
209 void updateDegenUV(FaceQuadStruct::Ptr quad);
211 void smooth (FaceQuadStruct::Ptr quad);
215 int getCorners(const TopoDS_Face& theFace,
216 SMESH_Mesh & theMesh,
217 std::list<TopoDS_Edge>& theWire,
218 std::vector<TopoDS_Vertex>& theVertices,
219 int & theNbDegenEdges,
220 const bool considerMesh);
222 bool getEnforcedUV();
224 bool addEnforcedNodes();
226 int splitQuad(FaceQuadStruct::Ptr quad, int i, int j);
228 void shiftQuad(FaceQuadStruct::Ptr& quad, const int num );
230 typedef std::map< StdMeshers_FaceSidePtr, std::vector< FaceQuadStruct::Ptr > > TQuadsBySide;
231 void updateSideUV( FaceQuadStruct::Side& side,
233 const TQuadsBySide& quads,
239 bool myQuadranglePreference;
240 bool myTrianglePreference;
242 bool myNeedSmooth, myCheckOri;
243 const StdMeshers_QuadrangleParams* myParams;
244 StdMeshers_QuadType myQuadType;
246 SMESH_MesherHelper* myHelper;
247 SMESH_ProxyMesh::Ptr myProxyMesh;
248 std::list< FaceQuadStruct::Ptr > myQuadList;
254 TopoDS_Vertex vertex;
255 const SMDS_MeshNode* node;
257 double U() const { return uv.X(); }
258 double V() const { return uv.Y(); }
259 operator const gp_XY& () { return uv; }
261 std::vector< ForcedPoint > myForcedPnts;