src/MgtPoly/MgtPoly.cxx

   1 // Copyright (c) 1998-1999 Matra Datavision
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and/or modify it under
   7 // the terms of the GNU Lesser General Public License version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 #include <MgtPoly.ixx>
  16
  17 #include <TColgp_Array1OfPnt.hxx>
  18 #include <PColgp_HArray1OfPnt.hxx>
  19 #include <TColgp_Array1OfPnt2d.hxx>
  20 #include <PColgp_HArray1OfPnt2d.hxx>
  21
  22 #include <TColStd_Array1OfReal.hxx>
  23 #include <TColStd_HArray1OfReal.hxx>
  24 #include <PColStd_HArray1OfReal.hxx>
  25 #include <TColStd_Array1OfInteger.hxx>
  26 #include <PColStd_HArray1OfInteger.hxx>
  27
  28 #include <Poly_Array1OfTriangle.hxx>
  29 #include <PPoly_HArray1OfTriangle.hxx>
  30
  31 #define MgtBRepSpeedDownCast
  32
  33 //=======================================================================
  34 //function : ArrayCopy
  35 //purpose  : Copy the gp_Pnt
  36 //           from an Array1 from TColgp (TCollection)
  37 //           to an HArray1 from PColgp (PCollection)
  38 //=======================================================================
  39
  40 static Handle(PColgp_HArray1OfPnt) ArrayCopy
  41        (const TColgp_Array1OfPnt& TArray)
  42 {
  43   Standard_Integer Lower = TArray.Lower();
  44   Standard_Integer Upper = TArray.Upper();
  45   Standard_Integer Index;
  46   Handle(PColgp_HArray1OfPnt) PArray = new PColgp_HArray1OfPnt(Lower, Upper);
  47   for (Index = Lower; Index <= Upper; Index++) {
  48     PArray->SetValue(Index, TArray(Index));
  49   }
  50   return PArray;
  51 }
  52
  53 //=======================================================================
  54 //function : ArrayCopy
  55 //purpose  : Copy the gp_Pnt
  56 //           from an HArray1 from PColgp (PCollection)
  57 //           to an Array1 from TColgp (TCollection)
  58 //=======================================================================
  59
  60 static void ArrayCopy(const Handle(PColgp_HArray1OfPnt)& PArray,
  61                       TColgp_Array1OfPnt& TArray)
  62 {
  63   Standard_Integer Lower = PArray->Lower();
  64   Standard_Integer Upper = PArray->Upper();
  65   Standard_Integer Index;
  66   for (Index = Lower; Index <= Upper; Index++) {
  67     TArray(Index) = PArray->Value(Index);
  68   }
  69 }
  70
  71 //=======================================================================
  72 //function : ArrayCopy
  73 //purpose  : Copy the gp_Pnt2d
  74 //           from an Array1 from TColgp (TCollection)
  75 //           to an Array1 from PColgp (PCollection)
  76 //=======================================================================
  77
  78 static Handle(PColgp_HArray1OfPnt2d) ArrayCopy
  79        (const TColgp_Array1OfPnt2d& TArray)
  80 {
  81   Standard_Integer Lower = TArray.Lower();
  82   Standard_Integer Upper = TArray.Upper();
  83   Standard_Integer Index;
  84   Handle(PColgp_HArray1OfPnt2d) PArray =
  85     new PColgp_HArray1OfPnt2d(Lower, Upper);
  86   for (Index = Lower; Index <= Upper; Index++) {
  87     PArray->SetValue(Index, TArray(Index));
  88   }
  89   return PArray;
  90 }
  91
  92 //=======================================================================
  93 //function : ArrayCopy
  94 //purpose  : Copy the gp_Pnt2d
  95 //           from an HArray1 from PColgp (PCollection)
  96 //           to an Array1 from TColgp (TCollection)
  97 //=======================================================================
  98
  99 static void ArrayCopy
 100   (const Handle(PColgp_HArray1OfPnt2d)& PArray,
 101    TColgp_Array1OfPnt2d& TArray)
 102 {
 103   Standard_Integer Lower = PArray->Lower();
 104   Standard_Integer Upper = PArray->Upper();
 105   Standard_Integer Index;
 106   for (Index = Lower; Index <= Upper; Index++) {
 107     TArray(Index) = PArray->Value(Index);
 108   }
 109 }
 110
 111
 112 //=======================================================================
 113 //function : ArrayCopy
 114 //purpose  : Copy the Triangle
 115 //           from an Array1 from Poly (TCollection)
 116 //           to an HArray1 from PPoly (PCollection)
 117 //=======================================================================
 118
 119 static Handle(PPoly_HArray1OfTriangle) ArrayCopy
 120 (const Poly_Array1OfTriangle& TArray)
 121 {
 122   Standard_Integer Lower = TArray.Lower();
 123   Standard_Integer Upper = TArray.Upper();
 124   Standard_Integer Index;
 125   Handle(PPoly_HArray1OfTriangle) PArray =
 126     new PPoly_HArray1OfTriangle(Lower, Upper);
 127   for (Index = Lower; Index <= Upper; Index++) {
 128     PPoly_Triangle aPTriangle = MgtPoly::Translate(TArray(Index));
 129     PArray->SetValue(Index, aPTriangle);
 130   }
 131   return PArray;
 132 }
 133
 134 //=======================================================================
 135 //function : ArrayCopy
 136 //purpose  : Copy the Triangle
 137 //           from an HArray1 from PPoly (PCollection)
 138 //           to an Array1 from Poly (TCollection)
 139 //=======================================================================
 140
 141 static void ArrayCopy
 142   (const Handle(PPoly_HArray1OfTriangle)& PArray,
 143    Poly_Array1OfTriangle& TArray)
 144 {
 145   Standard_Integer Lower = PArray->Lower();
 146   Standard_Integer Upper = PArray->Upper();
 147   Standard_Integer Index;
 148   for (Index = Lower; Index <= Upper; Index++) {
 149     Poly_Triangle aTTriangle = MgtPoly::Translate(PArray->Value(Index));
 150     TArray(Index) = aTTriangle;
 151   }
 152 }
 153
 154 //=======================================================================
 155 //function : ArrayCopy
 156 //purpose  : Copy PColStd_HArray1OfInteger to TColStd_Array1OfInteger
 157 //=======================================================================
 158
 159 static void ArrayCopy(const Handle(PColStd_HArray1OfInteger)& PArray,
 160                       TColStd_Array1OfInteger&                TArray)
 161 {
 162   Standard_Integer Lower = PArray->Lower();
 163   Standard_Integer Upper = PArray->Upper();
 164   Standard_Integer Index;
 165   for (Index = Lower; Index <= Upper; Index++) {
 166     TArray(Index) = PArray->Value(Index);
 167   }
 168 }
 169
 170 //=======================================================================
 171 //function : ArrayCopy
 172 //purpose  : Copy TColStd_Array1OfInteger to PColStd_HArray1OfInteger
 173 //=======================================================================
 174
 175 static Handle(PColStd_HArray1OfInteger)
 176 ArrayCopy(const TColStd_Array1OfInteger& TArray)
 177 {
 178   Standard_Integer Lower = TArray.Lower();
 179   Standard_Integer Upper = TArray.Upper();
 180   Standard_Integer Index;
 181   Handle(PColStd_HArray1OfInteger) PArray =
 182     new PColStd_HArray1OfInteger(Lower, Upper);
 183   for (Index = Lower; Index <= Upper; Index++) {
 184     PArray->SetValue(Index, TArray.Value(Index));
 185   }
 186   return PArray;
 187 }
 188
 189 //=======================================================================
 190 //function : ArrayCopy
 191 //purpose  : Copy PColStd_HArray1OfReal to TColStd_Array1OfReal
 192 //=======================================================================
 193
 194 static void ArrayCopy(const Handle(PColStd_HArray1OfReal)& PArray,
 195                       TColStd_Array1OfReal&                TArray)
 196 {
 197   Standard_Integer Lower = PArray->Lower();
 198   Standard_Integer Upper = PArray->Upper();
 199   Standard_Integer Index;
 200   for (Index = Lower; Index <= Upper; Index++) {
 201     TArray(Index) = PArray->Value(Index);
 202   }
 203 }
 204
 205 //=======================================================================
 206 //function : ArrayCopy
 207 //purpose  : Copy TColStd_Array1OfReal to PColStd_HArray1OfReal
 208 //=======================================================================
 209
 210 static Handle(PColStd_HArray1OfReal)
 211 ArrayCopy(const TColStd_Array1OfReal& TArray)
 212 {
 213   Standard_Integer Lower = TArray.Lower();
 214   Standard_Integer Upper = TArray.Upper();
 215   Standard_Integer Index;
 216   Handle(PColStd_HArray1OfReal) PArray =
 217     new PColStd_HArray1OfReal(Lower, Upper);
 218   for (Index = Lower; Index <= Upper; Index++) {
 219     PArray->SetValue(Index, TArray.Value(Index));
 220   }
 221   return PArray;
 222 }
 223
 224
 225 //=======================================================================
 226 //function :
 227 //purpose  : Persistent -> Transient
 228 //=======================================================================
 229
 230 Poly_Triangle MgtPoly::Translate(const PPoly_Triangle& PObj)
 231 {
 232   Standard_Integer n1, n2, n3;
 233   PObj.Get(n1,n2,n3);
 234   Poly_Triangle TT(n1, n2, n3);
 235   return TT;
 236 }
 237
 238 //=======================================================================
 239 //function :
 240 //purpose  : Transient -> Persistent
 241 //=======================================================================
 242
 243 PPoly_Triangle MgtPoly::Translate(const Poly_Triangle& TObj)
 244 {
 245   Standard_Integer n1, n2, n3;
 246   TObj.Get(n1,n2,n3);
 247   PPoly_Triangle PT(n1, n2, n3);
 248   return PT;
 249 }
 250
 251 //=======================================================================
 252 //function : Translate Triangulation
 253 //purpose  : Persistent -> Transient
 254 //=======================================================================
 255
 256 Handle(Poly_Triangulation) MgtPoly::Translate
 257 (const Handle(PPoly_Triangulation)& PObj,
 258  PTColStd_PersistentTransientMap& aMap)
 259 {
 260   Handle(Poly_Triangulation) TT;
 261   if (!PObj.IsNull()) {
 262     if (aMap.IsBound(PObj)) {
 263
 264 #ifdef MgtBRepSpeedDownCast
 265       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
 266       TT = (Handle(Poly_Triangulation)&) aTrans;
 267 #else
 268       TT = Handle(Poly_Triangulation)::DownCast(aMap.Find(PObj));
 269 #endif
 270     }
 271     else {              // translate and bind
 272
 273       // myNodes
 274       Handle(PColgp_HArray1OfPnt) PNodes = PObj->Nodes();
 275       TColgp_Array1OfPnt TNodes (PNodes->Lower(), PNodes->Upper());
 276       ArrayCopy(PNodes, TNodes);
 277
 278       // myTriangles
 279       Handle(PPoly_HArray1OfTriangle) PTriangles = PObj->Triangles();
 280       Poly_Array1OfTriangle TTriangles (PTriangles->Lower(),
 281                                         PTriangles->Upper());
 282       ArrayCopy(PTriangles, TTriangles);
 283
 284       // myUVNodes
 285       if (PObj->HasUVNodes()) {
 286         Handle(PColgp_HArray1OfPnt2d) PUVNodes = PObj->UVNodes();
 287         TColgp_Array1OfPnt2d TUVNodes(PUVNodes->Lower(), PUVNodes->Upper());
 288         ArrayCopy(PUVNodes, TUVNodes);
 289         // Constructor
 290         TT = new Poly_Triangulation(TNodes, TUVNodes, TTriangles);
 291       }
 292       else {
 293         // Constructor
 294         TT = new Poly_Triangulation(TNodes, TTriangles);
 295       }
 296       // Set deflection
 297       TT->Deflection(PObj->Deflection());
 298       aMap.Bind(PObj, TT);
 299     }
 300   }
 301   return TT;
 302 }
 303
 304 //=======================================================================
 305 //function : Translate Triangulation
 306 //purpose  : Transient -> Persistent
 307 //=======================================================================
 308
 309 Handle(PPoly_Triangulation) MgtPoly::Translate
 310 (const Handle(Poly_Triangulation)& TObj,
 311  PTColStd_TransientPersistentMap& aMap)
 312 {
 313   Handle(PPoly_Triangulation) PT;
 314   if (!TObj.IsNull()) {
 315     if (aMap.IsBound(TObj)) {
 316 #ifdef MgtBRepSpeedDownCast
 317       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
 318       PT = (Handle(PPoly_Triangulation)&) aPers;
 319 #else
 320       PT = Handle(PPoly_Triangulation)::DownCast(aMap.Find(TObj));
 321 #endif
 322     }
 323     else {
 324       // myNodes
 325       const TColgp_Array1OfPnt& TNodes = TObj->Nodes();
 326       Handle(PColgp_HArray1OfPnt) PNodes =
 327         new PColgp_HArray1OfPnt(TNodes.Lower(),
 328                                 TNodes.Upper());
 329       PNodes = ArrayCopy(TNodes);
 330
 331       // myTriangles
 332       const Poly_Array1OfTriangle& TTriangle = TObj->Triangles();
 333       Handle(PPoly_HArray1OfTriangle) PTriangle =
 334         new PPoly_HArray1OfTriangle(TTriangle.Lower(),
 335                                     TTriangle.Upper());
 336       PTriangle = ArrayCopy(TTriangle);
 337
 338       // myUVNodes
 339       Handle(PColgp_HArray1OfPnt2d) PUVNodes;
 340       if (TObj->HasUVNodes()) {
 341         const TColgp_Array1OfPnt2d& TUVNodes = TObj->UVNodes();
 342         PUVNodes =
 343           new PColgp_HArray1OfPnt2d(TUVNodes.Lower(),
 344                                     TUVNodes.Upper());
 345         PUVNodes = ArrayCopy(TUVNodes);
 346       }
 347       // Constructor + Deflection
 348       PT = new PPoly_Triangulation(TObj->Deflection(),
 349                                    PNodes, PUVNodes, PTriangle);
 350       aMap.Bind(TObj, PT);
 351     }
 352   }
 353   return PT;
 354 }
 355
 356 //=======================================================================
 357 //function : Translate Polygon3D
 358 //purpose  : Persistent -> Transient
 359 //=======================================================================
 360
 361 Handle(Poly_Polygon3D) MgtPoly::Translate
 362 (const Handle(PPoly_Polygon3D)& PObj,
 363  PTColStd_PersistentTransientMap& aMap)
 364 {
 365   Handle(Poly_Polygon3D) TP;
 366   if (!PObj.IsNull()) {
 367     if (aMap.IsBound(PObj)) {
 368 #ifdef MgtBRepSpeedDownCast
 369       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
 370       TP = (Handle(Poly_Polygon3D)&) aTrans;
 371 #else
 372       TP = Handle(Poly_Polygon3D)::DownCast(aMap.Find(PObj));
 373 #endif
 374     }
 375     else {
 376
 377       // myNodes
 378       Handle(PColgp_HArray1OfPnt) PNodes = PObj->Nodes();
 379       TColgp_Array1OfPnt TNodes(PNodes->Lower(), PNodes->Upper());
 380       ArrayCopy(PNodes, TNodes);
 381
 382       // myParameters
 383
 384       Handle(PColStd_HArray1OfReal) PParam = PObj->Parameters();
 385       TColStd_Array1OfReal TParam(PParam->Lower(), PParam->Upper());
 386       ArrayCopy(PParam, TParam);
 387
 388       // Constructor + Deflection
 389       TP = new Poly_Polygon3D(TNodes, TParam);
 390       TP->Deflection(PObj->Deflection());
 391       aMap.Bind(PObj, TP);
 392     }
 393   }
 394   return TP;
 395 }
 396
 397 //=======================================================================
 398 //function : Translate Polygon3D
 399 //purpose  : Transient -> Persistent
 400 //=======================================================================
 401
 402 Handle(PPoly_Polygon3D) MgtPoly::Translate
 403 (const Handle(Poly_Polygon3D)& TObj,
 404  PTColStd_TransientPersistentMap& aMap)
 405 {
 406   Handle(PPoly_Polygon3D) PT;
 407   if (!TObj.IsNull()) {
 408     if (aMap.IsBound(TObj)) {
 409 #ifdef MgtBRepSpeedDownCast
 410       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
 411       PT = (Handle(PPoly_Polygon3D)&) aPers;
 412 #else
 413       PT = Handle(PPoly_Polygon3D)::DownCast(aMap.Find(TObj));
 414 #endif
 415     }
 416     else {
 417       // myNodes
 418       const TColgp_Array1OfPnt& TNodes = TObj->Nodes();
 419       Handle(PColgp_HArray1OfPnt) PNodes =
 420         new PColgp_HArray1OfPnt(TNodes.Lower(),
 421                                 TNodes.Upper());
 422       PNodes = ArrayCopy(TNodes);
 423
 424       // myParameters
 425       const TColStd_Array1OfReal& TParam = TObj->Parameters();
 426       Handle(PColStd_HArray1OfReal) PParam =
 427         new PColStd_HArray1OfReal(TParam.Lower(), TParam.Upper());
 428       PParam = ArrayCopy(TParam);
 429
 430       // constructor + Deflection
 431       PT = new PPoly_Polygon3D(PNodes, PParam, TObj->Deflection());
 432       aMap.Bind(TObj, PT);
 433     }
 434   }
 435   return PT;
 436 }
 437
 438 //=======================================================================
 439 //function : Translate Polygon2D
 440 //purpose  : Persistent -> Transient
 441 //=======================================================================
 442
 443 Handle(Poly_Polygon2D) MgtPoly::Translate
 444 (const Handle(PPoly_Polygon2D)& PObj,
 445  PTColStd_PersistentTransientMap& aMap)
 446 {
 447   Handle(Poly_Polygon2D) TP;
 448   if (!PObj.IsNull()) {
 449     if (aMap.IsBound(PObj)) {
 450 #ifdef MgtBRepSpeedDownCast
 451       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
 452       TP = (Handle(Poly_Polygon2D)&) aTrans;
 453 #else
 454       TP = Handle(Poly_Polygon2D)::DownCast(aMap.Find(PObj));
 455 #endif
 456     }
 457     else {
 458       // myNodes
 459       Handle(PColgp_HArray1OfPnt2d) PUVNodes = PObj->Nodes();
 460       TColgp_Array1OfPnt2d TUVNodes(PUVNodes->Lower(), PUVNodes->Upper());
 461       ArrayCopy(PUVNodes, TUVNodes);
 462
 463       // Constructor + Deflection
 464       TP = new Poly_Polygon2D(TUVNodes);
 465       TP->Deflection(PObj->Deflection());
 466       aMap.Bind(PObj, TP);
 467     }
 468   }
 469   return TP;
 470 }
 471
 472 //=======================================================================
 473 //function : Translate Polygon2D
 474 //purpose  : Transient -> Persistent
 475 //=======================================================================
 476
 477 Handle(PPoly_Polygon2D) MgtPoly::Translate
 478 (const Handle(Poly_Polygon2D)& TObj,
 479  PTColStd_TransientPersistentMap& aMap)
 480 {
 481   Handle(PPoly_Polygon2D) PT;
 482   if (!TObj.IsNull()) {
 483     if (aMap.IsBound(TObj)) {
 484 #ifdef MgtBRepSpeedDownCast
 485       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
 486       PT = (Handle(PPoly_Polygon2D)&) aPers;
 487 #else
 488       PT = Handle(PPoly_Polygon2D)::DownCast(aMap.Find(TObj));
 489 #endif
 490     }
 491     else {
 492       // myNodes
 493       const TColgp_Array1OfPnt2d& TUVNodes = TObj->Nodes();
 494       Handle(PColgp_HArray1OfPnt2d) PUVNodes =
 495         new PColgp_HArray1OfPnt2d(TUVNodes.Lower(),
 496                                   TUVNodes.Upper());
 497       PUVNodes = ArrayCopy(TUVNodes);
 498
 499       // constructor + Deflection
 500       PT = new PPoly_Polygon2D(PUVNodes, TObj->Deflection());
 501       aMap.Bind(TObj, PT);
 502     }
 503   }
 504   return PT;
 505 }
 506
 507 //=======================================================================
 508 //function : Translate PolygonOnTriangulation
 509 //purpose  : Persistent -> Transient
 510 //=======================================================================
 511
 512 Handle(Poly_PolygonOnTriangulation) MgtPoly::Translate
 513 (const Handle(PPoly_PolygonOnTriangulation)& PObj,
 514  PTColStd_PersistentTransientMap& aMap)
 515 {
 516   Handle(Poly_PolygonOnTriangulation) TP;
 517   if (!PObj.IsNull()) {
 518     if (aMap.IsBound(PObj)) {
 519 #ifdef MgtBRepSpeedDownCast
 520       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
 521       TP = (Handle(Poly_PolygonOnTriangulation)&) aTrans;
 522 #else
 523       TP = Handle(Poly_PolygonOnTriangulation)::DownCast(aMap.Find(PObj));
 524 #endif
 525     }
 526     else {
 527
 528       // myNodes
 529       Handle(PColStd_HArray1OfInteger) PNodes = PObj->Nodes();
 530       TColStd_Array1OfInteger TNodes(PNodes->Lower(), PNodes->Upper());
 531       ArrayCopy(PNodes, TNodes);
 532
 533       // myParameters
 534
 535       if (PObj->HasParameters()) {
 536         Handle(PColStd_HArray1OfReal) PParam = PObj->Parameters();
 537         TColStd_Array1OfReal TParam(PParam->Lower(), PParam->Upper());
 538         ArrayCopy(PParam, TParam);
 539
 540         // Constructor + Deflection
 541         TP = new Poly_PolygonOnTriangulation(TNodes, TParam);
 542         TP->Deflection(PObj->Deflection());
 543         aMap.Bind(PObj, TP);
 544       }
 545       else {
 546         TP = new Poly_PolygonOnTriangulation(TNodes);
 547         TP->Deflection(PObj->Deflection());
 548         aMap.Bind(PObj, TP);
 549       }
 550     }
 551   }
 552   return TP;
 553 }
 554
 555 //=======================================================================
 556 //function : Translate PolygonOnTriangulation
 557 //purpose  : Transient -> Persistent
 558 //=======================================================================
 559
 560 Handle(PPoly_PolygonOnTriangulation) MgtPoly::Translate
 561 (const Handle(Poly_PolygonOnTriangulation)& TObj,
 562  PTColStd_TransientPersistentMap& aMap)
 563 {
 564   Handle(PPoly_PolygonOnTriangulation) PT;
 565   if (!TObj.IsNull()) {
 566     if (aMap.IsBound(TObj)) {
 567 #ifdef MgtBRepSpeedDownCast
 568       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
 569       PT = (Handle(PPoly_PolygonOnTriangulation)&) aPers;
 570 #else
 571       PT = Handle(PPoly_PolygonOnTriangulation)::DownCast(aMap.Find(TObj));
 572 #endif
 573     }
 574     else {
 575       // myNodes
 576       const TColStd_Array1OfInteger& TNodes = TObj->Nodes();
 577       Handle(PColStd_HArray1OfInteger) PNodes =
 578         new PColStd_HArray1OfInteger(TNodes.Lower(),
 579                                      TNodes.Upper());
 580       PNodes = ArrayCopy(TNodes);
 581
 582       // myParameters
 583
 584       if (TObj->HasParameters()) {
 585         const TColStd_Array1OfReal& TParam = TObj->Parameters()->Array1();
 586         Handle(PColStd_HArray1OfReal) PParam =
 587           new PColStd_HArray1OfReal(TParam.Lower(), TParam.Upper());
 588         PParam = ArrayCopy(TParam);
 589         // constructor + Deflection
 590         PT = new PPoly_PolygonOnTriangulation(PNodes, TObj->Deflection(),
 591                                               PParam);
 592         aMap.Bind(TObj, PT);
 593
 594       }
 595       else {
 596         // constructor + Deflection
 597         PT = new PPoly_PolygonOnTriangulation(PNodes, TObj->Deflection());
 598         aMap.Bind(TObj, PT);
 599       }
 600     }
 601   }
 602   return PT;
 603 }