src/BRep/BRep_Builder.cxx

   1 // Created on: 1991-07-02
   2 // Created by: Remi LEQUETTE
   3 // Copyright (c) 1991-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17
  18 #include <BRep_Builder.hxx>
  19 #include <BRep_Curve3D.hxx>
  20 #include <BRep_CurveOn2Surfaces.hxx>
  21 #include <BRep_CurveOnClosedSurface.hxx>
  22 #include <BRep_GCurve.hxx>
  23 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
  24 #include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
  25 #include <BRep_PointOnCurve.hxx>
  26 #include <BRep_PointOnCurveOnSurface.hxx>
  27 #include <BRep_PointOnSurface.hxx>
  28 #include <BRep_Polygon3D.hxx>
  29 #include <BRep_PolygonOnClosedSurface.hxx>
  30 #include <BRep_PolygonOnClosedTriangulation.hxx>
  31 #include <BRep_PolygonOnSurface.hxx>
  32 #include <BRep_PolygonOnTriangulation.hxx>
  33 #include <BRep_TEdge.hxx>
  34 #include <Geom2d_Curve.hxx>
  35 #include <Geom_Curve.hxx>
  36 #include <Geom_Surface.hxx>
  37 #include <gp_Pnt.hxx>
  38 #include <gp_Pnt2d.hxx>
  39 #include <Poly_Polygon2D.hxx>
  40 #include <Poly_Polygon3D.hxx>
  41 #include <Poly_PolygonOnTriangulation.hxx>
  42 #include <Poly_Triangulation.hxx>
  43 #include <Precision.hxx>
  44 #include <Standard_DomainError.hxx>
  45 #include <Standard_NullObject.hxx>
  46 #include <TopLoc_Location.hxx>
  47 #include <TopoDS.hxx>
  48 #include <TopoDS_Edge.hxx>
  49 #include <TopoDS_Face.hxx>
  50 #include <TopoDS_Iterator.hxx>
  51 #include <TopoDS_LockedShape.hxx>
  52 #include <TopoDS_Vertex.hxx>
  53
  54 //=======================================================================
  55 //function : Auxiliary methods
  56 //purpose  :
  57 //=======================================================================
  58 //=======================================================================
  59 //function : UpdateCurves
  60 //purpose  : Insert a 3d curve <C> with location <L>
  61 //           in a list of curve representations <lcr>
  62 //=======================================================================
  63 static void UpdateCurves(BRep_ListOfCurveRepresentation& lcr,
  64                          const Handle(Geom_Curve)&       C,
  65                          const TopLoc_Location&          L)
  66 {
  67   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
  68   Handle(BRep_GCurve) GC;
  69   Standard_Real f = 0.,l = 0.;
  70
  71   while (itcr.More()) {
  72     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
  73     if (!GC.IsNull()) {
  74       GC->Range(f, l);
  75       if (GC->IsCurve3D()) break;
  76
  77     }
  78     itcr.Next();
  79   }
  80
  81   if (itcr.More()) {
  82     itcr.Value()->Curve3D(C);
  83     itcr.Value()->Location(L);
  84   }
  85   else {
  86     Handle(BRep_Curve3D) C3d = new BRep_Curve3D(C,L);
  87     // test if there is already a range
  88     if (!GC.IsNull()) {
  89       C3d->SetRange(f,l);
  90     }
  91     lcr.Append(C3d);
  92   }
  93
  94 }
  95
  96 //=======================================================================
  97 //function : UpdateCurves
  98 //purpose  : Insert a pcurve <C> on surface <S> with location <L>
  99 //           in a list of curve representations <lcr>
 100 //           Remove the pcurve on <S> from <lcr> if <C> is null
 101 //=======================================================================
 102
 103 static void UpdateCurves(BRep_ListOfCurveRepresentation& lcr,
 104                          const Handle(Geom2d_Curve)& C,
 105                          const Handle(Geom_Surface)& S,
 106                          const TopLoc_Location& L)
 107 {
 108   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 109   Handle(BRep_CurveRepresentation) cr;
 110   Handle(BRep_GCurve) GC;
 111   Standard_Real f = -Precision::Infinite(), l = Precision::Infinite();
 112   // search the range of the 3d curve
 113   // and remove any existing representation
 114
 115   while (itcr.More()) {
 116     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
 117     if (!GC.IsNull()) {
 118       if (GC->IsCurve3D()) {
 119 //      if (!C.IsNull()) { //xpu031198, edge degeneree
 120
 121         // xpu151298 : parameters can be setted for null curves
 122         //             see lbo & flo, to determine whether range is defined
 123         //             compare first and last parameters with default values.
 124         GC->Range(f, l);
 125       }
 126       if (GC->IsCurveOnSurface(S,L)) {
 127         // remove existing curve on surface
 128         // cr is used to keep a reference on the curve representation
 129         // this avoid deleting it as its content may be referenced by C or S
 130         cr = itcr.Value();
 131         lcr.Remove(itcr);
 132       }
 133       else {
 134         itcr.Next();
 135       }
 136     }
 137     else {
 138       itcr.Next();
 139     }
 140   }
 141
 142   if (!C.IsNull()) {
 143     Handle(BRep_CurveOnSurface) COS = new BRep_CurveOnSurface(C, S, L);
 144     Standard_Real aFCur = 0.0, aLCur = 0.0;
 145     COS->Range(aFCur, aLCur);
 146     if (!Precision::IsInfinite(f))
 147     {
 148       aFCur = f;
 149     }
 150
 151     if (!Precision::IsInfinite(l))
 152     {
 153       aLCur = l;
 154     }
 155
 156     COS->SetRange(aFCur, aLCur);
 157     lcr.Append(COS);
 158   }
 159 }
 160
 161 //=======================================================================
 162 //function : UpdateCurves
 163 //purpose  : Insert a pcurve <C> on surface <S> with location <L>
 164 //           in a list of curve representations <lcr>
 165 //           Remove the pcurve on <S> from <lcr> if <C> is null
 166 //=======================================================================
 167 static void UpdateCurves(BRep_ListOfCurveRepresentation& lcr,
 168                          const Handle(Geom2d_Curve)& C,
 169                          const Handle(Geom_Surface)& S,
 170                          const TopLoc_Location& L,
 171                          const gp_Pnt2d& Pf,
 172                          const gp_Pnt2d& Pl)
 173 {
 174   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 175   Handle(BRep_CurveRepresentation) cr;
 176   Handle(BRep_GCurve) GC;
 177   Standard_Real f = -Precision::Infinite(), l = Precision::Infinite();
 178
 179   // search the range of the 3d curve
 180   // and remove any existing representation
 181
 182   while (itcr.More()) {
 183     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
 184     if (!GC.IsNull()) {
 185       if (GC->IsCurve3D()) {
 186 //      if (!C.IsNull()) { //xpu031198, edge degeneree
 187
 188         // xpu151298 : parameters can be setted for null curves
 189         //             see lbo & flo, to determine whether range is defined
 190         //             compare first and last parameters with default values.
 191         GC->Range(f, l);
 192       }
 193       if (GC->IsCurveOnSurface(S,L)) {
 194         // remove existing curve on surface
 195         // cr is used to keep a reference on the curve representation
 196         // this avoid deleting it as its content may be referenced by C or S
 197         cr = itcr.Value();
 198         lcr.Remove(itcr);
 199       }
 200       else {
 201         itcr.Next();
 202       }
 203     }
 204     else {
 205       itcr.Next();
 206     }
 207   }
 208
 209   if (! C.IsNull()) {
 210     Handle(BRep_CurveOnSurface) COS = new BRep_CurveOnSurface(C,S,L);
 211     Standard_Real aFCur = 0.0, aLCur = 0.0;
 212     COS->Range(aFCur, aLCur);
 213     if (!Precision::IsInfinite(f))
 214     {
 215       aFCur = f;
 216     }
 217
 218     if (!Precision::IsInfinite(l))
 219     {
 220       aLCur = l;
 221     }
 222
 223     COS->SetRange(aFCur, aLCur);
 224     COS->SetUVPoints(Pf, Pl);
 225     lcr.Append(COS);
 226   }
 227 }
 228
 229 //=======================================================================
 230 //function : UpdateCurves
 231 //purpose  : Insert two pcurves <C1,C2> on surface <S> with location <L>
 232 //           in a list of curve representations <lcr>
 233 //           Remove the pcurves on <S> from <lcr> if <C1> or <C2> is null
 234 //=======================================================================
 235
 236 static void UpdateCurves(BRep_ListOfCurveRepresentation& lcr,
 237                          const Handle(Geom2d_Curve)& C1,
 238                          const Handle(Geom2d_Curve)& C2,
 239                          const Handle(Geom_Surface)& S,
 240                          const TopLoc_Location& L)
 241 {
 242   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 243   Handle(BRep_CurveRepresentation) cr;
 244   Handle(BRep_GCurve) GC;
 245   Standard_Real f = -Precision::Infinite(), l = Precision::Infinite();
 246
 247   while (itcr.More()) {
 248     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
 249     if ( !GC.IsNull() ) {
 250       if (GC->IsCurve3D()) {
 251         GC->Range(f,l);
 252       }
 253       Standard_Boolean iscos = GC->IsCurveOnSurface(S,L);
 254       if (iscos) break;
 255     }
 256     itcr.Next();
 257   }
 258
 259   if (itcr.More())  {
 260     // cr is used to keep a reference on the curve representation
 261     // this avoid deleting it as its content may be referenced by C or S
 262     cr = itcr.Value();
 263     lcr.Remove(itcr);
 264   }
 265
 266   if ( !C1.IsNull() && !C2.IsNull() ) {
 267     Handle(BRep_CurveOnClosedSurface) COS = new
 268                     BRep_CurveOnClosedSurface(C1,C2,S,L,GeomAbs_C0);
 269     Standard_Real aFCur = 0.0, aLCur = 0.0;
 270     COS->Range(aFCur, aLCur);
 271     if (!Precision::IsInfinite(f))
 272     {
 273       aFCur = f;
 274     }
 275
 276     if (!Precision::IsInfinite(l))
 277     {
 278       aLCur = l;
 279     }
 280
 281     COS->SetRange(aFCur, aLCur);
 282     lcr.Append(COS);
 283   }
 284 }
 285
 286 //=======================================================================
 287 //function : UpdateCurves
 288 //purpose  : Insert two pcurves <C1,C2> on surface <S> with location <L>
 289 //           in a list of curve representations <lcr>
 290 //           Remove the pcurves on <S> from <lcr> if <C1> or <C2> is null
 291 //=======================================================================
 292 static void UpdateCurves(BRep_ListOfCurveRepresentation& lcr,
 293                          const Handle(Geom2d_Curve)& C1,
 294                          const Handle(Geom2d_Curve)& C2,
 295                          const Handle(Geom_Surface)& S,
 296                          const TopLoc_Location& L,
 297                          const gp_Pnt2d& Pf,
 298                          const gp_Pnt2d& Pl)
 299 {
 300   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 301   Handle(BRep_CurveRepresentation) cr;
 302   Handle(BRep_GCurve) GC;
 303   Standard_Real f = -Precision::Infinite(), l = Precision::Infinite();
 304
 305   while (itcr.More()) {
 306     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
 307     if ( !GC.IsNull() ) {
 308       if (GC->IsCurve3D()) {
 309         GC->Range(f,l);
 310       }
 311       Standard_Boolean iscos = GC->IsCurveOnSurface(S,L);
 312       if (iscos) break;
 313     }
 314     itcr.Next();
 315   }
 316
 317   if (itcr.More())  {
 318     // cr is used to keep a reference on the curve representation
 319     // this avoid deleting it as its content may be referenced by C or S
 320     cr = itcr.Value();
 321     lcr.Remove(itcr);
 322   }
 323
 324   if ( !C1.IsNull() && !C2.IsNull() ) {
 325     Handle(BRep_CurveOnClosedSurface) COS = new
 326                     BRep_CurveOnClosedSurface(C1,C2,S,L,GeomAbs_C0);
 327     Standard_Real aFCur = 0.0, aLCur = 0.0;
 328     COS->Range(aFCur, aLCur);
 329     if (!Precision::IsInfinite(f))
 330     {
 331       aFCur = f;
 332     }
 333
 334     if (!Precision::IsInfinite(l))
 335     {
 336       aLCur = l;
 337     }
 338
 339     COS->SetRange(aFCur, aLCur);
 340     COS->SetUVPoints2(Pf, Pl);
 341     lcr.Append(COS);
 342   }
 343 }
 344
 345
 346 static void UpdateCurves(BRep_ListOfCurveRepresentation& lcr,
 347                          const Handle(Geom_Surface)& S1,
 348                          const Handle(Geom_Surface)& S2,
 349                          const TopLoc_Location& L1,
 350                          const TopLoc_Location& L2,
 351                          const GeomAbs_Shape C)
 352 {
 353   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 354   while (itcr.More()) {
 355     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
 356     Standard_Boolean isregu = cr->IsRegularity(S1,S2,L1,L2);
 357     if (isregu) break;
 358     itcr.Next();
 359   }
 360
 361   if (itcr.More()) {
 362     Handle(BRep_CurveRepresentation)& cr = itcr.Value();
 363     cr->Continuity(C);
 364   }
 365   else {
 366     Handle(BRep_CurveOn2Surfaces) COS = new BRep_CurveOn2Surfaces
 367       (S1,S2,L1,L2,C);
 368     lcr.Append(COS);
 369   }
 370 }
 371
 372 static void UpdatePoints(BRep_ListOfPointRepresentation& lpr,
 373                          Standard_Real p,
 374                          const Handle(Geom_Curve)& C,
 375                          const TopLoc_Location& L)
 376 {
 377   BRep_ListIteratorOfListOfPointRepresentation itpr(lpr);
 378   while (itpr.More()) {
 379     const Handle(BRep_PointRepresentation)& pr = itpr.Value();
 380     Standard_Boolean isponc = pr->IsPointOnCurve(C,L);
 381     if (isponc) break;
 382     itpr.Next();
 383   }
 384
 385   if (itpr.More()) {
 386     Handle(BRep_PointRepresentation)& pr = itpr.Value();
 387     pr->Parameter(p);
 388   }
 389   else {
 390     Handle(BRep_PointOnCurve) POC = new BRep_PointOnCurve(p,C,L);
 391     lpr.Append(POC);
 392   }
 393 }
 394
 395 static void UpdatePoints(BRep_ListOfPointRepresentation& lpr,
 396                          Standard_Real p,
 397                          const Handle(Geom2d_Curve)& PC,
 398                          const Handle(Geom_Surface)& S,
 399                          const TopLoc_Location& L)
 400 {
 401   BRep_ListIteratorOfListOfPointRepresentation itpr(lpr);
 402   while (itpr.More()) {
 403     const Handle(BRep_PointRepresentation)& pr = itpr.Value();
 404     Standard_Boolean isponcons = pr->IsPointOnCurveOnSurface(PC,S,L);
 405     if (isponcons) break;
 406     itpr.Next();
 407   }
 408
 409   if (itpr.More()) {
 410     Handle(BRep_PointRepresentation)& pr = itpr.Value();
 411     pr->Parameter(p);
 412   }
 413   else {
 414     Handle(BRep_PointOnCurveOnSurface) POCS =
 415       new BRep_PointOnCurveOnSurface(p,PC,S,L);
 416     lpr.Append(POCS);
 417   }
 418 }
 419
 420
 421 static void UpdatePoints(BRep_ListOfPointRepresentation& lpr,
 422                          Standard_Real p1,
 423                          Standard_Real p2,
 424                          const Handle(Geom_Surface)& S,
 425                          const TopLoc_Location& L)
 426 {
 427   BRep_ListIteratorOfListOfPointRepresentation itpr(lpr);
 428   while (itpr.More()) {
 429     const Handle(BRep_PointRepresentation)& pr = itpr.Value();
 430     Standard_Boolean ispons = pr->IsPointOnSurface(S,L);
 431     if (ispons) break;
 432     itpr.Next();
 433   }
 434
 435   if (itpr.More()) {
 436     Handle(BRep_PointRepresentation)& pr = itpr.Value();
 437     pr->Parameter(p1);
 438 //    pr->Parameter(p2); // skv
 439     pr->Parameter2(p2); // skv
 440   }
 441   else {
 442     Handle(BRep_PointOnSurface) POS = new BRep_PointOnSurface(p1,p2,S,L);
 443     lpr.Append(POS);
 444   }
 445 }
 446
 447
 448 //=======================================================================
 449 //function : MakeFace
 450 //purpose  :
 451 //=======================================================================
 452
 453 void  BRep_Builder::MakeFace(TopoDS_Face& F,
 454                              const Handle(Geom_Surface)& S,
 455                              const Standard_Real Tol) const
 456 {
 457   Handle(BRep_TFace) TF = new BRep_TFace();
 458   if(!F.IsNull() && F.Locked())
 459   {
 460     throw TopoDS_LockedShape("BRep_Builder::MakeFace");
 461   }
 462   TF->Surface(S);
 463   TF->Tolerance(Tol);
 464   MakeShape(F,TF);
 465 }
 466
 467
 468 //=======================================================================
 469 //function : MakeFace
 470 //purpose  :
 471 //=======================================================================
 472
 473 void  BRep_Builder::MakeFace(TopoDS_Face&                      F,
 474                              const Handle(Poly_Triangulation)& T) const
 475 {
 476   Handle(BRep_TFace) TF = new BRep_TFace();
 477   if(!F.IsNull() && F.Locked())
 478   {
 479     throw TopoDS_LockedShape("BRep_Builder::MakeFace");
 480   }
 481   TF->Triangulation(T);
 482   MakeShape(F, TF);
 483 }
 484
 485
 486 //=======================================================================
 487 //function : MakeFace
 488 //purpose  :
 489 //=======================================================================
 490
 491 void  BRep_Builder::MakeFace(TopoDS_Face& F,
 492                              const Handle(Geom_Surface)& S,
 493                              const TopLoc_Location& L,
 494                              const Standard_Real Tol) const
 495 {
 496   Handle(BRep_TFace) TF = new BRep_TFace();
 497   if(!F.IsNull() && F.Locked())
 498   {
 499     throw TopoDS_LockedShape("BRep_Builder::MakeFace");
 500   }
 501   TF->Surface(S);
 502   TF->Tolerance(Tol);
 503   TF->Location(L);
 504   MakeShape(F,TF);
 505 }
 506
 507
 508 //=======================================================================
 509 //function : UpdateFace
 510 //purpose  :
 511 //=======================================================================
 512
 513 void  BRep_Builder::UpdateFace(const TopoDS_Face& F,
 514                                const Handle(Geom_Surface)& S,
 515                                const TopLoc_Location& L,
 516                                const Standard_Real Tol) const
 517 {
 518   const Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &F.TShape());
 519   if(TF->Locked())
 520   {
 521     throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
 522   }
 523   TF->Surface(S);
 524   TF->Tolerance(Tol);
 525   TF->Location(L.Predivided(F.Location()));
 526   F.TShape()->Modified(Standard_True);
 527 }
 528
 529
 530 //=======================================================================
 531 //function : UpdateFace
 532 //purpose  :
 533 //=======================================================================
 534
 535 void  BRep_Builder::UpdateFace(const TopoDS_Face& F,
 536                                const Handle(Poly_Triangulation)& T) const
 537 {
 538   const Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &F.TShape());
 539   if(TF->Locked())
 540   {
 541     throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
 542   }
 543   TF->Triangulation(T);
 544   F.TShape()->Modified(Standard_True);
 545 }
 546
 547
 548 //=======================================================================
 549 //function : UpdateFace
 550 //purpose  :
 551 //=======================================================================
 552
 553 void  BRep_Builder::UpdateFace(const TopoDS_Face& F,
 554                                const Standard_Real Tol) const
 555 {
 556   const Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &F.TShape());
 557   if(TF->Locked())
 558   {
 559     throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
 560   }
 561   TF->Tolerance(Tol);
 562   F.TShape()->Modified(Standard_True);
 563 }
 564
 565
 566 //=======================================================================
 567 //function : NaturalRestriction
 568 //purpose  :
 569 //=======================================================================
 570
 571 void  BRep_Builder::NaturalRestriction(const TopoDS_Face& F,
 572                                        const Standard_Boolean N) const
 573 {
 574   const Handle(BRep_TFace)& TF = (*((Handle(BRep_TFace)*) &F.TShape()));
 575   if(TF->Locked())
 576   {
 577     throw TopoDS_LockedShape("BRep_Builder::NaturalRestriction");
 578   }
 579   TF->NaturalRestriction(N);
 580   F.TShape()->Modified(Standard_True);
 581 }
 582
 583
 584 //=======================================================================
 585 //function : MakeEdge
 586 //purpose  : make undefined edge
 587 //=======================================================================
 588
 589 void  BRep_Builder::MakeEdge(TopoDS_Edge& E) const
 590 {
 591   Handle(BRep_TEdge) TE = new BRep_TEdge();
 592   if(!E.IsNull() && E.Locked())
 593   {
 594     throw TopoDS_LockedShape("BRep_Builder::MakeEdge");
 595   }
 596   MakeShape(E,TE);
 597 }
 598
 599
 600 //=======================================================================
 601 //function : UpdateEdge
 602 //purpose  :
 603 //=======================================================================
 604
 605 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 606                                const Handle(Geom_Curve)& C,
 607                                const TopLoc_Location& L,
 608                                const Standard_Real Tol) const
 609 {
 610   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 611   if(TE->Locked())
 612   {
 613     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 614   }
 615   const TopLoc_Location l = L.Predivided(E.Location());
 616
 617   UpdateCurves(TE->ChangeCurves(),C,l);
 618
 619   TE->UpdateTolerance(Tol);
 620   TE->Modified(Standard_True);
 621 }
 622
 623
 624 //=======================================================================
 625 //function : UpdateEdge
 626 //purpose  :
 627 //=======================================================================
 628
 629 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 630                                const Handle(Geom2d_Curve)& C,
 631                                const Handle(Geom_Surface)& S,
 632                                const TopLoc_Location& L,
 633                                const Standard_Real Tol) const
 634 {
 635   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 636   if(TE->Locked())
 637   {
 638     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 639   }
 640   const TopLoc_Location l = L.Predivided(E.Location());
 641
 642   UpdateCurves(TE->ChangeCurves(),C,S,l);
 643
 644   TE->UpdateTolerance(Tol);
 645   TE->Modified(Standard_True);
 646 }
 647
 648
 649 //=======================================================================
 650 //function : UpdateEdge
 651 //purpose  : for the second format (for XML Persistence)
 652 //=======================================================================
 653
 654 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 655                                const Handle(Geom2d_Curve)& C,
 656                                const Handle(Geom_Surface)& S,
 657                                const TopLoc_Location& L,
 658                                const Standard_Real Tol,
 659                                const gp_Pnt2d& Pf,
 660                                const gp_Pnt2d& Pl) const
 661 {
 662   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 663   if(TE->Locked())
 664   {
 665     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 666   }
 667   const TopLoc_Location l = L.Predivided(E.Location());
 668
 669   UpdateCurves(TE->ChangeCurves(),C,S,l,Pf,Pl);
 670
 671   TE->UpdateTolerance(Tol);
 672   TE->Modified(Standard_True);
 673 }
 674
 675
 676 //=======================================================================
 677 //function : UpdateEdge
 678 //purpose  :
 679 //=======================================================================
 680
 681 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 682                                const Handle(Geom2d_Curve)& C1,
 683                                const Handle(Geom2d_Curve)& C2,
 684                                const Handle(Geom_Surface)& S,
 685                                const TopLoc_Location& L,
 686                                const Standard_Real Tol) const
 687 {
 688   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 689   if(TE->Locked())
 690   {
 691     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 692   }
 693   const TopLoc_Location l = L.Predivided(E.Location());
 694
 695   UpdateCurves(TE->ChangeCurves(),C1,C2,S,l);
 696
 697   TE->UpdateTolerance(Tol);
 698   TE->Modified(Standard_True);
 699 }
 700
 701
 702 //=======================================================================
 703 //function : UpdateEdge
 704 //purpose  : for the second format (for XML Persistence)
 705 //=======================================================================
 706
 707 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 708                                const Handle(Geom2d_Curve)& C1,
 709                                const Handle(Geom2d_Curve)& C2,
 710                                const Handle(Geom_Surface)& S,
 711                                const TopLoc_Location& L,
 712                                const Standard_Real Tol,
 713                                const gp_Pnt2d& Pf,
 714                                const gp_Pnt2d& Pl) const
 715 {
 716   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 717   if(TE->Locked())
 718   {
 719     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 720   }
 721   const TopLoc_Location l = L.Predivided(E.Location());
 722
 723   UpdateCurves(TE->ChangeCurves(),C1,C2,S,l,Pf,Pl);
 724
 725   TE->UpdateTolerance(Tol);
 726   TE->Modified(Standard_True);
 727 }
 728
 729
 730 //=======================================================================
 731 //function : UpdateEdge
 732 //purpose  :
 733 //=======================================================================
 734
 735 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 736                                const Handle(Poly_Polygon3D)& P,
 737                                const TopLoc_Location& L) const
 738 {
 739   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 740   if(TE->Locked())
 741   {
 742     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 743   }
 744   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
 745   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 746
 747   while (itcr.More())
 748   {
 749     if (itcr.Value()->IsPolygon3D())
 750     {
 751       if (P.IsNull())
 752         lcr.Remove(itcr);
 753       else
 754         itcr.Value()->Polygon3D(P);
 755       TE->Modified(Standard_True);
 756       return;
 757     }
 758     itcr.Next();
 759   }
 760
 761   const TopLoc_Location l = L.Predivided(E.Location());
 762   Handle(BRep_Polygon3D) P3d = new BRep_Polygon3D(P,l);
 763   lcr.Append(P3d);
 764
 765   TE->Modified(Standard_True);
 766 }
 767
 768
 769 //=======================================================================
 770 //function : UpdateEdge
 771 //purpose  :
 772 //=======================================================================
 773
 774 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 775                                const Handle(Poly_PolygonOnTriangulation)& P,
 776                                const Handle(Poly_Triangulation)& T,
 777                                const TopLoc_Location& L) const
 778 {
 779   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 780   if(TE->Locked())
 781   {
 782     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 783   }
 784   const TopLoc_Location l = L.Predivided(E.Location());
 785
 786   Standard_Boolean isModified = Standard_False;
 787
 788   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
 789   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 790   Handle(BRep_CurveRepresentation) cr;
 791
 792   while (itcr.More())
 793   {
 794     if (itcr.Value()->IsPolygonOnTriangulation(T,l))
 795     {
 796       // cr is used to keep a reference on the curve representation
 797       // this avoid deleting it as its content may be referenced by T
 798       cr = itcr.Value();
 799       lcr.Remove(itcr);
 800       isModified = Standard_True;
 801       break;
 802     }
 803     itcr.Next();
 804   }
 805
 806   if (!P.IsNull())
 807   {
 808     Handle(BRep_PolygonOnTriangulation) PT =
 809       new BRep_PolygonOnTriangulation(P,T,l);
 810     lcr.Append(PT);
 811     isModified = Standard_True;
 812   }
 813
 814   if (isModified)
 815     TE->Modified(Standard_True);
 816 }
 817
 818
 819 //=======================================================================
 820 //function : UpdateEdge
 821 //purpose  :
 822 //=======================================================================
 823
 824 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 825                                const Handle(Poly_PolygonOnTriangulation)& P1,
 826                                const Handle(Poly_PolygonOnTriangulation)& P2,
 827                                const Handle(Poly_Triangulation)& T,
 828                                const TopLoc_Location& L) const
 829 {
 830   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 831   if(TE->Locked())
 832   {
 833     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 834   }
 835   const TopLoc_Location l = L.Predivided(E.Location());
 836
 837   Standard_Boolean isModified = Standard_False;
 838
 839   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
 840   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 841   Handle(BRep_CurveRepresentation) cr;
 842
 843   while (itcr.More())
 844   {
 845     if (itcr.Value()->IsPolygonOnTriangulation(T,l)) //szv:was L
 846     {
 847       // cr is used to keep a reference on the curve representation
 848       // this avoid deleting it as its content may be referenced by T
 849       cr = itcr.Value();
 850       lcr.Remove(itcr);
 851       isModified = Standard_True;
 852       break;
 853     }
 854     itcr.Next();
 855   }
 856
 857   if (!P1.IsNull() && !P2.IsNull())
 858   {
 859     Handle(BRep_PolygonOnClosedTriangulation) PT =
 860       new BRep_PolygonOnClosedTriangulation(P1,P2,T,l);
 861     lcr.Append(PT);
 862     isModified = Standard_True;
 863   }
 864
 865   if (isModified)
 866     TE->Modified(Standard_True);
 867 }
 868
 869 //=======================================================================
 870 //function : UpdateEdge
 871 //purpose  :
 872 //=======================================================================
 873
 874 void  BRep_Builder::UpdateEdge(const TopoDS_Edge&            E,
 875                                const Handle(Poly_Polygon2D)& P,
 876                                const TopoDS_Face&            F) const
 877 {
 878   TopLoc_Location l;
 879   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
 880   UpdateEdge(E, P, S, l);
 881 }
 882
 883 //=======================================================================
 884 //function : UpdateEdge
 885 //purpose  :
 886 //=======================================================================
 887
 888 void  BRep_Builder::UpdateEdge(const TopoDS_Edge&            E,
 889                                const Handle(Poly_Polygon2D)& P,
 890                                const Handle(Geom_Surface)&   S,
 891                                const TopLoc_Location&        L) const
 892 {
 893   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 894   if(TE->Locked())
 895   {
 896     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 897   }
 898   TopLoc_Location l = L.Predivided(E.Location());
 899
 900   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
 901   Handle(BRep_CurveRepresentation) cr;
 902
 903   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 904   while (itcr.More()) {
 905     if (itcr.Value()->IsPolygonOnSurface(S, l)) break;
 906     itcr.Next();
 907   }
 908
 909   if (itcr.More()) {
 910     // cr is used to keep a reference on the curve representation
 911     // this avoid deleting it as its content may be referenced by T
 912     cr = itcr.Value();
 913     lcr.Remove(itcr);
 914   }
 915
 916   if (!P.IsNull()) {
 917     Handle(BRep_PolygonOnSurface) PS =
 918       new BRep_PolygonOnSurface(P, S, l);
 919     lcr.Append(PS);
 920   }
 921
 922   TE->Modified(Standard_True);
 923 }
 924
 925 //=======================================================================
 926 //function : UpdateEdge
 927 //purpose  :
 928 //=======================================================================
 929
 930 void  BRep_Builder::UpdateEdge(const TopoDS_Edge&            E,
 931                                const Handle(Poly_Polygon2D)& P1,
 932                                const Handle(Poly_Polygon2D)& P2,
 933                                const TopoDS_Face&            F) const
 934 {
 935   TopLoc_Location l;
 936   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
 937   UpdateEdge(E, P1, P2, S, l);
 938 }
 939
 940 //=======================================================================
 941 //function : UpdateEdge
 942 //purpose  :
 943 //=======================================================================
 944
 945 void  BRep_Builder::UpdateEdge(const TopoDS_Edge&            E,
 946                                const Handle(Poly_Polygon2D)& P1,
 947                                const Handle(Poly_Polygon2D)& P2,
 948                                const Handle(Geom_Surface)&   S,
 949                                const TopLoc_Location&        L) const
 950 {
 951   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 952   if(TE->Locked())
 953   {
 954     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 955   }
 956   TopLoc_Location l = L.Predivided(E.Location());
 957
 958   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
 959   Handle(BRep_CurveRepresentation) cr;
 960
 961   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
 962   while (itcr.More()) {
 963     if (itcr.Value()->IsPolygonOnSurface(S, l)) break;
 964     itcr.Next();
 965   }
 966
 967   if (itcr.More()) {
 968     // cr is used to keep a reference on the curve representation
 969     // this avoid deleting it as its content may be referenced by T
 970     cr = itcr.Value();
 971     lcr.Remove(itcr);
 972   }
 973
 974   if (!P1.IsNull() && !P2.IsNull()) {
 975     Handle(BRep_PolygonOnClosedSurface) PS =
 976       new BRep_PolygonOnClosedSurface(P1, P2, S, TopLoc_Location());
 977     lcr.Append(PS);
 978   }
 979
 980   TE->Modified(Standard_True);
 981 }
 982
 983 //=======================================================================
 984 //function : UpdateEdge
 985 //purpose  :
 986 //=======================================================================
 987
 988 void  BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
 989                                const Standard_Real Tol) const
 990 {
 991   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
 992   if(TE->Locked())
 993   {
 994     throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
 995   }
 996   TE->UpdateTolerance(Tol);
 997   TE->Modified(Standard_True);
 998 }
 999
