-// 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"
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
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
// 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 );
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
c = quad->uv_grid[nbhoriz*(jup + 1) - 2].node;
}
}
} 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;
// 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
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);
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
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;
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 )
{
// 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;
