src/SMESH/SMESH_Quadrangle_2D.cxx

   1 //  SMESH SMESH : implementaion of SMESH idl descriptions
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   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.
  10 //
  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.
  15 //
  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
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Quadrangle_2D.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 using namespace std;
  30 #include "SMESH_Quadrangle_2D.hxx"
  31 #include "SMESH_Gen.hxx"
  32 #include "SMESH_Mesh.hxx"
  33
  34 #include "SMDS_MeshElement.hxx"
  35 #include "SMDS_MeshNode.hxx"
  36 #include "SMDS_EdgePosition.hxx"
  37 #include "SMDS_FacePosition.hxx"
  38
  39 #include <BRep_Tool.hxx>
  40 #include <BRepTools.hxx>
  41 #include <BRepTools_WireExplorer.hxx>
  42 #include <Geom_Surface.hxx>
  43 #include <Geom_Curve.hxx>
  44 #include <Geom2d_Curve.hxx>
  45 #include <Handle_Geom2d_Curve.hxx>
  46 #include <Handle_Geom_Curve.hxx>
  47 #include <gp_Pnt2d.hxx>
  48 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  49
  50 #include "utilities.h"
  51
  52 //=============================================================================
  53 /*!
  54  *
  55  */
  56 //=============================================================================
  57
  58 SMESH_Quadrangle_2D::SMESH_Quadrangle_2D(int hypId,
  59         int studyId, SMESH_Gen * gen):SMESH_2D_Algo(hypId, studyId, gen)
  60 {
  61         MESSAGE("SMESH_Quadrangle_2D::SMESH_Quadrangle_2D");
  62         _name = "Quadrangle_2D";
  63         //  _shapeType = TopAbs_FACE;
  64         _shapeType = (1 << TopAbs_FACE);
  65 }
  66
  67 //=============================================================================
  68 /*!
  69  *
  70  */
  71 //=============================================================================
  72
  73 SMESH_Quadrangle_2D::~SMESH_Quadrangle_2D()
  74 {
  75         MESSAGE("SMESH_Quadrangle_2D::~SMESH_Quadrangle_2D");
  76 }
  77
  78 //=============================================================================
  79 /*!
  80  *
  81  */
  82 //=============================================================================
  83
  84 bool SMESH_Quadrangle_2D::CheckHypothesis(SMESH_Mesh & aMesh,
  85         const TopoDS_Shape & aShape)
  86 {
  87         //MESSAGE("SMESH_Quadrangle_2D::CheckHypothesis");
  88
  89         bool isOk = true;
  90
  91         // nothing to check
  92
  93         return isOk;
  94 }
  95
  96 //=============================================================================
  97 /*!
  98  *
  99  */
 100 //=============================================================================
 101
 102 bool SMESH_Quadrangle_2D::Compute(SMESH_Mesh & aMesh,
 103         const TopoDS_Shape & aShape)throw(SALOME_Exception)
 104 {
 105         //MESSAGE("SMESH_Quadrangle_2D::Compute");
 106         SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
 107         SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
 108
 109         FaceQuadStruct *quad = CheckAnd2Dcompute(aMesh, aShape);
 110         if (!quad)
 111                 return false;
 112
 113         // --- compute 3D values on points, store points & quadrangles
 114
 115         int nbdown = quad->nbPts[0];
 116         int nbright = quad->nbPts[1];
 117         int nbVertices = nbdown * nbright;
 118         int nbQuad = (nbdown - 1) * (nbright - 1);
 119         //SCRUTE(nbVertices);
 120         //SCRUTE(nbQuad);
 121
 122         //   const TopoDS_Face& FF = TopoDS::Face(aShape);
 123         //   bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
 124         //   TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
 125         const TopoDS_Face & F = TopoDS::Face(aShape);
 126         bool faceIsForward = (F.Orientation() == TopAbs_FORWARD);
 127         Handle(Geom_Surface) S = BRep_Tool::Surface(F);
 128
 129         for (int i = 1; i < nbdown - 1; i++)
 130                 for (int j = 1; j < nbright - 1; j++)   // internal points
 131                 {
 132                         int ij = j * nbdown + i;
 133                         double u = quad->uv_grid[ij].u;
 134                         double v = quad->uv_grid[ij].v;
 135                         gp_Pnt P = S->Value(u, v);
 136                         SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
 137                         meshDS->SetNodeOnFace(node, F);
 138                         quad->uv_grid[ij].node = node;
 139 //  Handle (SMDS_FacePosition) fpos
 140 //    = new SMDS_FacePosition(theSubMesh->GetId(),i,j); // easier than u,v
 141 //  node->SetPosition(fpos);
 142                         SMDS_FacePosition* fpos
 143                                 = dynamic_cast<SMDS_FacePosition*>(node->GetPosition());
 144                         fpos->SetUParameter(i);
 145                         fpos->SetVParameter(j);
 146                 }
 147
 148         //   bool isQuadForward = ( faceIsForward == quad->isEdgeForward[0]);
 149         for (int i = 0; i < nbdown - 1; i++)
 150                 for (int j = 0; j < nbright - 1; j++)   // faces
 151                 {
 152                         const SMDS_MeshNode *a, *b, *c, *d;
 153                         a = quad->uv_grid[j * nbdown + i].node;
 154                         b = quad->uv_grid[j * nbdown + i + 1].node;
 155                         c = quad->uv_grid[(j + 1) * nbdown + i + 1].node;
 156                         d = quad->uv_grid[(j + 1) * nbdown + i].node;
 157                         //  if (isQuadForward) faceId = meshDS->AddFace(a,b,c,d);
 158                         //  else faceId = meshDS->AddFace(a,d,c,b);
 159                         SMDS_MeshFace * face = meshDS->AddFace(a, b, c, d);
 160                         meshDS->SetMeshElementOnShape(face, F);
 161                 }
 162
 163         QuadDelete(quad);
 164         bool isOk = true;
 165         return isOk;
 166 }
 167
 168 //=============================================================================
 169 /*!
 170  *
 171  */
 172 //=============================================================================
 173
 174 FaceQuadStruct *SMESH_Quadrangle_2D::CheckAnd2Dcompute(SMESH_Mesh & aMesh,
 175         const TopoDS_Shape & aShape)throw(SALOME_Exception)
 176 {
 177         //MESSAGE("SMESH_Quadrangle_2D::ComputeWithoutStore");
 178
 179         SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
 180
 181         //   const TopoDS_Face& FF = TopoDS::Face(aShape);
 182         //   bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
 183         //   TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
 184         const TopoDS_Face & F = TopoDS::Face(aShape);
 185         bool faceIsForward = (F.Orientation() == TopAbs_FORWARD);
 186
 187         // verify 1 wire only, with 4 edges, same number of points on opposite edges
 188
 189         if (NumberOfWires(F) != 1)
 190         {
 191                 MESSAGE("only 1 wire by face (quadrangles)");
 192                 return 0;
 193                 //throw SALOME_Exception(LOCALIZED("only 1 wire by face (quadrangles)"));
 194         }
 195         //   const TopoDS_Wire WW = BRepTools::OuterWire(F);
 196         //   TopoDS_Wire W = TopoDS::Wire(WW.Oriented(TopAbs_FORWARD));
 197         const TopoDS_Wire & W = BRepTools::OuterWire(F);
 198         BRepTools_WireExplorer wexp(W, F);
 199
 200         FaceQuadStruct *quad = new FaceQuadStruct;
 201         for (int i = 0; i < 4; i++)
 202                 quad->uv_edges[i] = 0;
 203         quad->uv_grid = 0;
 204
 205         int nbEdges = 0;
 206         for (wexp.Init(W, F); wexp.More(); wexp.Next())
 207         {
 208                 //       const TopoDS_Edge& EE = wexp.Current();
 209                 //       TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
 210                 const TopoDS_Edge & E = wexp.Current();
 211                 int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
 212                 if (nbEdges < 4)
 213                 {
 214                         quad->edge[nbEdges] = E;
 215                         quad->nbPts[nbEdges] = nb + 2;  // internal points + 2 extrema
 216                 }
 217                 nbEdges++;
 218         }
 219
 220         if (nbEdges != 4)
 221         {
 222                 MESSAGE("face must have 4 edges /quadrangles");
 223                 QuadDelete(quad);
 224                 return 0;
 225                 //throw SALOME_Exception(LOCALIZED("face must have 4 edges /quadrangles"));
 226         }
 227
 228         if (quad->nbPts[0] != quad->nbPts[2])
 229         {
 230                 MESSAGE("different point number-opposed edge");
 231                 QuadDelete(quad);
 232                 return 0;
 233                 //throw SALOME_Exception(LOCALIZED("different point number-opposed edge"));
 234         }
 235
 236         if (quad->nbPts[1] != quad->nbPts[3])
 237         {
 238                 MESSAGE("different point number-opposed edge");
 239                 QuadDelete(quad);
 240                 return 0;
 241                 //throw SALOME_Exception(LOCALIZED("different point number-opposed edge"));
 242         }
 243
 244         // set normalized grid on unit square in parametric domain
 245
 246         SetNormalizedGrid(aMesh, F, quad);
 247
 248         return quad;
 249 }
 250
 251 //=============================================================================
 252 /*!
 253  *
 254  */
 255 //=============================================================================
 256
 257 void SMESH_Quadrangle_2D::QuadDelete(FaceQuadStruct * quad)
 258 {
 259         //MESSAGE("SMESH_Quadrangle_2D::QuadDelete");
 260         if (quad)
 261         {
 262                 for (int i = 0; i < 4; i++)
 263                 {
 264                         if (quad->uv_edges[i])
 265                                 delete[]quad->uv_edges[i];
 266                         quad->edge[i].Nullify();
 267                 }
 268                 if (quad->uv_grid)
 269                         delete[]quad->uv_grid;
 270                 delete quad;
 271         }
 272 }
 273
 274 //=============================================================================
 275 /*!
 276  *
 277  */
 278 //=============================================================================
 279
 280 void SMESH_Quadrangle_2D::SetNormalizedGrid(SMESH_Mesh & aMesh,
 281         const TopoDS_Shape & aShape, FaceQuadStruct * quad) throw(SALOME_Exception)
 282 {
 283         // Algorithme décrit dans "Génération automatique de maillages"
 284         // P.L. GEORGE, MASSON, § 6.4.1 p. 84-85
 285         // traitement dans le domaine paramétrique 2d u,v
 286         // transport - projection sur le carré unité
 287
 288         const TopoDS_Face & F = TopoDS::Face(aShape);
 289
 290         // 1 --- find orientation of the 4 edges, by test on extrema
 291
 292         //      max             min                    0     x1     1
 293         //     |<----north-2-------^                a3 -------------> a2
 294         //     |                   |                   ^1          1^
 295         //    west-3            east-1 =right          |            |
 296         //     |                   |         ==>       |            |
 297         //  y0 |                   | y1                |            |
 298         //     |                   |                   |0          0|
 299         //     v----south-0-------->                a0 -------------> a1
 300         //      min             max                    0     x0     1
 301         //             =down
 302         //
 303
 304         Handle(Geom2d_Curve) c2d[4];
 305         gp_Pnt2d pf[4];
 306         gp_Pnt2d pl[4];
 307         for (int i = 0; i < 4; i++)
 308         {
 309                 c2d[i] = BRep_Tool::CurveOnSurface(quad->edge[i],
 310                         F, quad->first[i], quad->last[i]);
 311                 pf[i] = c2d[i]->Value(quad->first[i]);
 312                 pl[i] = c2d[i]->Value(quad->last[i]);
 313                 quad->isEdgeForward[i] = false;
 314         }
 315
 316         double eps2d = 1.e-3;           // *** utiliser plutot TopExp::CommonVertex, puis
 317         // distances si piece fausse
 318         int i = 0;
 319         if ((pf[1].Distance(pl[0]) < eps2d) || (pl[1].Distance(pl[0]) < eps2d))
 320         {
 321                 quad->isEdgeForward[0] = true;
 322         }
 323         else
 324         {
 325                 double tmp = quad->first[0];
 326                 quad->first[0] = quad->last[0];
 327                 quad->last[0] = tmp;
 328                 pf[0] = c2d[0]->Value(quad->first[0]);
 329                 pl[0] = c2d[0]->Value(quad->last[0]);
 330         }
 331         for (int i = 1; i < 4; i++)
 332         {
 333                 quad->isEdgeForward[i] = (pf[i].Distance(pl[i - 1]) < eps2d);
 334                 if (!quad->isEdgeForward[i])
 335                 {
 336                         double tmp = quad->first[i];
 337                         quad->first[i] = quad->last[i];
 338                         quad->last[i] = tmp;
 339                         pf[i] = c2d[i]->Value(quad->first[i]);
 340                         pl[i] = c2d[i]->Value(quad->last[i]);
 341                         //SCRUTE(pf[i].Distance(pl[i-1]));
 342                         ASSERT(pf[i].Distance(pl[i - 1]) < eps2d);
 343                 }
 344         }
 345         //SCRUTE(pf[0].Distance(pl[3]));
 346         ASSERT(pf[0].Distance(pl[3]) < eps2d);
 347
 348 //   for (int i=0; i<4; i++)
 349 //     {
 350 //       SCRUTE(quad->isEdgeForward[i]);
 351 //       MESSAGE(" -first "<<i<<" "<<pf[i].X()<<" "<<pf[i].Y());
 352 //       MESSAGE(" -last  "<<i<<" "<<pl[i].X()<<" "<<pl[i].Y());
 353 //     }
 354
 355         // 2 --- load 2d edge points (u,v) with orientation and value on unit square
 356
 357         for (int i = 0; i < 2; i++)
 358         {
 359                 quad->uv_edges[i] = LoadEdgePoints(aMesh, F,
 360                         quad->edge[i], quad->first[i], quad->last[i]);
 361
 362                 //                         quad->isEdgeForward[i]);
 363         }
 364         for (int i = 2; i < 4; i++)
 365         {
 366                 quad->uv_edges[i] = LoadEdgePoints(aMesh, F,
 367                         quad->edge[i], quad->last[i], quad->first[i]);
 368
 369                 //                         !quad->isEdgeForward[i]);
 370         }
 371
 372         // 3 --- 2D normalized values on unit square [0..1][0..1]
 373
 374         int nbdown = quad->nbPts[0];
 375         int nbright = quad->nbPts[1];
 376         quad->uv_grid = new UVPtStruct[nbright * nbdown];
 377
 378         UVPtStruct *uv_grid = quad->uv_grid;
 379         UVPtStruct *uv_e0 = quad->uv_edges[0];
 380         UVPtStruct *uv_e1 = quad->uv_edges[1];
 381         UVPtStruct *uv_e2 = quad->uv_edges[2];
 382         UVPtStruct *uv_e3 = quad->uv_edges[3];
 383         gp_Pnt2d a0 = pf[0];
 384         gp_Pnt2d a1 = pf[1];
 385         gp_Pnt2d a2 = pf[2];
 386         gp_Pnt2d a3 = pf[3];
 387
 388         // nodes Id on edges
 389
 390         int j = 0;
 391         for (int i = 0; i < nbdown; i++)
 392         {
 393                 int ij = j * nbdown + i;
 394                 uv_grid[ij].node = uv_e0[i].node;
 395         }
 396         i = nbdown - 1;
 397         for (int j = 0; j < nbright; j++)
 398         {
 399                 int ij = j * nbdown + i;
 400                 uv_grid[ij].node = uv_e1[j].node;
 401         }
 402         j = nbright - 1;
 403         for (int i = 0; i < nbdown; i++)
 404         {
 405                 int ij = j * nbdown + i;
 406                 uv_grid[ij].node = uv_e2[i].node;
 407         }
 408         i = 0;
 409         for (int j = 0; j < nbright; j++)
 410         {
 411                 int ij = j * nbdown + i;
 412                 uv_grid[ij].node = uv_e3[j].node;
 413         }
 414
 415         // normalized 2d values on grid
 416
 417         for (int i = 0; i < nbdown; i++)
 418                 for (int j = 0; j < nbright; j++)
 419                 {
 420                         int ij = j * nbdown + i;
 421                         // --- droite i cste : x = x0 + y(x1-x0)
 422                         double x0 = uv_e0[i].normParam; // bas - sud
 423                         double x1 = uv_e2[i].normParam; // haut - nord
 424                         // --- droite j cste : y = y0 + x(y1-y0)
 425                         double y0 = uv_e3[j].normParam; // gauche-ouest
 426                         double y1 = uv_e1[j].normParam; // droite - est
 427                         // --- intersection : x=x0+(y0+x(y1-y0))(x1-x0)
 428                         double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
 429                         double y = y0 + x * (y1 - y0);
 430                         uv_grid[ij].x = x;
 431                         uv_grid[ij].y = y;
 432                         //MESSAGE("-xy-01 "<<x0<<" "<<x1<<" "<<y0<<" "<<y1);
 433                         //MESSAGE("-xy-norm "<<i<<" "<<j<<" "<<x<<" "<<y);
 434                 }
 435
 436         // 4 --- projection on 2d domain (u,v)
 437
 438         for (int i = 0; i < nbdown; i++)
 439                 for (int j = 0; j < nbright; j++)
 440                 {
 441                         int ij = j * nbdown + i;
 442                         double x = uv_grid[ij].x;
 443                         double y = uv_grid[ij].y;
 444                         double param_0 = uv_e0[0].param + x * (uv_e0[nbdown - 1].param - uv_e0[0].param);       // sud
 445                         double param_2 = uv_e2[0].param + x * (uv_e2[nbdown - 1].param - uv_e2[0].param);       // nord
 446                         double param_1 = uv_e1[0].param + y * (uv_e1[nbright - 1].param - uv_e1[0].param);      // est
 447                         double param_3 = uv_e3[0].param + y * (uv_e3[nbright - 1].param - uv_e3[0].param);      // ouest
 448
 449                         //MESSAGE("params "<<param_0<<" "<<param_1<<" "<<param_2<<" "<<param_3);
 450                         gp_Pnt2d p0 = c2d[0]->Value(param_0);
 451                         gp_Pnt2d p1 = c2d[1]->Value(param_1);
 452                         gp_Pnt2d p2 = c2d[2]->Value(param_2);
 453                         gp_Pnt2d p3 = c2d[3]->Value(param_3);
 454
 455                         double u =
 456                                 (1 - y) * p0.X() + x * p1.X() + y * p2.X() + (1 - x) * p3.X();
 457                         double v =
 458                                 (1 - y) * p0.Y() + x * p1.Y() + y * p2.Y() + (1 - x) * p3.Y();
 459
 460                         u -= (1 - x) * (1 - y) * a0.X() + x * (1 - y) * a1.X() +
 461                                 x * y * a2.X() + (1 - x) * y * a3.X();
 462                         v -= (1 - x) * (1 - y) * a0.Y() + x * (1 - y) * a1.Y() +
 463                                 x * y * a2.Y() + (1 - x) * y * a3.Y();
 464
 465                         uv_grid[ij].u = u;
 466                         uv_grid[ij].v = v;
 467
 468                         //MESSAGE("-uv- "<<i<<" "<<j<<" "<<uv_grid[ij].u<<" "<<uv_grid[ij].v);
 469                 }
 470 }
 471
 472 //=============================================================================
 473 /*!
 474  *
 475  */
 476 //=============================================================================
 477
 478 UVPtStruct *SMESH_Quadrangle_2D::LoadEdgePoints(SMESH_Mesh & aMesh,
 479         const TopoDS_Face & F, const TopoDS_Edge & E, double first, double last)
 480   //                        bool isForward)
 481 {
 482         //MESSAGE("SMESH_Quadrangle_2D::LoadEdgePoints");
 483
 484         SMDS_Mesh * meshDS = aMesh.GetMeshDS();
 485
 486         // --- IDNodes of first and last Vertex
 487
 488         TopoDS_Vertex VFirst, VLast;
 489         TopExp::Vertices(E, VFirst, VLast);     // corresponds to f and l
 490
 491     ASSERT(!VFirst.IsNull());
 492     SMDS_Iterator<const SMDS_MeshNode *> * lid=
 493         aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes();
 494     const SMDS_MeshNode * idFirst = lid->next();
 495     delete lid;
 496
 497     ASSERT(!VLast.IsNull());
 498     lid=aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes();
 499     const SMDS_MeshNode * idLast = lid->next();
 500     delete lid;
 501
 502         // --- edge internal IDNodes (relies on good order storage, not checked)
 503
 504         int nbPoints = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
 505         //SCRUTE(nbPoints);
 506         UVPtStruct *uvslf = new UVPtStruct[nbPoints + 2];
 507
 508         double f, l;
 509         Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
 510
 511         map<double, const SMDS_MeshNode *> params;
 512         SMDS_Iterator<const SMDS_MeshNode *> * ite=
 513                 aMesh.GetSubMesh(E)->GetSubMeshDS()->GetNodes();
 514
 515         while(ite->more())
 516         {
 517                 const SMDS_MeshNode * node = ite->next();
 518                 const SMDS_EdgePosition* epos
 519                         = static_cast<const SMDS_EdgePosition*>(node->GetPosition());
 520                 double param = epos->GetUParameter();
 521                 params[param] = node;
 522         }
 523         delete ite;
 524
 525         bool isForward = (((l - f) * (last - first)) > 0);
 526         double paramin = 0;
 527         double paramax = 0;
 528         if (isForward)
 529         {
 530                 paramin = f;
 531                 paramax = l;
 532                 gp_Pnt2d p = C2d->Value(f);     // first point = Vertex Forward
 533                 uvslf[0].x = p.X();
 534                 uvslf[0].y = p.Y();
 535                 uvslf[0].param = f;
 536                 uvslf[0].node = idFirst;
 537                 //MESSAGE("__ f "<<f<<" "<<uvslf[0].x <<" "<<uvslf[0].y);
 538                 map < double, const SMDS_MeshNode* >::iterator itp = params.begin();
 539                 for (int i = 1; i <= nbPoints; i++)     // nbPoints internal
 540                 {
 541                         double param = (*itp).first;
 542                         gp_Pnt2d p = C2d->Value(param);
 543                         uvslf[i].x = p.X();
 544                         uvslf[i].y = p.Y();
 545                         uvslf[i].param = param;
 546                         uvslf[i].node = (*itp).second;
 547                         //MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[i].x <<" "<<uvslf[i].y);
 548                         itp++;
 549                 }
 550                 p = C2d->Value(l);              // last point = Vertex Reversed
 551                 uvslf[nbPoints + 1].x = p.X();
 552                 uvslf[nbPoints + 1].y = p.Y();
 553                 uvslf[nbPoints + 1].param = l;
 554                 uvslf[nbPoints + 1].node = idLast;
 555                 //MESSAGE("__ l "<<l<<" "<<uvslf[nbPoints+1].x <<" "<<uvslf[nbPoints+1].y);
 556         }
 557         else
 558         {
 559                 paramin = l;
 560                 paramax = f;
 561                 gp_Pnt2d p = C2d->Value(l);     // first point = Vertex Reversed
 562                 uvslf[0].x = p.X();
 563                 uvslf[0].y = p.Y();
 564                 uvslf[0].param = l;
 565                 uvslf[0].node = idLast;
 566                 //MESSAGE("__ l "<<l<<" "<<uvslf[0].x <<" "<<uvslf[0].y);
 567                 map < double, const SMDS_MeshNode* >::reverse_iterator itp = params.rbegin();
 568                 for (int j = nbPoints; j >= 1; j--)     // nbPoints internal
 569                 {
 570                         double param = (*itp).first;
 571                         int i = nbPoints + 1 - j;
 572                         gp_Pnt2d p = C2d->Value(param);
 573                         uvslf[i].x = p.X();
 574                         uvslf[i].y = p.Y();
 575                         uvslf[i].param = param;
 576                         uvslf[i].node = (*itp).second;
 577                         //MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[i].x <<" "<<uvslf[i].y);
 578                         itp++;
 579                 }
 580                 p = C2d->Value(f);              // last point = Vertex Forward
 581                 uvslf[nbPoints + 1].x = p.X();
 582                 uvslf[nbPoints + 1].y = p.Y();
 583                 uvslf[nbPoints + 1].param = f;
 584                 uvslf[nbPoints + 1].node = idFirst;
 585                 //MESSAGE("__ f "<<f<<" "<<uvslf[nbPoints+1].x <<" "<<uvslf[nbPoints+1].y);
 586         }
 587
 588         ASSERT(paramin != paramax);
 589         for (int i = 0; i < nbPoints + 2; i++)
 590         {
 591                 uvslf[i].normParam = (uvslf[i].param - paramin) / (paramax - paramin);
 592                 //SCRUTE(uvslf[i].normParam);
 593         }
 594
 595         return uvslf;
 596 }
 597
 598 //=============================================================================
 599 /*!
 600  *
 601  */
 602 //=============================================================================
 603
 604 ostream & SMESH_Quadrangle_2D::SaveTo(ostream & save)
 605 {
 606         return save << this;
 607 }
 608
 609 //=============================================================================
 610 /*!
 611  *
 612  */
 613 //=============================================================================
 614
 615 istream & SMESH_Quadrangle_2D::LoadFrom(istream & load)
 616 {
 617         return load >> (*this);
 618 }
 619
 620 //=============================================================================
 621 /*!
 622  *
 623  */
 624 //=============================================================================
 625
 626 ostream & operator <<(ostream & save, SMESH_Quadrangle_2D & hyp)
 627 {
 628         return save;
 629 }
 630
 631 //=============================================================================
 632 /*!
 633  *
 634  */
 635 //=============================================================================
 636
 637 istream & operator >>(istream & load, SMESH_Quadrangle_2D & hyp)
 638 {
 639         return load;
 640 }