1000
1001 //=======================================================================
1002 //function : Continuity
1003 //purpose  :
1004 //=======================================================================
1005
1006 void  BRep_Builder::Continuity(const TopoDS_Edge& E,
1007                                const TopoDS_Face& F1,
1008                                const TopoDS_Face& F2,
1009                                const GeomAbs_Shape C) const
1010 {
1011   TopLoc_Location l1,l2;
1012   const Handle(Geom_Surface)& S1 = BRep_Tool::Surface(F1,l1);
1013   const Handle(Geom_Surface)& S2 = BRep_Tool::Surface(F2,l2);
1014   Continuity(E,S1,S2,l1,l2,C);
1015 }
1016
1017 //=======================================================================
1018 //function : Continuity
1019 //purpose  :
1020 //=======================================================================
1021
1022 void  BRep_Builder::Continuity(const TopoDS_Edge& E,
1023                                const Handle(Geom_Surface)& S1,
1024                                const Handle(Geom_Surface)& S2,
1025                                const TopLoc_Location& L1,
1026                                const TopLoc_Location& L2,
1027                                const GeomAbs_Shape C)const
1028 {
1029   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1030   if(TE->Locked())
1031   {
1032     throw TopoDS_LockedShape("BRep_Builder::Continuity");
1033   }
1034   const TopLoc_Location l1 = L1.Predivided(E.Location());
1035   const TopLoc_Location l2 = L2.Predivided(E.Location());
1036
1037   UpdateCurves(TE->ChangeCurves(),S1,S2,l1,l2,C);
1038
1039   TE->Modified(Standard_True);
1040 }
1041
1042 //=======================================================================
1043 //function : SameParameter
1044 //purpose  :
1045 //=======================================================================
1046
1047 void  BRep_Builder::SameParameter(const TopoDS_Edge& E,
1048                                   const Standard_Boolean S) const
1049 {
1050   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1051   if(TE->Locked())
1052   {
1053     throw TopoDS_LockedShape("BRep_Builder::SameParameter");
1054   }
1055   TE->SameParameter(S);
1056   TE->Modified(Standard_True);
1057 }
1058
1059 //=======================================================================
1060 //function : SameRange
1061 //purpose  :
1062 //=======================================================================
1063
1064 void  BRep_Builder::SameRange(const TopoDS_Edge& E,
1065                               const Standard_Boolean S) const
1066 {
1067   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1068   if(TE->Locked())
1069   {
1070     throw TopoDS_LockedShape("BRep_Builder::SameRange");
1071   }
1072   TE->SameRange(S);
1073   TE->Modified(Standard_True);
1074 }
1075
1076 //=======================================================================
1077 //function : Degenerated
1078 //purpose  :
1079 //=======================================================================
1080
1081 void  BRep_Builder::Degenerated(const TopoDS_Edge& E,
1082                                 const Standard_Boolean D) const
1083 {
1084   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1085   if(TE->Locked())
1086   {
1087     throw TopoDS_LockedShape("BRep_Builder::Degenerated");
1088   }
1089   TE->Degenerated(D);
1090   if (D) {
1091     // set a null 3d curve
1092     UpdateCurves(TE->ChangeCurves(),Handle(Geom_Curve)(),E.Location());
1093   }
1094   TE->Modified(Standard_True);
1095 }
1096
1097
1098 //=======================================================================
1099 //function : Range
1100 //purpose  :
1101 //=======================================================================
1102
1103 void  BRep_Builder::Range(const TopoDS_Edge&  E,
1104                           const Standard_Real First,
1105                           const Standard_Real Last,
1106                           const Standard_Boolean Only3d) const
1107 {
1108   //  set the range to all the representations if Only3d=FALSE
1109   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1110   if(TE->Locked())
1111   {
1112     throw TopoDS_LockedShape("BRep_Builder::Range");
1113   }
1114   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1115   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1116   Handle(BRep_GCurve) GC;
1117
1118   while (itcr.More()) {
1119     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1120     if (!GC.IsNull() && (!Only3d || GC->IsCurve3D()))
1121       GC->SetRange(First,Last);
1122     itcr.Next();
1123   }
1124
1125   TE->Modified(Standard_True);
1126 }
1127
1128
1129 //=======================================================================
1130 //function : Range
1131 //purpose  :
1132 //=======================================================================
1133
1134 void  BRep_Builder::Range(const TopoDS_Edge& E,
1135                           const Handle(Geom_Surface)& S,
1136                           const TopLoc_Location& L,
1137                           const Standard_Real First,
1138                           const Standard_Real Last) const
1139 {
1140   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1141   if(TE->Locked())
1142   {
1143     throw TopoDS_LockedShape("BRep_Builder::Range");
1144   }
1145   const TopLoc_Location l = L.Predivided(E.Location());
1146
1147   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1148   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1149   Handle(BRep_GCurve) GC;
1150
1151   while (itcr.More()) {
1152     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1153     if (!GC.IsNull() && GC->IsCurveOnSurface(S,l))
1154     {
1155       GC->SetRange(First,Last);
1156       break;
1157     }
1158     itcr.Next();
1159   }
1160
1161   if (!itcr.More())
1162     throw Standard_DomainError("BRep_Builder::Range, no pcurve");
1163
1164   TE->Modified(Standard_True);
1165 }
1166
1167
1168 //=======================================================================
1169 //function : Transfert
1170 //purpose  :
1171 //=======================================================================
1172
1173 void  BRep_Builder::Transfert(const TopoDS_Edge& Ein,
1174                               const TopoDS_Edge& Eout) const
1175 {
1176   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &Ein.TShape());
1177   const Standard_Real tol = TE->Tolerance();
1178
1179   const BRep_ListOfCurveRepresentation& lcr = TE->Curves();
1180   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1181
1182   while (itcr.More()) {
1183
1184     const Handle(BRep_CurveRepresentation)& CR = itcr.Value();
1185
1186     if (CR->IsCurveOnSurface()) {
1187       UpdateEdge(Eout,
1188                  CR->PCurve(),
1189                  CR->Surface(),
1190                  Ein.Location() * CR->Location(),tol);
1191     }
1192
1193     else if (CR->IsCurveOnClosedSurface()) {
1194       UpdateEdge(Eout,
1195                  CR->PCurve(),
1196                  CR->PCurve2(),
1197                  CR->Surface(),
1198                  Ein.Location() * CR->Location(),tol);
1199     }
1200
1201     if (CR->IsRegularity()) {
1202       Continuity(Eout,
1203                  CR->Surface(),
1204                  CR->Surface2(),
1205                  Ein.Location() * CR->Location(),
1206                  Ein.Location() * CR->Location2(),
1207                  CR->Continuity());
1208     }
1209
1210     itcr.Next();
1211   }
1212 }
1213
1214
1215 //=======================================================================
1216 //function : UpdateVertex
1217 //purpose  : update vertex with 3d point
1218 //=======================================================================
1219
1220 void  BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1221                                  const gp_Pnt& P,
1222                                  const Standard_Real Tol) const
1223 {
1224   const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1225   if(TV->Locked())
1226   {
1227     throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1228   }
1229   TV->Pnt(P.Transformed(V.Location().Inverted().Transformation()));
1230   TV->UpdateTolerance(Tol);
1231   TV->Modified(Standard_True);
1232 }
1233
1234
1235 //=======================================================================
1236 //function : UpdateVertex
1237 //purpose  : update vertex with parameter on edge
1238 //=======================================================================
1239
1240 void  BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1241                                  const Standard_Real Par,
1242                                  const TopoDS_Edge& E,
1243                                  const Standard_Real Tol) const
1244 {
1245   if (Precision::IsPositiveInfinite(Par) ||
1246       Precision::IsNegativeInfinite(Par))
1247     throw Standard_DomainError("BRep_Builder::Infinite parameter");
1248
1249   const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1250   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1251
1252   if(TV->Locked() || TE->Locked())
1253   {
1254     throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1255   }
1256
1257   TopLoc_Location L = E.Location().Predivided(V.Location());
1258
1259   // Search the vertex in the edge
1260   TopAbs_Orientation ori = TopAbs_INTERNAL;
1261
1262   TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
1263
1264   // if the edge has no vertices
1265   // and is degenerated use the vertex orientation
1266   // RLE, june 94
1267
1268   if (!itv.More() && TE->Degenerated())
1269     ori = V.Orientation();
1270
1271   while (itv.More()) {
1272     const TopoDS_Shape& Vcur = itv.Value();
1273     if (V.IsSame(Vcur)) {
1274       ori = Vcur.Orientation();
1275       if (ori == V.Orientation()) break;
1276     }
1277     itv.Next();
1278   }
1279
1280   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1281   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1282   Handle(BRep_GCurve) GC;
1283
1284   while (itcr.More()) {
1285     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1286     if (!GC.IsNull()) {
1287       if (ori == TopAbs_FORWARD)
1288         GC->First(Par);
1289       else if (ori == TopAbs_REVERSED)
1290         GC->Last(Par);
1291       else {
1292         BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1293         const TopLoc_Location& GCloc = GC->Location();
1294         TopLoc_Location LGCloc = L*GCloc;
1295         if (GC->IsCurve3D()) {
1296           const Handle(Geom_Curve)& GC3d = GC->Curve3D();
1297           UpdatePoints(lpr,Par,GC3d,LGCloc);
1298         }
1299         else if (GC->IsCurveOnSurface()) {
1300           const Handle(Geom2d_Curve)& GCpc = GC->PCurve();
1301           const Handle(Geom_Surface)& GCsu = GC->Surface();
1302           UpdatePoints(lpr,Par,GCpc,GCsu,LGCloc);
1303         }
1304       }
1305     }
1306     itcr.Next();
1307   }
1308
1309   if ((ori != TopAbs_FORWARD) && (ori != TopAbs_REVERSED))
1310     TV->Modified(Standard_True);
1311   TV->UpdateTolerance(Tol);
1312   TE->Modified(Standard_True);
1313 }
1314
1315
1316 //=======================================================================
1317 //function : UpdateVertex
1318 //purpose  : update vertex with parameter on edge on face
1319 //=======================================================================
1320
1321 void  BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1322                                  const Standard_Real  Par,
1323                                  const TopoDS_Edge&   E,
1324                                  const Handle(Geom_Surface)& S,
1325                                  const TopLoc_Location& L,
1326                                  const Standard_Real  Tol) const
1327 {
1328   if (Precision::IsPositiveInfinite(Par) ||
1329       Precision::IsNegativeInfinite(Par))
1330     throw Standard_DomainError("BRep_Builder::Infinite parameter");
1331
1332   // Find the curve representation
1333   TopLoc_Location l = L.Predivided(V.Location());
1334
1335   const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1336   const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1337
1338   if(TV->Locked() || TE->Locked())
1339   {
1340     throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1341   }
1342
1343   // Search the vertex in the edge
1344   TopAbs_Orientation ori = TopAbs_INTERNAL;
1345
1346   TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
1347
1348   // if the edge has no vertices
1349   // and is degenerated use the vertex orientation
1350   // RLE, june 94
1351
1352   if (!itv.More() && TE->Degenerated())
1353     ori = V.Orientation();
1354
1355   while (itv.More()) {
1356     const TopoDS_Shape& Vcur = itv.Value();
1357     if (V.IsSame(Vcur)) {
1358       ori = Vcur.Orientation();
1359       if (ori == V.Orientation()) break;
1360     }
1361     itv.Next();
1362   }
1363
1364   BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1365   BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1366   Handle(BRep_GCurve) GC;
1367
1368   while (itcr.More()) {
1369     GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1370     if (!GC.IsNull()) {
1371 //      if (GC->IsCurveOnSurface(S,l)) {
1372       if (GC->IsCurveOnSurface(S,L)) { //xpu020198 : BUC60407
1373         if (ori == TopAbs_FORWARD)
1374           GC->First(Par);
1375         else if (ori == TopAbs_REVERSED)
1376           GC->Last(Par);
1377         else {
1378           BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1379           const Handle(Geom2d_Curve)& GCpc = GC->PCurve();
1380           UpdatePoints(lpr,Par,GCpc,S,l);
1381           TV->Modified(Standard_True);
1382         }
1383         break;
1384       }
1385     }
1386     itcr.Next();
1387   }
1388
1389   if (!itcr.More())
1390     throw Standard_DomainError("BRep_Builder:: no pcurve");
1391
1392   TV->UpdateTolerance(Tol);
1393   TE->Modified(Standard_True);
1394 }
1395
1396 //=======================================================================
1397 //function : UpdateVertex
1398 //purpose  : update vertex with parameters on face
1399 //=======================================================================
1400
1401 void  BRep_Builder::UpdateVertex(const TopoDS_Vertex& Ve,
1402                                  const Standard_Real U,
1403                                  const Standard_Real V,
1404                                  const TopoDS_Face& F,
1405                                  const Standard_Real Tol) const
1406 {
1407   const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &Ve.TShape());
1408
1409   if(TV->Locked())
1410   {
1411     throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1412   }
1413
1414   TopLoc_Location L;
1415   const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
1416   L = L.Predivided(Ve.Location());
1417   BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1418   UpdatePoints(lpr,U,V,S,L);
1419
1420   TV->UpdateTolerance(Tol);
1421   TV->Modified(Standard_True);
1422 }
1423
1424 //=======================================================================
1425 //function : UpdateVertex
1426 //purpose  : update vertex with 3d point
1427 //=======================================================================
1428
1429 void  BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1430                                  const Standard_Real Tol) const
1431 {
1432   const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1433
1434   if(TV->Locked())
1435   {
1436     throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1437   }
1438
1439   TV->UpdateTolerance(Tol);
1440   TV->Modified(Standard_True);
1441 }
1442
1443
1444 //=======================================================================
1445 //function : Transfert
1446 //purpose  :
1447 //=======================================================================
1448
1449 void  BRep_Builder::Transfert(const TopoDS_Edge& Ein,
1450                               const TopoDS_Edge& Eout,
1451                               const TopoDS_Vertex& Vin,
1452                               const TopoDS_Vertex& Vout) const
1453 {
1454   const Standard_Real tol = BRep_Tool::Tolerance(Vin);
1455   const Standard_Real parin = BRep_Tool::Parameter(Vin,Ein);
1456   UpdateVertex(Vout,parin,Eout,tol);
1457 }