1 // SMESH SMESH : implementaion of SMESH idl descriptions
3 // Copyright (C) 2003 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.
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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : StdMeshers_Quadrangle_2D.cxx
25 // Moved here from SMESH_Quadrangle_2D.cxx
26 // Author : Paul RASCLE, EDF
31 #include "StdMeshers_Quadrangle_2D.hxx"
32 #include "SMESH_Gen.hxx"
33 #include "SMESH_Mesh.hxx"
34 #include "SMESH_subMesh.hxx"
36 #include "SMDS_MeshElement.hxx"
37 #include "SMDS_MeshNode.hxx"
38 #include "SMDS_EdgePosition.hxx"
39 #include "SMDS_FacePosition.hxx"
41 #include <BRep_Tool.hxx>
42 #include <BRepTools.hxx>
43 #include <BRepTools_WireExplorer.hxx>
45 #include <Geom_Surface.hxx>
46 #include <Geom_Curve.hxx>
47 #include <Geom2d_Curve.hxx>
48 #include <GeomAdaptor_Curve.hxx>
49 #include <GCPnts_UniformAbscissa.hxx>
51 #include <Precision.hxx>
52 #include <gp_Pnt2d.hxx>
53 #include <TColStd_ListIteratorOfListOfInteger.hxx>
55 #include "utilities.h"
56 #include "Utils_ExceptHandlers.hxx"
59 //=============================================================================
63 //=============================================================================
65 StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D (int hypId, int studyId, SMESH_Gen* gen)
66 : SMESH_2D_Algo(hypId, studyId, gen)
68 MESSAGE("StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D");
69 _name = "Quadrangle_2D";
70 // _shapeType = TopAbs_FACE;
71 _shapeType = (1 << TopAbs_FACE);
74 //=============================================================================
78 //=============================================================================
80 StdMeshers_Quadrangle_2D::~StdMeshers_Quadrangle_2D()
82 MESSAGE("StdMeshers_Quadrangle_2D::~StdMeshers_Quadrangle_2D");
85 //=============================================================================
89 //=============================================================================
91 bool StdMeshers_Quadrangle_2D::CheckHypothesis
93 const TopoDS_Shape& aShape,
94 SMESH_Hypothesis::Hypothesis_Status& aStatus)
96 //MESSAGE("StdMeshers_Quadrangle_2D::CheckHypothesis");
99 aStatus = SMESH_Hypothesis::HYP_OK;
106 //=============================================================================
110 //=============================================================================
112 bool StdMeshers_Quadrangle_2D::Compute (SMESH_Mesh& aMesh,
113 const TopoDS_Shape& aShape) throw (SALOME_Exception)
115 Unexpect aCatch(SalomeException);
116 //MESSAGE("StdMeshers_Quadrangle_2D::Compute");
117 SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
118 aMesh.GetSubMesh(aShape);
120 FaceQuadStruct *quad = CheckAnd2Dcompute(aMesh, aShape);
124 // --- compute 3D values on points, store points & quadrangles
126 int nbdown = quad->nbPts[0];
127 int nbup = quad->nbPts[2];
128 // bool isDownOut = (nbdown > nbup);
129 // bool isUpOut = (nbdown < nbup);
131 int nbright = quad->nbPts[1];
132 int nbleft = quad->nbPts[3];
133 // bool isRightOut = (nbright > nbleft);
134 // bool isLeftOut = (nbright < nbleft);
136 int nbhoriz = Min(nbdown, nbup);
137 int nbvertic = Min(nbright, nbleft);
139 int nbVertices = nbhoriz * nbvertic;
140 int nbQuad = (nbhoriz - 1) * (nbvertic - 1);
141 //SCRUTE(nbVertices);
144 // const TopoDS_Face& FF = TopoDS::Face(aShape);
145 // bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
146 // TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
147 const TopoDS_Face& F = TopoDS::Face(aShape);
148 bool faceIsForward = (F.Orientation() == TopAbs_FORWARD);
149 Handle(Geom_Surface) S = BRep_Tool::Surface(F);
151 // internal mesh nodes
153 for (i = 1; i < nbhoriz - 1; i++) {
154 for (j = 1; j < nbvertic - 1; j++) {
155 int ij = j * nbhoriz + i;
156 double u = quad->uv_grid[ij].u;
157 double v = quad->uv_grid[ij].v;
158 gp_Pnt P = S->Value(u, v);
159 SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
160 meshDS->SetNodeOnFace(node, F);
161 quad->uv_grid[ij].node = node;
162 SMDS_FacePosition* fpos =
163 dynamic_cast<SMDS_FacePosition*>(node->GetPosition().get());
164 fpos->SetUParameter(u);
165 fpos->SetVParameter(v);
172 // --.--.--.--.--.-- nbvertic
178 // ---.----.----.--- 0
179 // 0 > > > > > > > > nbhoriz
185 int iup = nbhoriz - 1;
186 if (quad->isEdgeOut[3]) { ilow++; } else { if (quad->isEdgeOut[1]) iup--; }
189 int jup = nbvertic - 1;
190 if (quad->isEdgeOut[0]) { jlow++; } else { if (quad->isEdgeOut[2]) jup--; }
192 // regular quadrangles
193 // bool isQuadForward = ( faceIsForward == quad->isEdgeForward[0]);
194 for (i = ilow; i < iup; i++) {
195 for (j = jlow; j < jup; j++) {
196 const SMDS_MeshNode *a, *b, *c, *d;
197 a = quad->uv_grid[j * nbhoriz + i].node;
198 b = quad->uv_grid[j * nbhoriz + i + 1].node;
199 c = quad->uv_grid[(j + 1) * nbhoriz + i + 1].node;
200 d = quad->uv_grid[(j + 1) * nbhoriz + i].node;
201 // if (isQuadForward) faceId = meshDS->AddFace(a,b,c,d);
202 // else faceId = meshDS->AddFace(a,d,c,b);
203 SMDS_MeshFace * face = meshDS->AddFace(a, b, c, d);
204 meshDS->SetMeshElementOnShape(face, F);
208 UVPtStruct *uv_e0 = quad->uv_edges[0];
209 UVPtStruct *uv_e1 = quad->uv_edges[1];
210 UVPtStruct *uv_e2 = quad->uv_edges[2];
211 UVPtStruct *uv_e3 = quad->uv_edges[3];
213 double eps = Precision::Confusion();
215 // Boundary quadrangles
217 if (quad->isEdgeOut[0]) {
220 // |___|___|___|___|___|___|
222 // |___|___|___|___|___|___|
224 // |___|___|___|___|___|___| __ first row of the regular grid
225 // . . . . . . . . . __ down edge nodes
227 // >->->->->->->->->->->->-> -- direction of processing
229 int g = 0; // number of last processed node in the regular grid
231 // number of last node of the down edge to be processed
232 int stop = nbdown - 1;
233 // if right edge is out, we will stop at a node, previous to the last one
234 if (quad->isEdgeOut[1]) stop--;
236 // for each node of the down edge find nearest node
237 // in the first row of the regular grid and link them
238 for (i = 0; i < stop; i++) {
239 const SMDS_MeshNode *a, *b, *c, *d;
241 b = uv_e0[i + 1].node;
242 gp_Pnt pb (b->X(), b->Y(), b->Z());
244 // find node c in the regular grid, which will be linked with node b
247 // right bound reached, link with the rightmost node
249 c = quad->uv_grid[nbhoriz + iup].node;
251 // find in the grid node c, nearest to the b
252 double mind = RealLast();
253 for (int k = g; k <= iup; k++) {
255 const SMDS_MeshNode *nk;
256 if (k < ilow) // this can be, if left edge is out
257 nk = uv_e3[1].node; // get node from the left edge
259 nk = quad->uv_grid[nbhoriz + k].node; // get one of middle nodes
261 gp_Pnt pnk (nk->X(), nk->Y(), nk->Z());
262 double dist = pb.Distance(pnk);
263 if (dist < mind - eps) {
273 if (near == g) { // make triangle
274 SMDS_MeshFace* face = meshDS->AddFace(a, b, c);
275 meshDS->SetMeshElementOnShape(face, F);
276 } else { // make quadrangle
280 d = quad->uv_grid[nbhoriz + near - 1].node;
281 SMDS_MeshFace* face = meshDS->AddFace(a, b, c, d);
282 meshDS->SetMeshElementOnShape(face, F);
284 // if node d is not at position g - make additional triangles
286 for (int k = near - 1; k > g; k--) {
287 c = quad->uv_grid[nbhoriz + k].node;
291 d = quad->uv_grid[nbhoriz + k - 1].node;
292 SMDS_MeshFace* face = meshDS->AddFace(a, c, d);
293 meshDS->SetMeshElementOnShape(face, F);
300 if (quad->isEdgeOut[2]) {
303 // <-<-<-<-<-<-<-<-<-<-<-<-< -- direction of processing
305 // . . . . . . . . . __ up edge nodes
306 // ___ ___ ___ ___ ___ ___ __ first row of the regular grid
308 // |___|___|___|___|___|___|
310 // |___|___|___|___|___|___|
313 int g = nbhoriz - 1; // last processed node in the regular grid
316 // if left edge is out, we will stop at a second node
317 if (quad->isEdgeOut[3]) stop++;
319 // for each node of the up edge find nearest node
320 // in the first row of the regular grid and link them
321 for (i = nbup - 1; i > stop; i--) {
322 const SMDS_MeshNode *a, *b, *c, *d;
324 b = uv_e2[i - 1].node;
325 gp_Pnt pb (b->X(), b->Y(), b->Z());
327 // find node c in the grid, which will be linked with node b
329 if (i == stop + 1) { // left bound reached, link with the leftmost node
330 c = quad->uv_grid[nbhoriz*(nbvertic - 2) + ilow].node;
333 // find node c in the grid, nearest to the b
334 double mind = RealLast();
335 for (int k = g; k >= ilow; k--) {
336 const SMDS_MeshNode *nk;
338 nk = uv_e1[nbright - 2].node;
340 nk = quad->uv_grid[nbhoriz*(nbvertic - 2) + k].node;
341 gp_Pnt pnk (nk->X(), nk->Y(), nk->Z());
342 double dist = pb.Distance(pnk);
343 if (dist < mind - eps) {
353 if (near == g) { // make triangle
354 SMDS_MeshFace* face = meshDS->AddFace(a, b, c);
355 meshDS->SetMeshElementOnShape(face, F);
356 } else { // make quadrangle
358 d = uv_e1[nbright - 2].node;
360 d = quad->uv_grid[nbhoriz*(nbvertic - 2) + near + 1].node;
361 SMDS_MeshFace* face = meshDS->AddFace(a, b, c, d);
362 meshDS->SetMeshElementOnShape(face, F);
364 if (near + 1 < g) { // if d not is at g - make additional triangles
365 for (int k = near + 1; k < g; k++) {
366 c = quad->uv_grid[nbhoriz*(nbvertic - 2) + k].node;
368 d = uv_e1[nbright - 2].node;
370 d = quad->uv_grid[nbhoriz*(nbvertic - 2) + k + 1].node;
371 SMDS_MeshFace* face = meshDS->AddFace(a, c, d);
372 meshDS->SetMeshElementOnShape(face, F);
381 // right or left boundary quadrangles
382 if (quad->isEdgeOut[1]) {
383 // MESSAGE("right edge is out");
384 int g = 0; // last processed node in the grid
385 int stop = nbright - 1;
386 if (quad->isEdgeOut[2]) stop--;
387 for (i = 0; i < stop; i++) {
388 const SMDS_MeshNode *a, *b, *c, *d;
390 b = uv_e1[i + 1].node;
391 gp_Pnt pb (b->X(), b->Y(), b->Z());
393 // find node c in the grid, nearest to the b
395 if (i == stop - 1) { // up bondary reached
396 c = quad->uv_grid[nbhoriz*(jup + 1) - 2].node;
399 double mind = RealLast();
400 for (int k = g; k <= jup; k++) {
401 const SMDS_MeshNode *nk;
403 nk = uv_e0[nbdown - 2].node;
405 nk = quad->uv_grid[nbhoriz*(k + 1) - 2].node;
406 gp_Pnt pnk (nk->X(), nk->Y(), nk->Z());
407 double dist = pb.Distance(pnk);
408 if (dist < mind - eps) {
418 if (near == g) { // make triangle
419 SMDS_MeshFace* face = meshDS->AddFace(a, b, c);
420 meshDS->SetMeshElementOnShape(face, F);
421 } else { // make quadrangle
423 d = uv_e0[nbdown - 2].node;
425 d = quad->uv_grid[nbhoriz*near - 2].node;
426 SMDS_MeshFace* face = meshDS->AddFace(a, b, c, d);
427 meshDS->SetMeshElementOnShape(face, F);
429 if (near - 1 > g) { // if d not is at g - make additional triangles
430 for (int k = near - 1; k > g; k--) {
431 c = quad->uv_grid[nbhoriz*(k + 1) - 2].node;
433 d = uv_e0[nbdown - 2].node;
435 d = quad->uv_grid[nbhoriz*k - 2].node;
436 SMDS_MeshFace* face = meshDS->AddFace(a, c, d);
437 meshDS->SetMeshElementOnShape(face, F);
444 if (quad->isEdgeOut[3]) {
445 // MESSAGE("left edge is out");
446 int g = nbvertic - 1; // last processed node in the grid
448 if (quad->isEdgeOut[0]) stop++;
449 for (i = nbleft - 1; i > stop; i--) {
450 const SMDS_MeshNode *a, *b, *c, *d;
452 b = uv_e3[i - 1].node;
453 gp_Pnt pb (b->X(), b->Y(), b->Z());
455 // find node c in the grid, nearest to the b
457 if (i == stop + 1) { // down bondary reached
458 c = quad->uv_grid[nbhoriz*jlow + 1].node;
461 double mind = RealLast();
462 for (int k = g; k >= jlow; k--) {
463 const SMDS_MeshNode *nk;
467 nk = quad->uv_grid[nbhoriz*k + 1].node;
468 gp_Pnt pnk (nk->X(), nk->Y(), nk->Z());
469 double dist = pb.Distance(pnk);
470 if (dist < mind - eps) {
480 if (near == g) { // make triangle
481 SMDS_MeshFace* face = meshDS->AddFace(a, b, c);
482 meshDS->SetMeshElementOnShape(face, F);
483 } else { // make quadrangle
487 d = quad->uv_grid[nbhoriz*(near + 1) + 1].node;
488 SMDS_MeshFace* face = meshDS->AddFace(a, b, c, d);
489 meshDS->SetMeshElementOnShape(face, F);
491 if (near + 1 < g) { // if d not is at g - make additional triangles
492 for (int k = near + 1; k < g; k++) {
493 c = quad->uv_grid[nbhoriz*k + 1].node;
497 d = quad->uv_grid[nbhoriz*(k + 1) + 1].node;
498 SMDS_MeshFace* face = meshDS->AddFace(a, c, d);
499 meshDS->SetMeshElementOnShape(face, F);
513 //=============================================================================
517 //=============================================================================
519 FaceQuadStruct *StdMeshers_Quadrangle_2D::CheckAnd2Dcompute
520 (SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) throw(SALOME_Exception)
522 Unexpect aCatch(SalomeException);
523 // MESSAGE("StdMeshers_Quadrangle_2D::CheckAnd2Dcompute");
525 SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
527 // const TopoDS_Face& FF = TopoDS::Face(aShape);
528 // bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
529 // TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
530 const TopoDS_Face & F = TopoDS::Face(aShape);
531 bool faceIsForward = (F.Orientation() == TopAbs_FORWARD);
533 // verify 1 wire only, with 4 edges
535 if (NumberOfWires(F) != 1)
537 MESSAGE("only 1 wire by face (quadrangles)");
539 //throw SALOME_Exception(LOCALIZED("only 1 wire by face (quadrangles)"));
541 // const TopoDS_Wire WW = BRepTools::OuterWire(F);
542 // TopoDS_Wire W = TopoDS::Wire(WW.Oriented(TopAbs_FORWARD));
543 const TopoDS_Wire& W = BRepTools::OuterWire(F);
544 BRepTools_WireExplorer wexp (W, F);
546 FaceQuadStruct *quad = new FaceQuadStruct;
547 for (int i = 0; i < 4; i++)
548 quad->uv_edges[i] = 0;
552 for (wexp.Init(W, F); wexp.More(); wexp.Next())
554 // const TopoDS_Edge& EE = wexp.Current();
555 // TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
556 const TopoDS_Edge& E = wexp.Current();
557 int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
560 quad->edge[nbEdges] = E;
561 quad->nbPts[nbEdges] = nb + 2; // internal points + 2 extrema
568 MESSAGE("face must have 4 edges /quadrangles");
571 //throw SALOME_Exception(LOCALIZED("face must have 4 edges /quadrangles"));
574 // if (quad->nbPts[0] != quad->nbPts[2]) {
575 // MESSAGE("different point number-opposed edge");
578 // //throw SALOME_Exception(LOCALIZED("different point number-opposed edge"));
581 // if (quad->nbPts[1] != quad->nbPts[3]) {
582 // MESSAGE("different point number-opposed edge");
585 // //throw SALOME_Exception(LOCALIZED("different point number-opposed edge"));
588 // set normalized grid on unit square in parametric domain
590 SetNormalizedGrid(aMesh, F, quad);
595 //=============================================================================
599 //=============================================================================
601 void StdMeshers_Quadrangle_2D::QuadDelete (FaceQuadStruct * quad)
603 //MESSAGE("StdMeshers_Quadrangle_2D::QuadDelete");
606 for (int i = 0; i < 4; i++)
608 if (quad->uv_edges[i])
609 delete [] quad->uv_edges[i];
610 quad->edge[i].Nullify();
613 delete [] quad->uv_grid;
618 //=============================================================================
622 //=============================================================================
624 void StdMeshers_Quadrangle_2D::SetNormalizedGrid (SMESH_Mesh & aMesh,
625 const TopoDS_Shape& aShape,
626 FaceQuadStruct* quad) throw (SALOME_Exception)
628 Unexpect aCatch(SalomeException);
629 // Algorithme décrit dans "Génération automatique de maillages"
630 // P.L. GEORGE, MASSON, § 6.4.1 p. 84-85
631 // traitement dans le domaine paramétrique 2d u,v
632 // transport - projection sur le carré unité
634 // MESSAGE("StdMeshers_Quadrangle_2D::SetNormalizedGrid");
635 const TopoDS_Face& F = TopoDS::Face(aShape);
637 // 1 --- find orientation of the 4 edges, by test on extrema
640 // |<----north-2-------^ a3 -------------> a2
642 // west-3 east-1 =right | |
646 // v----south-0--------> a0 -------------> a1
651 Handle(Geom2d_Curve) c2d[4];
654 for (int i = 0; i < 4; i++)
656 c2d[i] = BRep_Tool::CurveOnSurface(quad->edge[i], F,
657 quad->first[i], quad->last[i]);
658 pf[i] = c2d[i]->Value(quad->first[i]);
659 pl[i] = c2d[i]->Value(quad->last[i]);
660 quad->isEdgeForward[i] = false;
663 double eps2d = 1.e-3; // *** utiliser plutot TopExp::CommonVertex, puis
664 // distances si piece fausse
666 if ((pf[1].Distance(pl[0]) < eps2d) || (pl[1].Distance(pl[0]) < eps2d))
668 quad->isEdgeForward[0] = true;
670 double tmp = quad->first[0];
671 quad->first[0] = quad->last[0];
673 pf[0] = c2d[0]->Value(quad->first[0]);
674 pl[0] = c2d[0]->Value(quad->last[0]);
677 for (int i = 1; i < 4; i++)
679 quad->isEdgeForward[i] = (pf[i].Distance(pl[i - 1]) < eps2d);
680 if (!quad->isEdgeForward[i])
682 double tmp = quad->first[i];
683 quad->first[i] = quad->last[i];
685 pf[i] = c2d[i]->Value(quad->first[i]);
686 pl[i] = c2d[i]->Value(quad->last[i]);
687 //SCRUTE(pf[i].Distance(pl[i-1]));
688 ASSERT(pf[i].Distance(pl[i - 1]) < eps2d);
691 //SCRUTE(pf[0].Distance(pl[3]));
692 ASSERT(pf[0].Distance(pl[3]) < eps2d);
694 // for (int i=0; i<4; i++)
696 // SCRUTE(quad->isEdgeForward[i]);
697 // MESSAGE(" -first "<<i<<" "<<pf[i].X()<<" "<<pf[i].Y());
698 // MESSAGE(" -last "<<i<<" "<<pl[i].X()<<" "<<pl[i].Y());
701 // 2 --- load 2d edge points (u,v) with orientation and value on unit square
704 for (int i = 0; i < 2; i++)
706 quad->uv_edges[i] = LoadEdgePoints(aMesh, F, quad->edge[i],
707 quad->first[i], quad->last[i]);
708 if (!quad->uv_edges[i]) loadOk = false;
709 // quad->isEdgeForward[i]);
712 for (int i = 2; i < 4; i++)
714 quad->uv_edges[i] = LoadEdgePoints(aMesh, F, quad->edge[i],
715 quad->last[i], quad->first[i]);
716 if (!quad->uv_edges[i]) loadOk = false;
717 // !quad->isEdgeForward[i]);
722 // MESSAGE("StdMeshers_Quadrangle_2D::SetNormalizedGrid - LoadEdgePoints failed");
727 // 3 --- 2D normalized values on unit square [0..1][0..1]
729 // int nbdown = quad->nbPts[0];
730 // int nbright = quad->nbPts[1];
731 int nbhoriz = Min(quad->nbPts[0], quad->nbPts[2]);
732 int nbvertic = Min(quad->nbPts[1], quad->nbPts[3]);
733 // MESSAGE("nbhoriz, nbvertic = " << nbhoriz << nbvertic);
735 quad->isEdgeOut[0] = (quad->nbPts[0] > quad->nbPts[2]);
736 quad->isEdgeOut[1] = (quad->nbPts[1] > quad->nbPts[3]);
737 quad->isEdgeOut[2] = (quad->nbPts[2] > quad->nbPts[0]);
738 quad->isEdgeOut[3] = (quad->nbPts[3] > quad->nbPts[1]);
740 quad->uv_grid = new UVPtStruct[nbvertic * nbhoriz];
742 UVPtStruct *uv_grid = quad->uv_grid;
743 UVPtStruct *uv_e0 = quad->uv_edges[0];
744 UVPtStruct *uv_e1 = quad->uv_edges[1];
745 UVPtStruct *uv_e2 = quad->uv_edges[2];
746 UVPtStruct *uv_e3 = quad->uv_edges[3];
748 // nodes Id on "in" edges
749 if (! quad->isEdgeOut[0]) {
751 for (int i = 0; i < nbhoriz; i++) { // down
752 int ij = j * nbhoriz + i;
753 uv_grid[ij].node = uv_e0[i].node;
756 if (! quad->isEdgeOut[1]) {
758 for (int j = 0; j < nbvertic; j++) { // right
759 int ij = j * nbhoriz + i;
760 uv_grid[ij].node = uv_e1[j].node;
763 if (! quad->isEdgeOut[2]) {
764 int j = nbvertic - 1;
765 for (int i = 0; i < nbhoriz; i++) { // up
766 int ij = j * nbhoriz + i;
767 uv_grid[ij].node = uv_e2[i].node;
770 if (! quad->isEdgeOut[3]) {
772 for (int j = 0; j < nbvertic; j++) { // left
773 int ij = j * nbhoriz + i;
774 uv_grid[ij].node = uv_e3[j].node;
778 // falsificate "out" edges
779 if (quad->isEdgeOut[0]) // down
780 uv_e0 = MakeEdgePoints
781 (aMesh, F, quad->edge[0], quad->first[0], quad->last[0], nbhoriz - 1);
782 else if (quad->isEdgeOut[2]) // up
783 uv_e2 = MakeEdgePoints
784 (aMesh, F, quad->edge[2], quad->last[2], quad->first[2], nbhoriz - 1);
786 if (quad->isEdgeOut[1]) // right
787 uv_e1 = MakeEdgePoints
788 (aMesh, F, quad->edge[1], quad->first[1], quad->last[1], nbvertic - 1);
789 else if (quad->isEdgeOut[3]) // left
790 uv_e3 = MakeEdgePoints
791 (aMesh, F, quad->edge[3], quad->last[3], quad->first[3], nbvertic - 1);
793 // normalized 2d values on grid
794 for (int i = 0; i < nbhoriz; i++)
796 for (int j = 0; j < nbvertic; j++)
798 int ij = j * nbhoriz + i;
799 // --- droite i cste : x = x0 + y(x1-x0)
800 double x0 = uv_e0[i].normParam; // bas - sud
801 double x1 = uv_e2[i].normParam; // haut - nord
802 // --- droite j cste : y = y0 + x(y1-y0)
803 double y0 = uv_e3[j].normParam; // gauche-ouest
804 double y1 = uv_e1[j].normParam; // droite - est
805 // --- intersection : x=x0+(y0+x(y1-y0))(x1-x0)
806 double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
807 double y = y0 + x * (y1 - y0);
810 //MESSAGE("-xy-01 "<<x0<<" "<<x1<<" "<<y0<<" "<<y1);
811 //MESSAGE("-xy-norm "<<i<<" "<<j<<" "<<x<<" "<<y);
815 // 4 --- projection on 2d domain (u,v)
821 for (int i = 0; i < nbhoriz; i++)
823 for (int j = 0; j < nbvertic; j++)
825 int ij = j * nbhoriz + i;
826 double x = uv_grid[ij].x;
827 double y = uv_grid[ij].y;
828 double param_0 = uv_e0[0].param + x * (uv_e0[nbhoriz - 1].param - uv_e0[0].param); // sud
829 double param_2 = uv_e2[0].param + x * (uv_e2[nbhoriz - 1].param - uv_e2[0].param); // nord
830 double param_1 = uv_e1[0].param + y * (uv_e1[nbvertic - 1].param - uv_e1[0].param); // est
831 double param_3 = uv_e3[0].param + y * (uv_e3[nbvertic - 1].param - uv_e3[0].param); // ouest
833 //MESSAGE("params "<<param_0<<" "<<param_1<<" "<<param_2<<" "<<param_3);
834 gp_Pnt2d p0 = c2d[0]->Value(param_0);
835 gp_Pnt2d p1 = c2d[1]->Value(param_1);
836 gp_Pnt2d p2 = c2d[2]->Value(param_2);
837 gp_Pnt2d p3 = c2d[3]->Value(param_3);
839 double u = (1 - y) * p0.X() + x * p1.X() + y * p2.X() + (1 - x) * p3.X();
840 double v = (1 - y) * p0.Y() + x * p1.Y() + y * p2.Y() + (1 - x) * p3.Y();
842 u -= (1 - x) * (1 - y) * a0.X() + x * (1 - y) * a1.X() +
843 x * y * a2.X() + (1 - x) * y * a3.X();
844 v -= (1 - x) * (1 - y) * a0.Y() + x * (1 - y) * a1.Y() +
845 x * y * a2.Y() + (1 - x) * y * a3.Y();
850 //MESSAGE("-uv- "<<i<<" "<<j<<" "<<uv_grid[ij].u<<" "<<uv_grid[ij].v);
855 //=============================================================================
859 //=============================================================================
860 UVPtStruct* StdMeshers_Quadrangle_2D::LoadEdgePoints (SMESH_Mesh & aMesh,
861 const TopoDS_Face& F,
862 const TopoDS_Edge& E,
863 double first, double last)
866 //MESSAGE("StdMeshers_Quadrangle_2D::LoadEdgePoints");
868 SMDS_Mesh* meshDS = aMesh.GetMeshDS();
870 // --- IDNodes of first and last Vertex
872 TopoDS_Vertex VFirst, VLast;
873 TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l
875 ASSERT(!VFirst.IsNull());
876 SMDS_NodeIteratorPtr lid = aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes();
879 MESSAGE ( "NO NODE BUILT ON VERTEX" );
882 const SMDS_MeshNode* idFirst = lid->next();
884 ASSERT(!VLast.IsNull());
885 lid = aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes();
888 MESSAGE ( "NO NODE BUILT ON VERTEX" );
891 const SMDS_MeshNode* idLast = lid->next();
893 // --- edge internal IDNodes (relies on good order storage, not checked)
895 map<double, const SMDS_MeshNode *> params;
896 SMDS_NodeIteratorPtr ite = aMesh.GetSubMesh(E)->GetSubMeshDS()->GetNodes();
900 const SMDS_MeshNode* node = ite->next();
901 const SMDS_EdgePosition* epos =
902 static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
903 double param = epos->GetUParameter();
904 params[param] = node;
907 int nbPoints = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
908 if (nbPoints != params.size())
910 MESSAGE( "BAD NODE ON EDGE POSITIONS" );
913 UVPtStruct* uvslf = new UVPtStruct[nbPoints + 2];
916 Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
918 bool isForward = (((l - f) * (last - first)) > 0);
925 gp_Pnt2d p = C2d->Value(f); // first point = Vertex Forward
929 uvslf[0].node = idFirst;
930 //MESSAGE("__ f "<<f<<" "<<uvslf[0].x <<" "<<uvslf[0].y);
931 map < double, const SMDS_MeshNode* >::iterator itp = params.begin();
932 for (int i = 1; i <= nbPoints; i++) // nbPoints internal
934 double param = (*itp).first;
935 gp_Pnt2d p = C2d->Value(param);
938 uvslf[i].param = param;
939 uvslf[i].node = (*itp).second;
940 //MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[i].x <<" "<<uvslf[i].y);
943 p = C2d->Value(l); // last point = Vertex Reversed
944 uvslf[nbPoints + 1].x = p.X();
945 uvslf[nbPoints + 1].y = p.Y();
946 uvslf[nbPoints + 1].param = l;
947 uvslf[nbPoints + 1].node = idLast;
948 //MESSAGE("__ l "<<l<<" "<<uvslf[nbPoints+1].x <<" "<<uvslf[nbPoints+1].y);
953 gp_Pnt2d p = C2d->Value(l); // first point = Vertex Reversed
957 uvslf[0].node = idLast;
958 //MESSAGE("__ l "<<l<<" "<<uvslf[0].x <<" "<<uvslf[0].y);
959 map < double, const SMDS_MeshNode* >::reverse_iterator itp = params.rbegin();
961 for (int j = nbPoints; j >= 1; j--) // nbPoints internal
963 double param = (*itp).first;
964 int i = nbPoints + 1 - j;
965 gp_Pnt2d p = C2d->Value(param);
968 uvslf[i].param = param;
969 uvslf[i].node = (*itp).second;
970 //MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[i].x <<" "<<uvslf[i].y);
973 p = C2d->Value(f); // last point = Vertex Forward
974 uvslf[nbPoints + 1].x = p.X();
975 uvslf[nbPoints + 1].y = p.Y();
976 uvslf[nbPoints + 1].param = f;
977 uvslf[nbPoints + 1].node = idFirst;
978 //MESSAGE("__ f "<<f<<" "<<uvslf[nbPoints+1].x <<" "<<uvslf[nbPoints+1].y);
981 ASSERT(paramin != paramax);
982 for (int i = 0; i < nbPoints + 2; i++)
984 uvslf[i].normParam = (uvslf[i].param - paramin) / (paramax - paramin);
985 //SCRUTE(uvslf[i].normParam);
991 //=============================================================================
995 //=============================================================================
996 UVPtStruct* StdMeshers_Quadrangle_2D::MakeEdgePoints (SMESH_Mesh & aMesh,
997 const TopoDS_Face& F,
998 const TopoDS_Edge& E,
999 double first, double last,
1002 // MESSAGE("StdMeshers_Quadrangle_2D::MakeEdgePoints");
1004 UVPtStruct* uvslf = new UVPtStruct[nb_segm + 1];
1005 list<double> params;
1007 // --- edge internal points
1009 Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, fi, li);
1010 if (!Curve.IsNull()) {
1012 GeomAdaptor_Curve C3d (Curve);
1013 double length = EdgeLength(E);
1014 double eltSize = length / nb_segm;
1015 GCPnts_UniformAbscissa Discret (C3d, eltSize, fi, li);
1016 if (!Discret.IsDone()) return false;
1017 int NbPoints = Discret.NbPoints();
1018 for (int i = 1; i <= NbPoints; i++) {
1019 double param = Discret.Parameter(i);
1020 params.push_back(param);
1023 catch (Standard_Failure) {
1029 // Edge is a degenerated Edge
1030 BRep_Tool::Range(E, fi, li);
1031 double du = (li - fi) / nb_segm;
1032 for (int i = 1; i <= nb_segm + 1; i++)
1034 double param = fi + (i - 1) * du;
1035 params.push_back(param);
1040 Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
1043 bool isForward = (((l - f) * (last - first)) > 0);
1045 list<double>::iterator itU = params.begin();
1046 for (int i = 0; i <= nb_segm; i++) // nbPoints internal
1048 double param = *itU;
1049 gp_Pnt2d p = C2d->Value(param);
1052 uvslf[i].param = param;
1053 uvslf[i].normParam = (param - f) / (l - f);
1057 list<double>::reverse_iterator itU = params.rbegin();
1058 for (int j = nb_segm; j >= 0; j--) // nbPoints internal
1060 double param = *itU;
1061 int i = nb_segm - j;
1062 gp_Pnt2d p = C2d->Value(param);
1065 uvslf[i].param = param;
1066 uvslf[i].normParam = (param - l) / (f - l);
1075 //=============================================================================
1079 //=============================================================================
1081 ostream & StdMeshers_Quadrangle_2D::SaveTo(ostream & save)
1086 //=============================================================================
1090 //=============================================================================
1092 istream & StdMeshers_Quadrangle_2D::LoadFrom(istream & load)
1097 //=============================================================================
1101 //=============================================================================
1103 ostream & operator <<(ostream & save, StdMeshers_Quadrangle_2D & hyp)
1105 return hyp.SaveTo( save );
1108 //=============================================================================
1112 //=============================================================================
1114 istream & operator >>(istream & load, StdMeshers_Quadrangle_2D & hyp)
1116 return hyp.LoadFrom( load );