+ if (nbSides != 4) {
+ if (!nbSides)
+ nbSides = nbEdgesInWire.front();
+ error(COMPERR_BAD_SHAPE, TComm("Face must have 4 sides but not ") << nbSides);
+ return false;
+ }
+
+ return true;
+}
+
+
+//=============================================================================
+/*!
+ * CheckAnd2Dcompute
+ */
+//=============================================================================
+
+FaceQuadStruct::Ptr
+StdMeshers_Quadrangle_2D::CheckAnd2Dcompute (SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const bool CreateQuadratic)
+{
+ _quadraticMesh = CreateQuadratic;
+
+ FaceQuadStruct::Ptr quad = CheckNbEdges(aMesh, aShape);
+ if ( quad )
+ {
+ // set normalized grid on unit square in parametric domain
+ if ( ! setNormalizedGrid( quad ))
+ quad.reset();
+ }
+ return quad;
+}
+
+namespace
+{
+ inline const vector<UVPtStruct>& getUVPtStructIn(FaceQuadStruct::Ptr& quad, int i, int nbSeg)
+ {
+ bool isXConst = (i == QUAD_BOTTOM_SIDE || i == QUAD_TOP_SIDE);
+ double constValue = (i == QUAD_BOTTOM_SIDE || i == QUAD_LEFT_SIDE) ? 0 : 1;
+ return
+ quad->nbNodeOut(i) ?
+ quad->side[i].grid->SimulateUVPtStruct(nbSeg,isXConst,constValue) :
+ quad->side[i].grid->GetUVPtStruct (isXConst,constValue);
+ }
+ inline gp_UV calcUV(double x, double y,
+ const gp_UV& a0,const gp_UV& a1,const gp_UV& a2,const gp_UV& a3,
+ const gp_UV& p0,const gp_UV& p1,const gp_UV& p2,const gp_UV& p3)
+ {
+ return
+ ((1 - y) * p0 + x * p1 + y * p2 + (1 - x) * p3 ) -
+ ((1 - x) * (1 - y) * a0 + x * (1 - y) * a1 + x * y * a2 + (1 - x) * y * a3);
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_Quadrangle_2D::setNormalizedGrid (FaceQuadStruct::Ptr quad)
+{
+ if ( !quad->uv_grid.empty() )
+ return true;
+
+ // Algorithme décrit dans "Génération automatique de maillages"
+ // P.L. GEORGE, MASSON, § 6.4.1 p. 84-85
+ // traitement dans le domaine paramétrique 2d u,v
+ // transport - projection sur le carré unité
+
+ // max min 0 x1 1
+ // |<----north-2-------^ a3 -------------> a2
+ // | | ^1 1^
+ // west-3 east-1 =right | |
+ // | | ==> | |
+ // y0 | | y1 | |
+ // | | |0 0|
+ // v----south-0--------> a0 -------------> a1
+ // min max 0 x0 1
+ // =down
+ //
+ const FaceQuadStruct::Side & bSide = quad->side[0];
+ const FaceQuadStruct::Side & rSide = quad->side[1];
+ const FaceQuadStruct::Side & tSide = quad->side[2];
+ const FaceQuadStruct::Side & lSide = quad->side[3];
+
+ int nbhoriz = Min( bSide.NbPoints(), tSide.NbPoints() );
+ int nbvertic = Min( rSide.NbPoints(), lSide.NbPoints() );
+
+ if ( myQuadList.size() == 1 )
+ {
+ // all sub-quads must have NO sides with nbNodeOut > 0
+ quad->nbNodeOut(0) = Max( 0, bSide.grid->NbPoints() - tSide.grid->NbPoints() );
+ quad->nbNodeOut(1) = Max( 0, rSide.grid->NbPoints() - lSide.grid->NbPoints() );
+ quad->nbNodeOut(2) = Max( 0, tSide.grid->NbPoints() - bSide.grid->NbPoints() );
+ quad->nbNodeOut(3) = Max( 0, lSide.grid->NbPoints() - rSide.grid->NbPoints() );
+ }
+ const vector<UVPtStruct>& uv_e0 = bSide.GetUVPtStruct();
+ const vector<UVPtStruct>& uv_e1 = rSide.GetUVPtStruct();
+ const vector<UVPtStruct>& uv_e2 = tSide.GetUVPtStruct();
+ const vector<UVPtStruct>& uv_e3 = lSide.GetUVPtStruct();
+ if (uv_e0.empty() || uv_e1.empty() || uv_e2.empty() || uv_e3.empty())
+ //return error("Can't find nodes on sides");
+ return error(COMPERR_BAD_INPUT_MESH);
+
+ quad->uv_grid.resize( nbvertic * nbhoriz );
+ quad->iSize = nbhoriz;
+ quad->jSize = nbvertic;
+ UVPtStruct *uv_grid = & quad->uv_grid[0];
+
+ quad->uv_box.Clear();
+
+ // copy data of face boundary
+
+ FaceQuadStruct::SideIterator sideIter;
+
+ { // BOTTOM
+ const int j = 0;
+ const double x0 = bSide.First().normParam;
+ const double dx = bSide.Last().normParam - bSide.First().normParam;
+ for ( sideIter.Init( bSide ); sideIter.More(); sideIter.Next() ) {
+ sideIter.UVPt().x = ( sideIter.UVPt().normParam - x0 ) / dx;
+ sideIter.UVPt().y = 0.;
+ uv_grid[ j * nbhoriz + sideIter.Count() ] = sideIter.UVPt();
+ quad->uv_box.Add( sideIter.UVPt().UV() );
+ }
+ }
+ { // RIGHT
+ const int i = nbhoriz - 1;
+ const double y0 = rSide.First().normParam;
+ const double dy = rSide.Last().normParam - rSide.First().normParam;
+ sideIter.Init( rSide );
+ if ( quad->UVPt( i, sideIter.Count() ).node )
+ sideIter.Next(); // avoid copying from a split emulated side
+ for ( ; sideIter.More(); sideIter.Next() ) {
+ sideIter.UVPt().x = 1.;
+ sideIter.UVPt().y = ( sideIter.UVPt().normParam - y0 ) / dy;
+ uv_grid[ sideIter.Count() * nbhoriz + i ] = sideIter.UVPt();
+ quad->uv_box.Add( sideIter.UVPt().UV() );
+ }
+ }
+ { // TOP
+ const int j = nbvertic - 1;
+ const double x0 = tSide.First().normParam;
+ const double dx = tSide.Last().normParam - tSide.First().normParam;
+ int i = 0, nb = nbhoriz;
+ sideIter.Init( tSide );
+ if ( quad->UVPt( nb-1, j ).node ) --nb; // avoid copying from a split emulated side
+ for ( ; i < nb; i++, sideIter.Next()) {
+ sideIter.UVPt().x = ( sideIter.UVPt().normParam - x0 ) / dx;
+ sideIter.UVPt().y = 1.;
+ uv_grid[ j * nbhoriz + i ] = sideIter.UVPt();
+ quad->uv_box.Add( sideIter.UVPt().UV() );
+ }
+ }
+ { // LEFT
+ const int i = 0;
+ const double y0 = lSide.First().normParam;
+ const double dy = lSide.Last().normParam - lSide.First().normParam;
+ int j = 0, nb = nbvertic;
+ sideIter.Init( lSide );
+ if ( quad->UVPt( i, j ).node )
+ ++j, sideIter.Next(); // avoid copying from a split emulated side
+ if ( quad->UVPt( i, nb-1 ).node )
+ --nb;
+ for ( ; j < nb; j++, sideIter.Next()) {
+ sideIter.UVPt().x = 0.;
+ sideIter.UVPt().y = ( sideIter.UVPt().normParam - y0 ) / dy;
+ uv_grid[ j * nbhoriz + i ] = sideIter.UVPt();
+ quad->uv_box.Add( sideIter.UVPt().UV() );
+ }
+ }
+
+ // normalized 2d parameters on grid
+
+ for (int i = 1; i < nbhoriz-1; i++)
+ {
+ const double x0 = quad->UVPt( i, 0 ).x;
+ const double x1 = quad->UVPt( i, nbvertic-1 ).x;
+ for (int j = 1; j < nbvertic-1; j++)
+ {
+ const double y0 = quad->UVPt( 0, j ).y;
+ const double y1 = quad->UVPt( nbhoriz-1, j ).y;
+ // --- intersection : x=x0+(y0+x(y1-y0))(x1-x0)
+ double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
+ double y = y0 + x * (y1 - y0);
+ int ij = j * nbhoriz + i;
+ uv_grid[ij].x = x;
+ uv_grid[ij].y = y;
+ uv_grid[ij].node = NULL;
+ }
+ }
+
+ // projection on 2d domain (u,v)
+
+ gp_UV a0 = quad->UVPt( 0, 0 ).UV();
+ gp_UV a1 = quad->UVPt( nbhoriz-1, 0 ).UV();
+ gp_UV a2 = quad->UVPt( nbhoriz-1, nbvertic-1 ).UV();
+ gp_UV a3 = quad->UVPt( 0, nbvertic-1 ).UV();
+
+ for (int i = 1; i < nbhoriz-1; i++)
+ {
+ gp_UV p0 = quad->UVPt( i, 0 ).UV();
+ gp_UV p2 = quad->UVPt( i, nbvertic-1 ).UV();
+ for (int j = 1; j < nbvertic-1; j++)
+ {
+ gp_UV p1 = quad->UVPt( nbhoriz-1, j ).UV();
+ gp_UV p3 = quad->UVPt( 0, j ).UV();
+
+ int ij = j * nbhoriz + i;
+ double x = uv_grid[ij].x;
+ double y = uv_grid[ij].y;
+
+ gp_UV uv = calcUV(x,y, a0,a1,a2,a3, p0,p1,p2,p3);
+
+ uv_grid[ij].u = uv.X();
+ uv_grid[ij].v = uv.Y();
+ }
+ }
+ return true;
+}
+
+//=======================================================================
+//function : ShiftQuad
+//purpose : auxilary function for computeQuadPref
+//=======================================================================
+
+void StdMeshers_Quadrangle_2D::shiftQuad(FaceQuadStruct::Ptr& quad, const int num )
+{
+ quad->shift( num, /*ori=*/true, /*keepGrid=*/myQuadList.size() > 1 );
+}
+
+//================================================================================
+/*!
+ * \brief Rotate sides of a quad by given nb of quartes
+ * \param nb - number of rotation quartes
+ * \param ori - to keep orientation of sides as in an unit quad or not
+ * \param keepGrid - if \c true Side::grid is not changed, Side::from and Side::to
+ * are altered instead
+ */
+//================================================================================
+
+void FaceQuadStruct::shift( size_t nb, bool ori, bool keepGrid )
+{
+ if ( nb == 0 ) return;
+
+ vector< Side > newSides( side.size() );
+ vector< Side* > sidePtrs( side.size() );
+ for (int i = QUAD_BOTTOM_SIDE; i < NB_QUAD_SIDES; ++i)
+ {
+ int id = (i + nb) % NB_QUAD_SIDES;
+ if ( ori )
+ {
+ bool wasForward = (i < QUAD_TOP_SIDE);
+ bool newForward = (id < QUAD_TOP_SIDE);
+ if ( wasForward != newForward )
+ side[ i ].Reverse( keepGrid );
+ }
+ newSides[ id ] = side[ i ];
+ sidePtrs[ i ] = & side[ i ];
+ }
+ // make newSides refer newSides via Side::Contact's
+ for ( size_t i = 0; i < newSides.size(); ++i )
+ {
+ FaceQuadStruct::Side& ns = newSides[ i ];
+ for ( size_t iC = 0; iC < ns.contacts.size(); ++iC )
+ {
+ FaceQuadStruct::Side* oSide = ns.contacts[iC].other_side;
+ vector< Side* >::iterator sIt = std::find( sidePtrs.begin(), sidePtrs.end(), oSide );
+ if ( sIt != sidePtrs.end() )
+ ns.contacts[iC].other_side = & newSides[ *sIt - sidePtrs[0] ];
+ }
+ }
+ newSides.swap( side );
+
+ uv_grid.clear();
+}
+
+//=======================================================================
+//function : calcUV
+//purpose : auxilary function for computeQuadPref
+//=======================================================================
+
+static gp_UV calcUV(double x0, double x1, double y0, double y1,
+ FaceQuadStruct::Ptr& quad,
+ const gp_UV& a0, const gp_UV& a1,
+ const gp_UV& a2, const gp_UV& a3)
+{
+ double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
+ double y = y0 + x * (y1 - y0);
+
+ gp_UV p0 = quad->side[QUAD_BOTTOM_SIDE].grid->Value2d(x).XY();
+ gp_UV p1 = quad->side[QUAD_RIGHT_SIDE ].grid->Value2d(y).XY();
+ gp_UV p2 = quad->side[QUAD_TOP_SIDE ].grid->Value2d(x).XY();
+ gp_UV p3 = quad->side[QUAD_LEFT_SIDE ].grid->Value2d(y).XY();
+
+ gp_UV uv = calcUV(x,y, a0,a1,a2,a3, p0,p1,p2,p3);
+
+ return uv;
+}
+
+//=======================================================================
+//function : calcUV2
+//purpose : auxilary function for computeQuadPref
+//=======================================================================
+
+static gp_UV calcUV2(double x, double y,
+ FaceQuadStruct::Ptr& quad,
+ const gp_UV& a0, const gp_UV& a1,
+ const gp_UV& a2, const gp_UV& a3)
+{
+ gp_UV p0 = quad->side[QUAD_BOTTOM_SIDE].grid->Value2d(x).XY();
+ gp_UV p1 = quad->side[QUAD_RIGHT_SIDE ].grid->Value2d(y).XY();
+ gp_UV p2 = quad->side[QUAD_TOP_SIDE ].grid->Value2d(x).XY();
+ gp_UV p3 = quad->side[QUAD_LEFT_SIDE ].grid->Value2d(y).XY();
+
+ gp_UV uv = calcUV(x,y, a0,a1,a2,a3, p0,p1,p2,p3);
+
+ return uv;
+}
+
+
+//=======================================================================
+/*!
+ * Create only quandrangle faces
+ */
+//=======================================================================
+
+bool StdMeshers_Quadrangle_2D::computeQuadPref (SMESH_Mesh & aMesh,
+ const TopoDS_Face& aFace,
+ FaceQuadStruct::Ptr quad)
+{
+ const bool OldVersion = (myQuadType == QUAD_QUADRANGLE_PREF_REVERSED);
+ const bool WisF = true;
+
+ SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+ Handle(Geom_Surface) S = BRep_Tool::Surface(aFace);
+ int i,j, geomFaceID = meshDS->ShapeToIndex(aFace);
+
+ int nb = quad->side[0].NbPoints();
+ int nr = quad->side[1].NbPoints();
+ int nt = quad->side[2].NbPoints();
+ int nl = quad->side[3].NbPoints();
+ int dh = abs(nb-nt);
+ int dv = abs(nr-nl);
+
+ if ( myForcedPnts.empty() )
+ {
+ // rotate sides to be as in the picture below and to have
+ // dh >= dv and nt > nb
+ if ( dh >= dv )
+ shiftQuad( quad, ( nt > nb ) ? 0 : 2 );
+ else
+ shiftQuad( quad, ( nr > nl ) ? 1 : 3 );
+ }
+ else
+ {
+ // rotate the quad to have nt > nb [and nr > nl]
+ if ( nb > nt )
+ shiftQuad ( quad, nr > nl ? 1 : 2 );
+ else if ( nr > nl )
+ shiftQuad( quad, nb == nt ? 1 : 0 );
+ else if ( nl > nr )
+ shiftQuad( quad, 3 );
+ }
+
+ nb = quad->side[0].NbPoints();
+ nr = quad->side[1].NbPoints();
+ nt = quad->side[2].NbPoints();
+ nl = quad->side[3].NbPoints();
+ dh = abs(nb-nt);
+ dv = abs(nr-nl);
+ int nbh = Max(nb,nt);
+ int nbv = Max(nr,nl);
+ int addh = 0;
+ int addv = 0;
+
+ // Orientation of face and 3 main domain for future faces
+ // ----------- Old version ---------------
+ // 0 top 1
+ // 1------------1
+ // | | | |
+ // | |C | |
+ // | L | | R |
+ // left | |__| | rigth
+ // | / \ |
+ // | / C \ |
+ // |/ \|
+ // 0------------0
+ // 0 bottom 1
+
+ // ----------- New version ---------------
+ // 0 top 1
+ // 1------------1
+ // | |__| |
+ // | / \ |
+ // | / C \ |
+ // left |/________\| rigth
+ // | |
+ // | C |
+ // | |
+ // 0------------0
+ // 0 bottom 1
+
+
+ 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 vector<UVPtStruct>& uv_eb_vec = quad->side[0].GetUVPtStruct(true,0);
+ const vector<UVPtStruct>& uv_er_vec = quad->side[1].GetUVPtStruct(false,1);
+ const vector<UVPtStruct>& uv_et_vec = quad->side[2].GetUVPtStruct(true,1);
+ const vector<UVPtStruct>& uv_el_vec = quad->side[3].GetUVPtStruct(false,0);
+ if (uv_eb_vec.empty() ||
+ uv_er_vec.empty() ||
+ uv_et_vec.empty() ||
+ uv_el_vec.empty())
+ return error(COMPERR_BAD_INPUT_MESH);
+ }
+ FaceQuadStruct::SideIterator uv_eb, uv_er, uv_et, uv_el;
+ uv_eb.Init( quad->side[0] );
+ uv_er.Init( quad->side[1] );
+ uv_et.Init( quad->side[2] );
+ uv_el.Init( quad->side[3] );
+
+ gp_UV a0,a1,a2,a3, p0,p1,p2,p3, uv;
+ double x,y;
+
+ a0 = uv_eb[ 0 ].UV();
+ a1 = uv_er[ 0 ].UV();
+ a2 = uv_er[ nr-1 ].UV();
+ a3 = uv_et[ 0 ].UV();
+
+ if ( !myForcedPnts.empty() )
+ {
+ if ( dv != 0 && dh != 0 ) // here myQuadList.size() == 1
+ {
+ const int dmin = Min( dv, dh );
+
+ // Make a side separating domains L and Cb
+ StdMeshers_FaceSidePtr sideLCb;
+ UVPtStruct p3dom; // a point where 3 domains meat
+ { // dmin
+ vector<UVPtStruct> pointsLCb( dmin+1 ); // 1--------1
+ pointsLCb[0] = uv_eb[0]; // | | |
+ for ( int i = 1; i <= dmin; ++i ) // | |Ct|
+ { // | L | |
+ x = uv_et[ i ].normParam; // | |__|
+ y = uv_er[ i ].normParam; // | / |
+ p0 = quad->side[0].grid->Value2d( x ).XY(); // | / Cb |dmin
+ p1 = uv_er[ i ].UV(); // |/ |
+ p2 = uv_et[ i ].UV(); // 0--------0
+ p3 = quad->side[3].grid->Value2d( y ).XY();
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsLCb[ i ].u = uv.X();
+ pointsLCb[ i ].v = uv.Y();
+ }
+ sideLCb = StdMeshers_FaceSide::New( pointsLCb, aFace );
+ p3dom = pointsLCb.back();
+ }
+ // Make a side separating domains L and Ct
+ StdMeshers_FaceSidePtr sideLCt;
+ {
+ vector<UVPtStruct> pointsLCt( nl );
+ pointsLCt[0] = p3dom;
+ pointsLCt.back() = uv_et[ dmin ];
+ x = uv_et[ dmin ].normParam;
+ p0 = quad->side[0].grid->Value2d( x ).XY();
+ p2 = uv_et[ dmin ].UV();
+ double y0 = uv_er[ dmin ].normParam;
+ for ( int i = 1; i < nl-1; ++i )
+ {
+ y = y0 + i / ( nl-1. ) * ( 1. - y0 );
+ p1 = quad->side[1].grid->Value2d( y ).XY();
+ p3 = quad->side[3].grid->Value2d( y ).XY();
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsLCt[ i ].u = uv.X();
+ pointsLCt[ i ].v = uv.Y();
+ }
+ sideLCt = StdMeshers_FaceSide::New( pointsLCt, aFace );
+ }
+ // Make a side separating domains Cb and Ct
+ StdMeshers_FaceSidePtr sideCbCt;
+ {
+ vector<UVPtStruct> pointsCbCt( nb );
+ pointsCbCt[0] = p3dom;
+ pointsCbCt.back() = uv_er[ dmin ];
+ y = uv_er[ dmin ].normParam;
+ p1 = uv_er[ dmin ].UV();
+ p3 = quad->side[3].grid->Value2d( y ).XY();
+ double x0 = uv_et[ dmin ].normParam;
+ for ( int i = 1; i < nb-1; ++i )
+ {
+ x = x0 + i / ( nb-1. ) * ( 1. - x0 );
+ p2 = quad->side[2].grid->Value2d( x ).XY();
+ p0 = quad->side[0].grid->Value2d( x ).XY();
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsCbCt[ i ].u = uv.X();
+ pointsCbCt[ i ].v = uv.Y();
+ }
+ sideCbCt = StdMeshers_FaceSide::New( pointsCbCt, aFace );
+ }
+ // Make Cb quad
+ FaceQuadStruct* qCb = new FaceQuadStruct( quad->face, "Cb" );
+ myQuadList.push_back( FaceQuadStruct::Ptr( qCb ));
+ qCb->side.resize(4);
+ qCb->side[0] = quad->side[0];
+ qCb->side[1] = quad->side[1];
+ qCb->side[2] = sideCbCt;
+ qCb->side[3] = sideLCb;
+ qCb->side[1].to = dmin+1;
+ // Make L quad
+ FaceQuadStruct* qL = new FaceQuadStruct( quad->face, "L" );
+ myQuadList.push_back( FaceQuadStruct::Ptr( qL ));
+ qL->side.resize(4);
+ qL->side[0] = sideLCb;
+ qL->side[1] = sideLCt;
+ qL->side[2] = quad->side[2];
+ qL->side[3] = quad->side[3];
+ qL->side[2].to = dmin+1;
+ // Make Ct from the main quad
+ FaceQuadStruct::Ptr qCt = quad;
+ qCt->side[0] = sideCbCt;
+ qCt->side[3] = sideLCt;
+ qCt->side[1].from = dmin;
+ qCt->side[2].from = dmin;
+ qCt->uv_grid.clear();
+ qCt->name = "Ct";
+
+ // Connect sides
+ qCb->side[3].AddContact( dmin, & qCb->side[2], 0 );
+ qCb->side[3].AddContact( dmin, & qCt->side[3], 0 );
+ qCt->side[3].AddContact( 0, & qCt->side[0], 0 );
+ qCt->side[0].AddContact( 0, & qL ->side[0], dmin );
+ qL ->side[0].AddContact( dmin, & qL ->side[1], 0 );
+ qL ->side[0].AddContact( dmin, & qCb->side[2], 0 );
+
+ if ( dh == dv )
+ return computeQuadDominant( aMesh, aFace );
+ else
+ return computeQuadPref( aMesh, aFace, qCt );
+
+ } // 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 dt = quad->side[2].IsReversed() ? -1 : +1;
+ const int dl = quad->side[3].IsReversed() ? -1 : +1;
+
+ // Case dv == 0, here possibly myQuadList.size() > 1
+ //
+ // lw nb lw = dh/2
+ // +------------+
+ // | | | |
+ // | | Ct | |
+ // | L | | R |
+ // | |____| |
+ // | / \ |
+ // | / Cb \ |
+ // |/ \|
+ // +------------+
+ const int lw = dh/2; // lateral width
+
+ double yCbL, yCbR;
+ {
+ double lL = quad->side[3].Length();
+ double lLwL = quad->side[2].Length( tfrom,
+ tfrom + ( lw ) * dt );
+ yCbL = lLwL / ( lLwL + lL );
+
+ double lR = quad->side[1].Length();
+ double lLwR = quad->side[2].Length( tfrom + ( lw + nb-1 ) * dt,
+ tfrom + ( lw + nb-1 + lw ) * dt);
+ yCbR = lLwR / ( lLwR + lR );
+ }
+ // Make sides separating domains Cb and L and R
+ StdMeshers_FaceSidePtr sideLCb, sideRCb;
+ UVPtStruct pTBL, pTBR; // points where 3 domains meat
+ {
+ vector<UVPtStruct> pointsLCb( lw+1 ), pointsRCb( lw+1 );
+ pointsLCb[0] = uv_eb[ 0 ];
+ pointsRCb[0] = uv_eb[ nb-1 ];
+ for ( int i = 1, i2 = nt-2; i <= lw; ++i, --i2 )
+ {
+ x = quad->side[2].Param( i );
+ y = yCbL * i / lw;
+ p0 = quad->side[0].Value2d( x );
+ p1 = quad->side[1].Value2d( y );
+ p2 = uv_et[ i ].UV();
+ p3 = quad->side[3].Value2d( y );
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsLCb[ i ].u = uv.X();
+ pointsLCb[ i ].v = uv.Y();
+ pointsLCb[ i ].x = x;
+
+ x = quad->side[2].Param( i2 );
+ y = yCbR * i / lw;
+ p1 = quad->side[1].Value2d( y );
+ p0 = quad->side[0].Value2d( x );
+ p2 = uv_et[ i2 ].UV();
+ p3 = quad->side[3].Value2d( y );
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsRCb[ i ].u = uv.X();
+ pointsRCb[ i ].v = uv.Y();
+ pointsRCb[ i ].x = x;
+ }
+ sideLCb = StdMeshers_FaceSide::New( pointsLCb, aFace );
+ sideRCb = StdMeshers_FaceSide::New( pointsRCb, aFace );
+ pTBL = pointsLCb.back();
+ pTBR = pointsRCb.back();
+ }
+ // Make sides separating domains Ct and L and R
+ StdMeshers_FaceSidePtr sideLCt, sideRCt;
+ {
+ vector<UVPtStruct> pointsLCt( nl ), pointsRCt( nl );
+ pointsLCt[0] = pTBL;
+ pointsLCt.back() = uv_et[ lw ];
+ pointsRCt[0] = pTBR;
+ pointsRCt.back() = uv_et[ lw + nb - 1 ];
+ x = pTBL.x;
+ p0 = quad->side[0].Value2d( x );
+ p2 = uv_et[ lw ].UV();
+ int iR = lw + nb - 1;
+ double xR = pTBR.x;
+ gp_UV p0R = quad->side[0].Value2d( xR );
+ gp_UV p2R = uv_et[ iR ].UV();
+ for ( int i = 1; i < nl-1; ++i )
+ {
+ y = yCbL + ( 1. - yCbL ) * i / (nl-1.);
+ p1 = quad->side[1].Value2d( y );
+ p3 = quad->side[3].Value2d( y );
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsLCt[ i ].u = uv.X();
+ pointsLCt[ i ].v = uv.Y();
+
+ y = yCbR + ( 1. - yCbR ) * i / (nl-1.);
+ p1 = quad->side[1].Value2d( y );
+ p3 = quad->side[3].Value2d( y );
+ uv = calcUV( xR,y, a0,a1,a2,a3, p0R,p1,p2R,p3 );
+ pointsRCt[ i ].u = uv.X();
+ pointsRCt[ i ].v = uv.Y();
+ }
+ sideLCt = StdMeshers_FaceSide::New( pointsLCt, aFace );
+ sideRCt = StdMeshers_FaceSide::New( pointsRCt, aFace );
+ }
+ // Make a side separating domains Cb and Ct
+ StdMeshers_FaceSidePtr sideCbCt;
+ {
+ vector<UVPtStruct> pointsCbCt( nb );
+ pointsCbCt[0] = pTBL;
+ pointsCbCt.back() = pTBR;
+ p1 = quad->side[1].Value2d( yCbR );
+ p3 = quad->side[3].Value2d( yCbL );
+ for ( int i = 1; i < nb-1; ++i )
+ {
+ x = quad->side[2].Param( i + lw );
+ y = yCbL + ( yCbR - yCbL ) * i / (nb-1.);
+ p2 = uv_et[ i + lw ].UV();
+ p0 = quad->side[0].Value2d( x );
+ uv = calcUV( x,y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ pointsCbCt[ i ].u = uv.X();
+ pointsCbCt[ i ].v = uv.Y();
+ }
+ sideCbCt = StdMeshers_FaceSide::New( pointsCbCt, aFace );
+ }
+ // Make Cb quad
+ FaceQuadStruct* qCb = new FaceQuadStruct( quad->face, "Cb" );
+ myQuadList.push_back( FaceQuadStruct::Ptr( qCb ));
+ qCb->side.resize(4);
+ qCb->side[0] = quad->side[0];
+ qCb->side[1] = sideRCb;
+ qCb->side[2] = sideCbCt;
+ qCb->side[3] = sideLCb;
+ // Make L quad
+ FaceQuadStruct* qL = new FaceQuadStruct( quad->face, "L" );
+ myQuadList.push_back( FaceQuadStruct::Ptr( qL ));
+ qL->side.resize(4);
+ qL->side[0] = sideLCb;
+ qL->side[1] = sideLCt;
+ qL->side[2] = quad->side[2];
+ qL->side[3] = quad->side[3];
+ qL->side[2].to = ( lw + 1 ) * dt + tfrom;
+ // Make R quad
+ FaceQuadStruct* qR = new FaceQuadStruct( quad->face, "R" );
+ myQuadList.push_back( FaceQuadStruct::Ptr( qR ));
+ qR->side.resize(4);
+ qR->side[0] = sideRCb;
+ qR->side[0].from = lw;
+ qR->side[0].to = -1;
+ qR->side[0].di = -1;
+ qR->side[1] = quad->side[1];
+ qR->side[2] = quad->side[2];
+ qR->side[2].from = ( lw + nb-1 ) * dt + tfrom;
+ qR->side[3] = sideRCt;
+ // Make Ct from the main quad
+ FaceQuadStruct::Ptr qCt = quad;
+ qCt->side[0] = sideCbCt;
+ qCt->side[1] = sideRCt;
+ qCt->side[2].from = ( lw ) * dt + tfrom;
+ qCt->side[2].to = ( lw + nb ) * dt + tfrom;
+ qCt->side[3] = sideLCt;
+ qCt->uv_grid.clear();
+ qCt->name = "Ct";
+
+ // Connect sides
+ qCb->side[3].AddContact( lw, & qCb->side[2], 0 );
+ qCb->side[3].AddContact( lw, & qCt->side[3], 0 );
+ qCt->side[3].AddContact( 0, & qCt->side[0], 0 );
+ qCt->side[0].AddContact( 0, & qL ->side[0], lw );
+ qL ->side[0].AddContact( lw, & qL ->side[1], 0 );
+ qL ->side[0].AddContact( lw, & qCb->side[2], 0 );
+ //
+ qCb->side[1].AddContact( lw, & qCb->side[2], nb-1 );
+ qCb->side[1].AddContact( lw, & qCt->side[1], 0 );
+ qCt->side[0].AddContact( nb-1, & qCt->side[1], 0 );
+ qCt->side[0].AddContact( nb-1, & qR ->side[0], lw );
+ qR ->side[3].AddContact( 0, & qR ->side[0], lw );
+ qR ->side[3].AddContact( 0, & qCb->side[2], nb-1 );
+
+ return computeQuadDominant( aMesh, aFace );
+
+ } // if ( !myForcedPnts.empty() )
+
+ if ( dh > dv ) {
+ addv = (dh-dv)/2;
+ nbv = nbv + addv;
+ }
+ else { // dv >= dh
+ addh = (dv-dh)/2;
+ nbh = nbh + addh;
+ }
+
+ // arrays for normalized params
+ TColStd_SequenceOfReal npb, npr, npt, npl;
+ for (i=0; i<nb; i++) {
+ npb.Append(uv_eb[i].normParam);
+ }
+ for (i=0; i<nr; i++) {
+ npr.Append(uv_er[i].normParam);
+ }
+ for (i=0; i<nt; i++) {
+ npt.Append(uv_et[i].normParam);
+ }
+ for (i=0; i<nl; i++) {
+ npl.Append(uv_el[i].normParam);
+ }
+
+ int dl,dr;
+ if (OldVersion) {
+ // add some params to right and left after the first param
+ // insert to right
+ dr = nbv - nr;
+ double dpr = (npr.Value(2) - npr.Value(1))/(dr+1);
+ for (i=1; i<=dr; i++) {
+ npr.InsertAfter(1,npr.Value(2)-dpr);
+ }
+ // insert to left
+ dl = nbv - nl;
+ dpr = (npl.Value(2) - npl.Value(1))/(dl+1);
+ for (i=1; i<=dl; i++) {
+ npl.InsertAfter(1,npl.Value(2)-dpr);
+ }
+ }
+
+ int nnn = Min(nr,nl);
+ // auxilary 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;
+
+ if (OldVersion) {
+ // step1: create faces for left domain
+ StdMeshers_Array2OfNode NodesL(1,dl+1,1,nl);
+ // add left nodes
+ for (j=1; j<=nl; j++)
+ NodesL.SetValue(1,j,uv_el[j-1].node);
+ if (dl>0) {
+ // add top nodes
+ for (i=1; i<=dl; i++)
+ NodesL.SetValue(i+1,nl,uv_et[i].node);
+ // create and add needed nodes
+ TColgp_SequenceOfXY UVtmp;
+ for (i=1; i<=dl; i++) {
+ double x0 = npt.Value(i+1);
+ double x1 = x0;
+ // diagonal node
+ double y0 = npl.Value(i+1);
+ double y1 = npr.Value(i+1);
+ gp_UV UV = calcUV(x0, x1, y0, y1, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode * N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesL.SetValue(i+1,1,N);
+ if (UVL.Length()<nbv-nnn) UVL.Append(UV);
+ // internal nodes
+ for (j=2; j<nl; j++) {
+ double y0 = npl.Value(dl+j);
+ double y1 = npr.Value(dl+j);
+ gp_UV UV = calcUV(x0, x1, y0, y1, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesL.SetValue(i+1,j,N);
+ if (i==dl) UVtmp.Append(UV);
+ }
+ }
+ for (i=1; i<=UVtmp.Length() && UVL.Length()<nbv-nnn; i++) {
+ UVL.Append(UVtmp.Value(i));
+ }
+ // create faces
+ for (i=1; i<=dl; i++) {
+ for (j=1; j<nl; j++) {
+ if (WisF) {
+ SMDS_MeshFace* F =
+ myHelper->AddFace(NodesL.Value(i,j), NodesL.Value(i+1,j),
+ NodesL.Value(i+1,j+1), NodesL.Value(i,j+1));
+ if (F) meshDS->SetMeshElementOnShape(F, geomFaceID);
+ }
+ }
+ }
+ }
+ else {
+ // fill UVL using c2d
+ for (i=1; i<npl.Length() && UVL.Length()<nbv-nnn; i++) {
+ UVL.Append(gp_UV (uv_el[i].u, uv_el[i].v));
+ }
+ }
+
+ // step2: create faces for right domain
+ StdMeshers_Array2OfNode NodesR(1,dr+1,1,nr);
+ // add right nodes
+ for (j=1; j<=nr; j++)
+ NodesR.SetValue(1,j,uv_er[nr-j].node);
+ if (dr>0) {
+ // add top nodes
+ for (i=1; i<=dr; i++)
+ NodesR.SetValue(i+1,1,uv_et[nt-1-i].node);
+ // create and add needed nodes
+ TColgp_SequenceOfXY UVtmp;
+ for (i=1; i<=dr; i++) {
+ double x0 = npt.Value(nt-i);
+ double x1 = x0;
+ // diagonal node
+ double y0 = npl.Value(i+1);
+ double y1 = npr.Value(i+1);
+ gp_UV UV = calcUV(x0, x1, y0, y1, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode * N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesR.SetValue(i+1,nr,N);
+ if (UVR.Length()<nbv-nnn) UVR.Append(UV);
+ // internal nodes
+ for (j=2; j<nr; j++) {
+ double y0 = npl.Value(nbv-j+1);
+ double y1 = npr.Value(nbv-j+1);
+ gp_UV UV = calcUV(x0, x1, y0, y1, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesR.SetValue(i+1,j,N);
+ if (i==dr) UVtmp.Prepend(UV);
+ }
+ }
+ for (i=1; i<=UVtmp.Length() && UVR.Length()<nbv-nnn; i++) {
+ UVR.Append(UVtmp.Value(i));
+ }
+ // create faces
+ for (i=1; i<=dr; i++) {
+ for (j=1; j<nr; j++) {
+ if (WisF) {
+ SMDS_MeshFace* F =
+ myHelper->AddFace(NodesR.Value(i,j), NodesR.Value(i+1,j),
+ NodesR.Value(i+1,j+1), NodesR.Value(i,j+1));
+ if (F) meshDS->SetMeshElementOnShape(F, geomFaceID);
+ }
+ }
+ }
+ }
+ else {
+ // fill UVR using c2d
+ for (i=1; i<npr.Length() && UVR.Length()<nbv-nnn; i++) {
+ UVR.Append(gp_UV(uv_er[i].u, uv_er[i].v));
+ }
+ }
+
+ // step3: create faces for central domain
+ StdMeshers_Array2OfNode NodesC(1,nb,1,nbv);
+ // add first line using NodesL
+ for (i=1; i<=dl+1; i++)
+ NodesC.SetValue(1,i,NodesL(i,1));
+ for (i=2; i<=nl; i++)
+ NodesC.SetValue(1,dl+i,NodesL(dl+1,i));
+ // add last line using NodesR
+ for (i=1; i<=dr+1; i++)
+ NodesC.SetValue(nb,i,NodesR(i,nr));
+ for (i=1; i<nr; i++)
+ NodesC.SetValue(nb,dr+i+1,NodesR(dr+1,nr-i));
+ // add top nodes (last columns)
+ for (i=dl+2; i<nbh-dr; i++)
+ NodesC.SetValue(i-dl,nbv,uv_et[i-1].node);
+ // add bottom nodes (first columns)
+ for (i=2; i<nb; i++)
+ NodesC.SetValue(i,1,uv_eb[i-1].node);
+
+ // create and add needed nodes
+ // add linear layers
+ for (i=2; i<nb; i++) {
+ double x0 = npt.Value(dl+i);
+ double x1 = x0;
+ for (j=1; j<nnn; j++) {
+ double y0 = npl.Value(nbv-nnn+j);
+ double y1 = npr.Value(nbv-nnn+j);
+ gp_UV UV = calcUV(x0, x1, y0, y1, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesC.SetValue(i,nbv-nnn+j,N);
+ if ( j==1 )
+ UVT.Append( UV );
+ }
+ }
+ // add diagonal layers
+ gp_UV A2 = UVR.Value(nbv-nnn);
+ gp_UV A3 = UVL.Value(nbv-nnn);
+ for (i=1; i<nbv-nnn; i++) {
+ gp_UV p1 = UVR.Value(i);
+ gp_UV p3 = UVL.Value(i);
+ double y = i / double(nbv-nnn);
+ for (j=2; j<nb; j++) {
+ double x = npb.Value(j);
+ gp_UV p0( uv_eb[j-1].u, uv_eb[j-1].v );
+ gp_UV p2 = UVT.Value( j-1 );
+ gp_UV UV = calcUV(x, y, a0, a1, A2, A3, p0,p1,p2,p3 );
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(),UV.Y());
+ NodesC.SetValue(j,i+1,N);
+ }
+ }
+ // create faces
+ for (i=1; i<nb; i++) {
+ for (j=1; j<nbv; j++) {
+ if (WisF) {
+ SMDS_MeshFace* F =
+ myHelper->AddFace(NodesC.Value(i,j), NodesC.Value(i+1,j),
+ NodesC.Value(i+1,j+1), NodesC.Value(i,j+1));
+ if (F) meshDS->SetMeshElementOnShape(F, geomFaceID);
+ }
+ }
+ }
+ }
+
+ else { // New version (!OldVersion)
+ // step1: create faces for bottom rectangle domain
+ StdMeshers_Array2OfNode NodesBRD(1,nb,1,nnn-1);
+ // fill UVL and UVR using c2d
+ for (j=0; j<nb; j++) {
+ NodesBRD.SetValue(j+1,1,uv_eb[j].node);
+ }
+ for (i=1; i<nnn-1; i++) {
+ NodesBRD.SetValue(1,i+1,uv_el[i].node);
+ NodesBRD.SetValue(nb,i+1,uv_er[i].node);
+ for (j=2; j<nb; j++) {
+ double x = npb.Value(j);
+ double y = (1-x) * npl.Value(i+1) + x * npr.Value(i+1);
+ gp_UV UV = calcUV2(x, y, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(),UV.Y());
+ NodesBRD.SetValue(j,i+1,N);
+ }
+ }
+ for (j=1; j<nnn-1; j++) {
+ for (i=1; i<nb; i++) {
+ if (WisF) {
+ SMDS_MeshFace* F =
+ myHelper->AddFace(NodesBRD.Value(i,j), NodesBRD.Value(i+1,j),
+ NodesBRD.Value(i+1,j+1), NodesBRD.Value(i,j+1));
+ if (F) meshDS->SetMeshElementOnShape(F, geomFaceID);
+ }
+ }
+ }
+ int drl = abs(nr-nl);
+ // create faces for region C
+ StdMeshers_Array2OfNode NodesC(1,nb,1,drl+1+addv);
+ // add nodes from previous region
+ for (j=1; j<=nb; j++) {
+ NodesC.SetValue(j,1,NodesBRD.Value(j,nnn-1));
+ }
+ if ((drl+addv) > 0) {
+ int n1,n2;
+ if (nr>nl) {
+ n1 = 1;
+ n2 = drl + 1;
+ TColgp_SequenceOfXY UVtmp;
+ double drparam = npr.Value(nr) - npr.Value(nnn-1);
+ double dlparam = npl.Value(nnn) - npl.Value(nnn-1);
+ double y0,y1;
+ for (i=1; i<=drl; i++) {
+ // add existed nodes from right edge
+ NodesC.SetValue(nb,i+1,uv_er[nnn+i-2].node);
+ //double dtparam = npt.Value(i+1);
+ y1 = npr.Value(nnn+i-1); // param on right edge
+ double dpar = (y1 - npr.Value(nnn-1))/drparam;
+ y0 = npl.Value(nnn-1) + dpar*dlparam; // param on left edge
+ double dy = y1 - y0;
+ for (j=1; j<nb; j++) {
+ double x = npt.Value(i+1) + npb.Value(j)*(1-npt.Value(i+1));
+ double y = y0 + dy*x;
+ gp_UV UV = calcUV2(x, y, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesC.SetValue(j,i+1,N);
+ }
+ }
+ double dy0 = (1-y0)/(addv+1);
+ double dy1 = (1-y1)/(addv+1);
+ for (i=1; i<=addv; i++) {
+ double yy0 = y0 + dy0*i;
+ double yy1 = y1 + dy1*i;
+ double dyy = yy1 - yy0;
+ for (j=1; j<=nb; j++) {
+ double x = npt.Value(i+1+drl) +
+ npb.Value(j) * (npt.Value(nt-i) - npt.Value(i+1+drl));
+ double y = yy0 + dyy*x;
+ gp_UV UV = calcUV2(x, y, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesC.SetValue(j,i+drl+1,N);
+ }
+ }
+ }
+ else { // nr<nl
+ n2 = 1;
+ n1 = drl + 1;
+ TColgp_SequenceOfXY UVtmp;
+ double dlparam = npl.Value(nl) - npl.Value(nnn-1);
+ double drparam = npr.Value(nnn) - npr.Value(nnn-1);
+ double y0 = npl.Value(nnn-1);
+ double y1 = npr.Value(nnn-1);
+ for (i=1; i<=drl; i++) {
+ // add existed nodes from right edge
+ NodesC.SetValue(1,i+1,uv_el[nnn+i-2].node);
+ y0 = npl.Value(nnn+i-1); // param on left edge
+ double dpar = (y0 - npl.Value(nnn-1))/dlparam;
+ y1 = npr.Value(nnn-1) + dpar*drparam; // param on right edge
+ double dy = y1 - y0;
+ for (j=2; j<=nb; j++) {
+ double x = npb.Value(j)*npt.Value(nt-i);
+ double y = y0 + dy*x;
+ gp_UV UV = calcUV2(x, y, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesC.SetValue(j,i+1,N);
+ }
+ }
+ double dy0 = (1-y0)/(addv+1);
+ double dy1 = (1-y1)/(addv+1);
+ for (i=1; i<=addv; i++) {
+ double yy0 = y0 + dy0*i;
+ double yy1 = y1 + dy1*i;
+ double dyy = yy1 - yy0;
+ for (j=1; j<=nb; j++) {
+ double x = npt.Value(i+1) +
+ npb.Value(j) * (npt.Value(nt-i-drl) - npt.Value(i+1));
+ double y = yy0 + dyy*x;
+ gp_UV UV = calcUV2(x, y, quad, a0, a1, a2, a3);
+ gp_Pnt P = S->Value(UV.X(),UV.Y());
+ SMDS_MeshNode* N = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(N, geomFaceID, UV.X(), UV.Y());
+ NodesC.SetValue(j,i+drl+1,N);
+ }
+ }
+ }
+ // create faces
+ for (j=1; j<=drl+addv; j++) {
+ for (i=1; i<nb; i++) {
+ if (WisF) {
+ SMDS_MeshFace* F =
+ myHelper->AddFace(NodesC.Value(i,j), NodesC.Value(i+1,j),
+ NodesC.Value(i+1,j+1), NodesC.Value(i,j+1));
+ if (F) meshDS->SetMeshElementOnShape(F, geomFaceID);
+ }
+ }
+ } // end nr<nl
+
+ StdMeshers_Array2OfNode NodesLast(1,nt,1,2);
+ for (i=1; i<=nt; i++) {
+ NodesLast.SetValue(i,2,uv_et[i-1].node);
+ }
+ int nnn=0;
+ for (i=n1; i<drl+addv+1; i++) {
+ nnn++;
+ NodesLast.SetValue(nnn,1,NodesC.Value(1,i));
+ }
+ for (i=1; i<=nb; i++) {
+ nnn++;
+ NodesLast.SetValue(nnn,1,NodesC.Value(i,drl+addv+1));
+ }
+ for (i=drl+addv; i>=n2; i--) {
+ nnn++;
+ NodesLast.SetValue(nnn,1,NodesC.Value(nb,i));
+ }
+ for (i=1; i<nt; i++) {
+ if (WisF) {
+ SMDS_MeshFace* F =
+ myHelper->AddFace(NodesLast.Value(i,1), NodesLast.Value(i+1,1),
+ NodesLast.Value(i+1,2), NodesLast.Value(i,2));
+ if (F) meshDS->SetMeshElementOnShape(F, geomFaceID);
+ }
+ }
+ } // if ((drl+addv) > 0)
+
+ } // end new version implementation
+
+ bool isOk = true;
+ return isOk;
+}
+
+
+//=======================================================================
+/*!
+ * Evaluate only quandrangle faces
+ */
+//=======================================================================
+
+bool StdMeshers_Quadrangle_2D::evaluateQuadPref(SMESH_Mesh & aMesh,
+ const TopoDS_Shape& aShape,
+ std::vector<int>& aNbNodes,
+ MapShapeNbElems& aResMap,
+ bool IsQuadratic)
+{
+ // Auxilary key in order to keep old variant
+ // of meshing after implementation new variant
+ // for bug 0016220 from Mantis.
+ bool OldVersion = false;
+ if (myQuadType == QUAD_QUADRANGLE_PREF_REVERSED)
+ OldVersion = true;
+
+ const TopoDS_Face& F = TopoDS::Face(aShape);
+ Handle(Geom_Surface) S = BRep_Tool::Surface(F);
+
+ int nb = aNbNodes[0];
+ int nr = aNbNodes[1];
+ int nt = aNbNodes[2];
+ int nl = aNbNodes[3];
+ int dh = abs(nb-nt);
+ int dv = abs(nr-nl);
+
+ if (dh>=dv) {
+ if (nt>nb) {
+ // it is a base case => not shift
+ }
+ else {
+ // we have to shift on 2
+ nb = aNbNodes[2];
+ nr = aNbNodes[3];
+ nt = aNbNodes[0];
+ nl = aNbNodes[1];
+ }
+ }
+ else {
+ if (nr>nl) {
+ // we have to shift quad on 1
+ nb = aNbNodes[3];
+ nr = aNbNodes[0];
+ nt = aNbNodes[1];
+ nl = aNbNodes[2];
+ }
+ else {
+ // we have to shift quad on 3
+ nb = aNbNodes[1];
+ nr = aNbNodes[2];
+ nt = aNbNodes[3];
+ nl = aNbNodes[0];
+ }
+ }
+
+ dh = abs(nb-nt);
+ dv = abs(nr-nl);
+ int nbh = Max(nb,nt);
+ int nbv = Max(nr,nl);
+ int addh = 0;
+ int addv = 0;
+
+ if (dh>dv) {
+ addv = (dh-dv)/2;
+ nbv = nbv + addv;
+ }
+ else { // dv>=dh
+ addh = (dv-dh)/2;
+ nbh = nbh + addh;
+ }
+
+ int dl,dr;
+ if (OldVersion) {
+ // add some params to right and left after the first param
+ // insert to right
+ dr = nbv - nr;
+ // insert to left
+ dl = nbv - nl;
+ }
+
+ int nnn = Min(nr,nl);
+
+ int nbNodes = 0;
+ int nbFaces = 0;
+ if (OldVersion) {
+ // step1: create faces for left domain
+ if (dl>0) {
+ nbNodes += dl*(nl-1);
+ nbFaces += dl*(nl-1);
+ }
+ // step2: create faces for right domain
+ if (dr>0) {
+ nbNodes += dr*(nr-1);
+ nbFaces += dr*(nr-1);
+ }
+ // step3: create faces for central domain
+ nbNodes += (nb-2)*(nnn-1) + (nbv-nnn-1)*(nb-2);
+ nbFaces += (nb-1)*(nbv-1);
+ }
+ else { // New version (!OldVersion)
+ nbNodes += (nnn-2)*(nb-2);
+ nbFaces += (nnn-2)*(nb-1);
+ int drl = abs(nr-nl);
+ nbNodes += drl*(nb-1) + addv*nb;
+ nbFaces += (drl+addv)*(nb-1) + (nt-1);
+ } // end new version implementation
+
+ std::vector<int> aVec(SMDSEntity_Last);
+ for (int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aVec[i] = 0;
+ if (IsQuadratic) {
+ aVec[SMDSEntity_Quad_Quadrangle] = nbFaces;
+ aVec[SMDSEntity_Node] = nbNodes + nbFaces*4;
+ if (aNbNodes.size()==5) {
+ aVec[SMDSEntity_Quad_Triangle] = aNbNodes[3] - 1;
+ aVec[SMDSEntity_Quad_Quadrangle] = nbFaces - aNbNodes[3] + 1;
+ }
+ }
+ else {
+ aVec[SMDSEntity_Node] = nbNodes;
+ aVec[SMDSEntity_Quadrangle] = nbFaces;
+ if (aNbNodes.size()==5) {
+ aVec[SMDSEntity_Triangle] = aNbNodes[3] - 1;
+ aVec[SMDSEntity_Quadrangle] = nbFaces - aNbNodes[3] + 1;
+ }
+ }
+ SMESH_subMesh * sm = aMesh.GetSubMesh(aShape);
+ aResMap.insert(std::make_pair(sm,aVec));
+
+ return true;
+}
+
+//=============================================================================
+/*! Split quadrangle in to 2 triangles by smallest diagonal
+ *
+ */
+//=============================================================================
+
+void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * theMeshDS,
+ int theFaceID,
+ const SMDS_MeshNode* theNode1,
+ const SMDS_MeshNode* theNode2,
+ const SMDS_MeshNode* theNode3,
+ const SMDS_MeshNode* theNode4)
+{
+ SMDS_MeshFace* face;
+ if ( SMESH_TNodeXYZ( theNode1 ).SquareDistance( theNode3 ) >
+ SMESH_TNodeXYZ( theNode2 ).SquareDistance( theNode4 ) )
+ {
+ face = myHelper->AddFace(theNode2, theNode4 , theNode1);
+ if (face) theMeshDS->SetMeshElementOnShape(face, theFaceID);
+ face = myHelper->AddFace(theNode2, theNode3, theNode4);
+ if (face) theMeshDS->SetMeshElementOnShape(face, theFaceID);
+ }
+ else
+ {
+ face = myHelper->AddFace(theNode1, theNode2 ,theNode3);
+ if (face) theMeshDS->SetMeshElementOnShape(face, theFaceID);
+ face = myHelper->AddFace(theNode1, theNode3, theNode4);
+ if (face) theMeshDS->SetMeshElementOnShape(face, theFaceID);
+ }
+}
+
+namespace
+{
+ enum uvPos { UV_A0, UV_A1, UV_A2, UV_A3, UV_B, UV_R, UV_T, UV_L, UV_SIZE };
+
+ inline SMDS_MeshNode* makeNode( UVPtStruct & uvPt,
+ const double y,
+ FaceQuadStruct::Ptr& quad,
+ const gp_UV* UVs,
+ SMESH_MesherHelper* helper,
+ Handle(Geom_Surface) S)
+ {
+ const vector<UVPtStruct>& uv_eb = quad->side[QUAD_BOTTOM_SIDE].GetUVPtStruct();
+ const vector<UVPtStruct>& uv_et = quad->side[QUAD_TOP_SIDE ].GetUVPtStruct();
+ double rBot = ( uv_eb.size() - 1 ) * uvPt.normParam;
+ double rTop = ( uv_et.size() - 1 ) * uvPt.normParam;
+ int iBot = int( rBot );
+ int iTop = int( rTop );
+ double xBot = uv_eb[ iBot ].normParam + ( rBot - iBot ) * ( uv_eb[ iBot+1 ].normParam - uv_eb[ iBot ].normParam );
+ double xTop = uv_et[ iTop ].normParam + ( rTop - iTop ) * ( uv_et[ iTop+1 ].normParam - uv_et[ iTop ].normParam );
+ double x = xBot + y * ( xTop - xBot );
+
+ gp_UV uv = calcUV(/*x,y=*/x, y,
+ /*a0,...=*/UVs[UV_A0], UVs[UV_A1], UVs[UV_A2], UVs[UV_A3],
+ /*p0=*/quad->side[QUAD_BOTTOM_SIDE].grid->Value2d( x ).XY(),
+ /*p1=*/UVs[ UV_R ],
+ /*p2=*/quad->side[QUAD_TOP_SIDE ].grid->Value2d( x ).XY(),
+ /*p3=*/UVs[ UV_L ]);
+ gp_Pnt P = S->Value( uv.X(), uv.Y() );
+ uvPt.u = uv.X();
+ uvPt.v = uv.Y();
+ return helper->AddNode(P.X(), P.Y(), P.Z(), 0, uv.X(), uv.Y() );
+ }
+
+ void reduce42( const vector<UVPtStruct>& curr_base,
+ vector<UVPtStruct>& next_base,
+ const int j,
+ int & next_base_len,
+ FaceQuadStruct::Ptr& quad,
+ gp_UV* UVs,
+ const double y,
+ SMESH_MesherHelper* helper,
+ Handle(Geom_Surface)& S)
+ {
+ // add one "HH": nodes a,b,c,d,e and faces 1,2,3,4,5,6
+ //
+ // .-----a-----b i + 1
+ // |\ 5 | 6 /|
+ // | \ | / |
+ // | c--d--e |
+ // |1 |2 |3 |4 |
+ // | | | | |
+ // .--.--.--.--. i
+ //
+ // j j+2 j+4
+
+ // a (i + 1, j + 2)
+ const SMDS_MeshNode*& Na = next_base[ ++next_base_len ].node;
+ if ( !Na )
+ Na = makeNode( next_base[ next_base_len ], y, quad, UVs, helper, S );
+
+ // b (i + 1, j + 4)
+ const SMDS_MeshNode*& Nb = next_base[ ++next_base_len ].node;
+ if ( !Nb )
+ Nb = makeNode( next_base[ next_base_len ], y, quad, UVs, helper, S );
+
+ // c
+ double u = (curr_base[j + 2].u + next_base[next_base_len - 2].u) / 2.0;
+ double v = (curr_base[j + 2].v + next_base[next_base_len - 2].v) / 2.0;
+ gp_Pnt P = S->Value(u,v);
+ SMDS_MeshNode* Nc = helper->AddNode(P.X(), P.Y(), P.Z(), 0, u, v);
+
+ // d
+ u = (curr_base[j + 2].u + next_base[next_base_len - 1].u) / 2.0;
+ v = (curr_base[j + 2].v + next_base[next_base_len - 1].v) / 2.0;
+ P = S->Value(u,v);
+ SMDS_MeshNode* Nd = helper->AddNode(P.X(), P.Y(), P.Z(), 0, u, v);
+
+ // e
+ u = (curr_base[j + 2].u + next_base[next_base_len].u) / 2.0;
+ v = (curr_base[j + 2].v + next_base[next_base_len].v) / 2.0;
+ P = S->Value(u,v);
+ SMDS_MeshNode* Ne = helper->AddNode(P.X(), P.Y(), P.Z(), 0, u, v);
+
+ // Faces
+ helper->AddFace(curr_base[j + 0].node,
+ curr_base[j + 1].node, Nc,
+ next_base[next_base_len - 2].node);
+
+ helper->AddFace(curr_base[j + 1].node,
+ curr_base[j + 2].node, Nd, Nc);
+
+ helper->AddFace(curr_base[j + 2].node,
+ curr_base[j + 3].node, Ne, Nd);
+
+ helper->AddFace(curr_base[j + 3].node,
+ curr_base[j + 4].node, Nb, Ne);
+
+ helper->AddFace(Nc, Nd, Na, next_base[next_base_len - 2].node);
+
+ helper->AddFace(Nd, Ne, Nb, Na);
+ }
+
+ void reduce31( const vector<UVPtStruct>& curr_base,
+ vector<UVPtStruct>& next_base,
+ const int j,
+ int & next_base_len,
+ FaceQuadStruct::Ptr& quad,
+ gp_UV* UVs,
+ const double y,
+ SMESH_MesherHelper* helper,
+ Handle(Geom_Surface)& S)
+ {
+ // add one "H": nodes b,c,e and faces 1,2,4,5
+ //
+ // .---------b i + 1
+ // |\ 5 /|
+ // | \ / |
+ // | c---e |
+ // |1 |2 |4 |
+ // | | | |
+ // .--.---.--. i
+ //
+ // j j+1 j+2 j+3
+
+ // b (i + 1, j + 3)
+ const SMDS_MeshNode*& Nb = next_base[ ++next_base_len ].node;
+ if ( !Nb )
+ Nb = makeNode( next_base[ next_base_len ], y, quad, UVs, helper, S );
+
+ // c and e
+ double u1 = (curr_base[ j ].u + next_base[ next_base_len-1 ].u ) / 2.0;
+ double u2 = (curr_base[ j+3 ].u + next_base[ next_base_len ].u ) / 2.0;
+ double u3 = (u2 - u1) / 3.0;
+ //
+ double v1 = (curr_base[ j ].v + next_base[ next_base_len-1 ].v ) / 2.0;
+ double v2 = (curr_base[ j+3 ].v + next_base[ next_base_len ].v ) / 2.0;
+ double v3 = (v2 - v1) / 3.0;
+ // c
+ double u = u1 + u3;
+ double v = v1 + v3;
+ gp_Pnt P = S->Value(u,v);
+ SMDS_MeshNode* Nc = helper->AddNode( P.X(), P.Y(), P.Z(), 0, u, v );
+ // e
+ u = u1 + u3 + u3;
+ v = v1 + v3 + v3;
+ P = S->Value(u,v);
+ SMDS_MeshNode* Ne = helper->AddNode( P.X(), P.Y(), P.Z(), 0, u, v );
+
+ // Faces
+ // 1
+ helper->AddFace( curr_base[ j + 0 ].node,
+ curr_base[ j + 1 ].node,
+ Nc,
+ next_base[ next_base_len - 1 ].node);
+ // 2
+ helper->AddFace( curr_base[ j + 1 ].node,
+ curr_base[ j + 2 ].node, Ne, Nc);
+ // 4
+ helper->AddFace( curr_base[ j + 2 ].node,
+ curr_base[ j + 3 ].node, Nb, Ne);
+ // 5
+ helper->AddFace(Nc, Ne, Nb,
+ next_base[ next_base_len - 1 ].node);
+ }
+
+ typedef void (* PReduceFunction) ( const vector<UVPtStruct>& curr_base,
+ vector<UVPtStruct>& next_base,
+ const int j,
+ int & next_base_len,
+ FaceQuadStruct::Ptr & quad,
+ gp_UV* UVs,
+ const double y,
+ SMESH_MesherHelper* helper,
+ Handle(Geom_Surface)& S);
+
+} // namespace
+
+//=======================================================================
+/*!
+ * Implementation of Reduced algorithm (meshing with quadrangles only)
+ */
+//=======================================================================
+
+bool StdMeshers_Quadrangle_2D::computeReduced (SMESH_Mesh & aMesh,
+ const TopoDS_Face& aFace,
+ FaceQuadStruct::Ptr quad)
+{
+ SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+ Handle(Geom_Surface) S = BRep_Tool::Surface(aFace);
+ int i,j,geomFaceID = meshDS->ShapeToIndex(aFace);
+
+ int nb = quad->side[0].NbPoints(); // bottom
+ int nr = quad->side[1].NbPoints(); // right
+ int nt = quad->side[2].NbPoints(); // top
+ int nl = quad->side[3].NbPoints(); // left
+
+ // Simple Reduce 10->8->6->4 (3 steps) Multiple Reduce 10->4 (1 step)
+ //
+ // .-----.-----.-----.-----. .-----.-----.-----.-----.
+ // | / \ | / \ | | / \ | / \ |
+ // | / .--.--. \ | | / \ | / \ |
+ // | / / | \ \ | | / .----.----. \ |
+ // .---.---.---.---.---.---. | / / \ | / \ \ |
+ // | / / \ | / \ \ | | / / \ | / \ \ |
+ // | / / .-.-. \ \ | | / / .---.---. \ \ |
+ // | / / / | \ \ \ | | / / / \ | / \ \ \ |
+ // .--.--.--.--.--.--.--.--. | / / / \ | / \ \ \ |
+ // | / / / \ | / \ \ \ | | / / / .-.-. \ \ \ |
+ // | / / / .-.-. \ \ \ | | / / / / | \ \ \ \ |
+ // | / / / / | \ \ \ \ | | / / / / | \ \ \ \ |
+ // .-.-.-.--.--.--.--.-.-.-. .-.-.-.--.--.--.--.-.-.-.
+
+ bool MultipleReduce = false;
+ {
+ int nb1 = nb;
+ int nr1 = nr;
+ int nt1 = nt;
+
+ if (nr == nl) {
+ if (nb < nt) {
+ nt1 = nb;
+ nb1 = nt;
+ }
+ }
+ else if (nb == nt) {
+ nr1 = nb; // and == nt
+ if (nl < nr) {
+ nt1 = nl;
+ nb1 = nr;
+ }
+ else {
+ nt1 = nr;
+ nb1 = nl;
+ }
+ }
+ else {
+ return false;
+ }
+
+ // number of rows and columns
+ int nrows = nr1 - 1;
+ int ncol_top = nt1 - 1;
+ int ncol_bot = nb1 - 1;
+ // number of rows needed to reduce ncol_bot to ncol_top using simple 3->1 "tree" (see below)
+ int nrows_tree31 =
+ int( ceil( log( double(ncol_bot) / ncol_top) / log( 3.))); // = log x base 3
+ if ( nrows < nrows_tree31 )
+ {
+ MultipleReduce = true;
+ error( COMPERR_WARNING,
+ SMESH_Comment("To use 'Reduced' transition, "
+ "number of face rows should be at least ")
+ << nrows_tree31 << ". Actual number of face rows is " << nrows << ". "
+ "'Quadrangle preference (reversed)' transion has been used.");
+ }
+ }
+
+ if (MultipleReduce) { // == computeQuadPref QUAD_QUADRANGLE_PREF_REVERSED
+ //==================================================
+ int dh = abs(nb-nt);
+ int dv = abs(nr-nl);
+
+ if (dh >= dv) {
+ if (nt > nb) {
+ // it is a base case => not shift quad but may be replacement is need
+ shiftQuad(quad,0);
+ }
+ else {
+ // we have to shift quad on 2
+ shiftQuad(quad,2);
+ }
+ }
+ else {
+ if (nr > nl) {
+ // we have to shift quad on 1
+ shiftQuad(quad,1);
+ }
+ else {
+ // we have to shift quad on 3
+ shiftQuad(quad,3);
+ }
+ }
+
+ nb = quad->side[0].NbPoints();
+ nr = quad->side[1].NbPoints();
+ nt = quad->side[2].NbPoints();
+ nl = quad->side[3].NbPoints();
+ dh = abs(nb-nt);
+ dv = abs(nr-nl);
+ int nbh = Max(nb,nt);
+ int nbv = Max(nr,nl);
+ int addh = 0;
+ int addv = 0;
+
+ if (dh>dv) {
+ addv = (dh-dv)/2;
+ nbv = nbv + addv;
+ }
+ else { // dv>=dh
+ addh = (dv-dh)/2;
+ nbh = nbh + addh;
+ }
+
+ const vector<UVPtStruct>& uv_eb = quad->side[0].GetUVPtStruct(true,0);
+ const vector<UVPtStruct>& uv_er = quad->side[1].GetUVPtStruct(false,1);
+ const vector<UVPtStruct>& uv_et = quad->side[2].GetUVPtStruct(true,1);
+ const vector<UVPtStruct>& uv_el = quad->side[3].GetUVPtStruct(false,0);