0028229: BRep_Builder::Transfert must not raise exception if the input edge is Locked
[occt.git] / 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 }