-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
enum TSideID { QUAD_BOTTOM_SIDE=0, QUAD_RIGHT_SIDE, QUAD_TOP_SIDE, QUAD_LEFT_SIDE, NB_QUAD_SIDES };
typedef uvPtStruct UVPtStruct;
-struct FaceQuadStruct
+struct STDMESHERS_EXPORT FaceQuadStruct
{
- struct Side // a side of FaceQuadStruct
+ struct STDMESHERS_EXPORT Side // a side of FaceQuadStruct
{
- struct Contact // contact of two sides
+ struct STDMESHERS_EXPORT Contact // contact of two sides
{
int point; // index of a grid point of this side where two sides meat
Side* other_side;
};
StdMeshers_FaceSidePtr grid;
int from, to; // indices of grid points used by the quad
+ int di; // +1 or -1 depending on IsReversed()
std::set<int> forced_nodes; // indices of forced grid points
std::vector<Contact> contacts; // contacts with sides of other quads
int nbNodeOut; // nb of missing nodes on an opposite shorter side
int ToQuadIndex( int sideNodeIndex ) const;
bool IsForced( int nodeIndex ) const;
bool IsReversed() const { return nbNodeOut ? false : to < from; }
+ bool Reverse(bool keepGrid);
int NbPoints() const { return Abs( to - from ); }
double Param( int nodeIndex ) const;
double Length( int from=-1, int to=-1) const;
gp_XY Value2d( double x ) const;
+ const UVPtStruct& First() const { return GetUVPtStruct()[ from ]; }
+ const UVPtStruct& Last() const {
+ return GetUVPtStruct()[ to-nbNodeOut-(IsReversed() ? -1 : +1)];
+ }
// some sortcuts
- const vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
+ const std::vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
{ return nbNodeOut ?
grid->SimulateUVPtStruct( NbPoints()-nbNodeOut-1, isXConst, constValue ) :
grid->GetUVPtStruct( isXConst, constValue );
}
};
+ struct SideIterator // iterator on UVPtStruct of a Side
+ {
+ const UVPtStruct *uvPtr, *uvEnd;
+ int dPtr, counter;
+ SideIterator(): uvPtr(0), uvEnd(0), dPtr(0), counter(0) {}
+ void Init( const Side& side ) {
+ dPtr = counter = 0;
+ uvPtr = uvEnd = 0;
+ if ( side.NbPoints() > 0 ) {
+ uvPtr = & side.First();
+ uvEnd = & side.Last();
+ dPtr = ( uvEnd > uvPtr ) ? +1 : -1;
+ uvEnd += dPtr;
+ }
+ }
+ bool More() const { return uvPtr != uvEnd; }
+ void Next() { uvPtr += dPtr; ++counter; }
+ UVPtStruct& UVPt() const { return (UVPtStruct&) *uvPtr; }
+ UVPtStruct& operator[](int i) { return (UVPtStruct&) uvPtr[ i*dPtr]; }
+ int Count() const { return counter; }
+ };
std::vector< Side > side;
std::vector< UVPtStruct> uv_grid;
int iSize, jSize;
TopoDS_Face face;
Bnd_B2d uv_box;
+ std::string name; // to ease debugging
- FaceQuadStruct ( const TopoDS_Face& F = TopoDS_Face() );
+ FaceQuadStruct ( const TopoDS_Face& F = TopoDS_Face(), const std::string& nm="main" );
UVPtStruct& UVPt( int i, int j ) { return uv_grid[ i + j * iSize ]; }
- void shift ( size_t nb, bool keepUnitOri );
+ double& U( int i, int j ) { return UVPt( i, j ).u; }
+ double& V( int i, int j ) { return UVPt( i, j ).v; }
+ void shift ( size_t nb, bool keepUnitOri, bool keepGrid=false );
int & nbNodeOut( int iSide ) { return side[ iSide ].nbNodeOut; }
bool findCell ( const gp_XY& uv, int & i, int & j );
bool isNear ( const gp_XY& uv, int & i, int & j, int nbLoops=1 );
class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
{
-public:
- StdMeshers_Quadrangle_2D(int hypId, int studyId, SMESH_Gen* gen);
+ public:
+ StdMeshers_Quadrangle_2D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Quadrangle_2D();
virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
FaceQuadStruct::Ptr CheckNbEdges(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
- const bool considerMesh=false);
+ const bool considerMesh = false,
+ SMESH_MesherHelper* aFaceHelper = 0);
-protected:
+ virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+ {
+ return IsApplicable( shape, toCheckAll );
+ }
+ static bool IsApplicable(const TopoDS_Shape & aShape, bool toCheckAll);
+
+ protected:
bool checkNbEdgesForEvaluate(SMESH_Mesh& aMesh,
const TopoDS_Shape & aShape,
bool& IsQuadratic);
bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
-
+
void splitQuadFace(SMESHDS_Mesh * theMeshDS,
const int theFaceID,
const SMDS_MeshNode* theNode1,
void smooth (FaceQuadStruct::Ptr quad);
+ bool check();
+
int getCorners(const TopoDS_Face& theFace,
SMESH_Mesh & theMesh,
std::list<TopoDS_Edge>& theWire,
int splitQuad(FaceQuadStruct::Ptr quad, int i, int j);
+ void shiftQuad(FaceQuadStruct::Ptr& quad, const int num );
+
typedef std::map< StdMeshers_FaceSidePtr, std::vector< FaceQuadStruct::Ptr > > TQuadsBySide;
void updateSideUV( FaceQuadStruct::Side& side,
int iForced,
int * iNext=NULL);
- // Fields
+ protected: // Fields
bool myQuadranglePreference;
bool myTrianglePreference;
int myTriaVertexID;
- bool myNeedSmooth;
+ bool myNeedSmooth, myCheckOri;
const StdMeshers_QuadrangleParams* myParams;
StdMeshers_QuadType myQuadType;
struct ForcedPoint
{
- gp_XY uv;
- gp_XYZ xyz;
- TopoDS_Vertex vertex;
+ gp_XY uv;
+ gp_XYZ xyz;
+ TopoDS_Vertex vertex;
+ const SMDS_MeshNode* node;
double U() const { return uv.X(); }
double V() const { return uv.Y(); }
