-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 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
#include "SMDS_FacePosition.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
+#include "SMESHDS_Mesh.hxx"
#include "SMESH_Block.hxx"
#include "SMESH_Comment.hxx"
#include "SMESH_Gen.hxx"
#include <Geom_Surface.hxx>
#include <NCollection_DefineArray2.hxx>
#include <Precision.hxx>
-#include <Quantity_Parameter.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <TColgp_SequenceOfXY.hxx>
myQuadType(QUAD_STANDARD),
myHelper( NULL )
{
- MESSAGE("StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D");
_name = "Quadrangle_2D";
_shapeType = (1 << TopAbs_FACE);
_compatibleHypothesis.push_back("QuadrangleParams");
StdMeshers_Quadrangle_2D::~StdMeshers_Quadrangle_2D()
{
- MESSAGE("StdMeshers_Quadrangle_2D::~StdMeshers_Quadrangle_2D");
}
//=============================================================================
}
else if (strcmp("TrianglePreference", aHyp->GetName()) == 0){
isFirstParams = false;
- myTrianglePreference = true;
+ myTrianglePreference = true;
}
else {
isFirstParams = false;
if (isFirstParams) {
if (strcmp("QuadranglePreference", aHyp->GetName()) == 0) {
myQuadranglePreference = true;
- myTrianglePreference = false;
+ myTrianglePreference = false;
myQuadType = QUAD_STANDARD;
}
else if (strcmp("TrianglePreference", aHyp->GetName()) == 0){
myQuadranglePreference = false;
- myTrianglePreference = true;
+ myTrianglePreference = true;
myQuadType = QUAD_STANDARD;
}
}
- else {
- const StdMeshers_QuadrangleParams* aHyp2 =
- (const StdMeshers_QuadrangleParams*)aHyp;
+ else if (const StdMeshers_QuadrangleParams* aHyp2 =
+ dynamic_cast<const StdMeshers_QuadrangleParams*>( aHyp ))
+ {
myTriaVertexID = aHyp2->GetTriaVertex();
if (!myQuadranglePreference && !myTrianglePreference) { // priority of hypos
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
myNeedSmooth = false;
myCheckOri = false;
- FaceQuadStruct::Ptr quad = CheckNbEdges( aMesh, F, /*considerMesh=*/true );
+ FaceQuadStruct::Ptr quad = CheckNbEdges( aMesh, F, /*considerMesh=*/true, myHelper );
if (!quad)
return false;
myQuadList.clear();
int nbright = (int) uv_e1.size();
int nbleft = (int) uv_e3.size();
- if (quad->nbNodeOut(0) && nbvertic == 2) // this should not occure
+ if (quad->nbNodeOut(0) && nbvertic == 2) // this should not occur
{
// Down edge is out
//
// for each node of the down edge find nearest node
// in the first row of the regular grid and link them
for (i = 0; i < stop; i++) {
- const SMDS_MeshNode *a, *b, *c, *d;
+ const SMDS_MeshNode *a, *b, *c=0, *d;
a = uv_e0[i].node;
b = uv_e0[i + 1].node;
gp_Pnt pb (b->X(), b->Y(), b->Z());
}
else {
// find in the grid node c, nearest to the b
+ c = 0;
double mind = RealLast();
for (int k = g; k <= iup; k++) {
int stop = 0;
if ( quad->side[3].grid->Edge(0).IsNull() ) // left side is simulated one
{
- // quad divided at I but not at J, as nbvertic==nbright==2
- stop++; // we stop at a second node
+ if ( nbright == 2 ) // quad divided at I but not at J (2D_mesh_QuadranglePreference_01/B1)
+ stop++; // we stop at a second node
}
else
{
}
// for each node of the up edge find nearest node
// in the first row of the regular grid and link them
- for ( ; i > stop; i--) {
+ for ( ; i > stop; i--)
+ {
a = uv_e2[i].node;
b = uv_e2[i - 1].node;
gp_Pnt pb = SMESH_TNodeXYZ( b );
}
// right or left boundary quadrangles
- if (quad->nbNodeOut( QUAD_RIGHT_SIDE ) && nbhoriz == 2) // this should not occure
+ if (quad->nbNodeOut( QUAD_RIGHT_SIDE ) && nbhoriz == 2) // this should not occur
{
int g = 0; // last processed node in the grid
int stop = nbright - 1;
gp_Pnt pb (b->X(), b->Y(), b->Z());
// find node c in the grid, nearest to the b
+ c = 0;
int near = g;
- if (i == stop - 1) { // up bondary reached
+ if (i == stop - 1) { // up boundary reached
c = quad->uv_grid[nbhoriz*(jup + 1) - 2].node;
near = jup;
} else {
}
}
} else {
- if (quad->nbNodeOut(3) && nbhoriz == 2) {
-// MESSAGE("left edge is out");
+ if (quad->nbNodeOut(3) && nbhoriz == 2)
+ {
int g = nbvertic - 1; // last processed node in the grid
int stop = 0;
i = quad->side[ QUAD_LEFT_SIDE ].to-1; // nbleft - 1;
// find node c in the grid, nearest to the b
int near = g;
- if (i == stop + 1) { // down bondary reached
+ if (i == stop + 1) { // down boundary reached
c = quad->uv_grid[nbhoriz*jlow + 1].node;
near = jlow;
}
FaceQuadStruct::Ptr StdMeshers_Quadrangle_2D::CheckNbEdges(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape,
- const bool considerMesh)
+ const bool considerMesh,
+ SMESH_MesherHelper* aFaceHelper)
{
if ( !myQuadList.empty() && myQuadList.front()->face.IsSame( aShape ))
return myQuadList.front();
}
// find corner vertices of the quad
+ myHelper = ( aFaceHelper && aFaceHelper->GetSubShape() == aShape ) ? aFaceHelper : NULL;
vector<TopoDS_Vertex> corners;
int nbDegenEdges, nbSides = getCorners( F, aMesh, edges, corners, nbDegenEdges, considerMesh );
if ( nbSides == 0 )
sideEdges.push_back( *edgeIt++ );
if ( !sideEdges.empty() )
quad->side.push_back( StdMeshers_FaceSide::New(F, sideEdges, &aMesh, iSide < QUAD_TOP_SIDE,
- ignoreMediumNodes, myProxyMesh));
+ ignoreMediumNodes, myHelper, myProxyMesh));
else
--iSide;
}
{
quad->side.push_back
( StdMeshers_FaceSide::New( F, sideEdges, &aMesh, iSide < QUAD_TOP_SIDE,
- ignoreMediumNodes, myProxyMesh ));
+ ignoreMediumNodes, myHelper, myProxyMesh ));
++iSide;
}
if ( quad->side.size() == 4 )
//=======================================================================
//function : ShiftQuad
-//purpose : auxilary function for computeQuadPref
+//purpose : auxiliary function for computeQuadPref
//=======================================================================
void StdMeshers_Quadrangle_2D::shiftQuad(FaceQuadStruct::Ptr& quad, const int num )
//=======================================================================
//function : calcUV
-//purpose : auxilary function for computeQuadPref
+//purpose : auxiliary function for computeQuadPref
//=======================================================================
static gp_UV calcUV(double x0, double x1, double y0, double y1,
//=======================================================================
//function : calcUV2
-//purpose : auxilary function for computeQuadPref
+//purpose : auxiliary function for computeQuadPref
//=======================================================================
static gp_UV calcUV2(double x, double y,
// 0 bottom 1
- const int bfrom = quad->side[0].from;
- const int rfrom = quad->side[1].from;
+ //const int bfrom = quad->side[0].from;
+ //const int rfrom = quad->side[1].from;
const int tfrom = quad->side[2].from;
- const int lfrom = quad->side[3].from;
+ //const int lfrom = quad->side[3].from;
{
const vector<UVPtStruct>& uv_eb_vec = quad->side[0].GetUVPtStruct(true,0);
const vector<UVPtStruct>& uv_er_vec = quad->side[1].GetUVPtStruct(false,1);
} // if ( dv != 0 && dh != 0 )
- const int db = quad->side[0].IsReversed() ? -1 : +1;
- const int dr = quad->side[1].IsReversed() ? -1 : +1;
+ //const int db = quad->side[0].IsReversed() ? -1 : +1;
+ //const int dr = quad->side[1].IsReversed() ? -1 : +1;
const int dt = quad->side[2].IsReversed() ? -1 : +1;
- const int dl = quad->side[3].IsReversed() ? -1 : +1;
+ //const int dl = quad->side[3].IsReversed() ? -1 : +1;
// Case dv == 0, here possibly myQuadList.size() > 1
//
npl.Append(uv_el[i].normParam);
}
- int dl,dr;
+ int dl = 0, dr = 0;
if (OldVersion) {
// add some params to right and left after the first param
// insert to right
}
int nnn = Min(nr,nl);
- // auxilary sequence of XY for creation nodes
+ // auxiliary sequence of XY for creation nodes
// in the bottom part of central domain
// Length of UVL and UVR must be == nbv-nnn
TColgp_SequenceOfXY UVL, UVR, UVT;
TColgp_SequenceOfXY UVtmp;
double drparam = npr.Value(nr) - npr.Value(nnn-1);
double dlparam = npl.Value(nnn) - npl.Value(nnn-1);
- double y0,y1;
+ double y0 = 0, y1 = 0;
for (i=1; i<=drl; i++) {
// add existed nodes from right edge
NodesC.SetValue(nb,i+1,uv_er[nnn+i-2].node);
MapShapeNbElems& aResMap,
bool IsQuadratic)
{
- // Auxilary key in order to keep old variant
+ // Auxiliary key in order to keep old variant
// of meshing after implementation new variant
// for bug 0016220 from Mantis.
bool OldVersion = false;
const vector<UVPtStruct>& uv_et = quad->side[2].GetUVPtStruct(true,1);
const vector<UVPtStruct>& uv_el = quad->side[3].GetUVPtStruct(false,0);
- if (uv_eb.size() != nb || uv_er.size() != nr || uv_et.size() != nt || uv_el.size() != nl)
+ if ((int) uv_eb.size() != nb || (int) uv_er.size() != nr ||
+ (int) uv_et.size() != nt || (int) uv_el.size() != nl)
return error(COMPERR_BAD_INPUT_MESH);
// arrays for normalized params
gp_XY a3 (uv_et.front().u, uv_et.front().v);
int nnn = Min(nr,nl);
- // auxilary sequence of XY for creation of nodes
+ // auxiliary sequence of XY for creation of nodes
// in the bottom part of central domain
// it's length must be == nbv-nnn-1
TColgp_SequenceOfXY UVL;
const vector<UVPtStruct>& uv_et = quad->side[2].GetUVPtStruct(true,1);
const vector<UVPtStruct>& uv_el = quad->side[3].GetUVPtStruct(false,0);
- if (uv_eb.size() != nb || uv_er.size() != nr || uv_et.size() != nt || uv_el.size() != nl)
+ if ((int) uv_eb.size() != nb || (int) uv_er.size() != nr ||
+ (int) uv_et.size() != nt || (int) uv_el.size() != nl)
return error(COMPERR_BAD_INPUT_MESH);
gp_UV uv[ UV_SIZE ];
vector<UVPtStruct> curr_base = uv_eb, next_base;
- UVPtStruct nullUVPtStruct; nullUVPtStruct.node = 0;
+ UVPtStruct nullUVPtStruct;
+ nullUVPtStruct.node = 0;
+ nullUVPtStruct.x = nullUVPtStruct.y = nullUVPtStruct.u = nullUVPtStruct.v = 0;
+ nullUVPtStruct.param = 0;
+
int curr_base_len = nb;
int next_base_len = 0;
}
}
- // define refernce orientation in 2D
+ // define reference orientation in 2D
TNo2SmooNoMap::iterator n2sn = smooNoMap.begin();
for ( ; n2sn != smooNoMap.end(); ++n2sn )
if ( !n2sn->second._triangles.empty() )
{
TError err;
TSideVector wireVec =
- StdMeshers_FaceSide::GetFaceWires( geomFace, *myHelper->GetMesh(), true, err );
+ StdMeshers_FaceSide::GetFaceWires( geomFace, *myHelper->GetMesh(), true, err, myHelper );
StdMeshers_FaceSidePtr wire = wireVec[0];
// find a right angle VERTEX
- int iVertex;
+ int iVertex = 0;
double maxAngle = -1e100;
for ( int i = 0; i < wire->NbEdges(); ++i )
{
theNbDegenEdges = 0;
SMESH_MesherHelper helper( theMesh );
- StdMeshers_FaceSide faceSide( theFace, theWire, &theMesh, /*isFwd=*/true, /*skipMedium=*/true);
+ if ( myHelper )
+ helper.CopySubShapeInfo( *myHelper );
+ StdMeshers_FaceSide faceSide( theFace, theWire, &theMesh,
+ /*isFwd=*/true, /*skipMedium=*/true, &helper );
// sort theVertices by angle
multimap<double, TopoDS_Vertex> vertexByAngle;
// check if there are possible variations in choosing corners
bool haveVariants = false;
- if ( vertexByAngle.size() > nbCorners )
+ if ((int) vertexByAngle.size() > nbCorners )
{
double lostAngle = a2v->first;
double lastAngle = ( --a2v, a2v->first );
}
const double angleTol = 5.* M_PI/180;
- myCheckOri = ( vertexByAngle.size() > nbCorners ||
+ myCheckOri = ( (int)vertexByAngle.size() > nbCorners ||
vertexByAngle.begin()->first < angleTol );
// make theWire begin from a corner vertex or triaVertex
{
// select two halfDivider's as corners
TGeoIndex hd1, hd2 = -1;
- int iC2;
+ size_t iC2;
for ( iC2 = 0; iC2 < cornerInd.size() && hd2 < 0; ++iC2 )
{
hd1 = cornerInd[ iC2 ];
// move corners to make sides equal by length
int nbEqualV = equVerts.size();
int nbExcessV = nbEqualV - ( 1 + nbC[0] + nbC[1] );
- if ( nbExcessV > 0 ) // there is nbExcessV vertices that can become corners
+ if ( nbExcessV > 0 ) // there are nbExcessV vertices that can become corners
{
// calculate normalized length of each "side" enclosed between neighbor equVerts
vector< double > accuLength;
double totalLen = 0;
vector< TGeoIndex > evVec( equVerts.begin(), equVerts.end() );
- int iEV = 0;
+ size_t iEV = 0;
TGeoIndex iE = cornerInd[ helper.WrapIndex( iC - nbC[0] - 1, cornerInd.size() )];
TGeoIndex iEEnd = cornerInd[ helper.WrapIndex( iC + nbC[1] + 1, cornerInd.size() )];
- while ( accuLength.size() < nbEqualV + int( !allCornersSame ) )
+ while ((int) accuLength.size() < nbEqualV + int( !allCornersSame ) )
{
// accumulate length of edges before iEV-th equal vertex
accuLength.push_back( totalLen );
if ( iBestEV > iS-1 + nbExcessV )
iBestEV = iS-1 + nbExcessV;
theVertices[ iCorner ] = helper.IthVertex( 0, edgeVec[ evVec[ iBestEV ]]);
+ cornerInd [ iCorner ] = evVec[ iBestEV ];
refinedCorners.insert( evVec[ iBestEV ]);
iCorner = helper.WrapIndex( iCorner + 1, cornerInd.size() );
}
quadsBySide[ (*quadIt)->side[iSide] ].push_back( *quadIt );
}
- SMESH_Mesh* mesh = myHelper->GetMesh();
- SMESHDS_Mesh* meshDS = myHelper->GetMeshDS();
const TopoDS_Face& face = TopoDS::Face( myHelper->GetSubShape() );
Handle(Geom_Surface) surf = BRep_Tool::Surface( face );
continue;
const vector<UVPtStruct>& oGrid = side.contacts[iC].other_side->grid->GetUVPtStruct();
const UVPtStruct& uvPt = points[ side.contacts[iC].point ];
- if ( side.contacts[iC].other_point >= oGrid .size() ||
- side.contacts[iC].point >= points.size() )
+ if ( side.contacts[iC].other_point >= (int) oGrid .size() ||
+ side.contacts[iC].point >= (int) points.size() )
throw SALOME_Exception( "StdMeshers_Quadrangle_2D::addEnforcedNodes(): wrong contact" );
if ( oGrid[ side.contacts[iC].other_point ].node )
(( UVPtStruct& ) uvPt).node = oGrid[ side.contacts[iC].other_point ].node;
return;
}
- const int iFrom = Min ( iForced, *iNext );
- const int iTo = Max ( iForced, *iNext ) + 1;
- const int sideSize = iTo - iFrom;
+ const int iFrom = Min ( iForced, *iNext );
+ const int iTo = Max ( iForced, *iNext ) + 1;
+ const size_t sideSize = iTo - iFrom;
vector<UVPtStruct> points[4]; // side points of a temporary quad
for ( int is2nd = 0; is2nd < 2; ++is2nd )
{
points[ is2nd ].reserve( sideSize );
- int nbLoops = 0;
+ size_t nbLoops = 0;
while ( points[is2nd].size() < sideSize )
{
int iCur = iFrom + points[is2nd].size() - int( !points[is2nd].empty() );
for ( iS = 0; iS < q->side.size(); ++iS )
if ( side.grid == q->side[ iS ].grid )
break;
+ if ( iS == q->side.size() )
+ continue;
bool isOut;
if ( !q->side[ iS ].IsReversed() )
isOut = ( q->side[ iS ].from > iCur || q->side[ iS ].to-1 <= iCur );
void FaceQuadStruct::Side::AddContact( int ip, Side* side, int iop )
{
- if ( ip >= GetUVPtStruct().size() ||
- iop >= side->GetUVPtStruct().size() )
+ if ( ip >= (int) GetUVPtStruct().size() ||
+ iop >= (int) side->GetUVPtStruct().size() )
throw SALOME_Exception( "FaceQuadStruct::Side::AddContact(): wrong point" );
if ( ip < from || ip >= to )
return;
