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 //=======================================================================
UpdateCurves(BRep_ListOfCurveRepresentation & lcr,const Handle (Geom_Curve)& C,const TopLoc_Location & L)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
UpdateCurves(BRep_ListOfCurveRepresentation & lcr,const Handle (Geom2d_Curve)& C,const Handle (Geom_Surface)& S,const TopLoc_Location & L)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 set 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 //=======================================================================
UpdateCurves(BRep_ListOfCurveRepresentation & lcr,const Handle (Geom2d_Curve)& C,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const gp_Pnt2d & Pf,const gp_Pnt2d & Pl)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 set 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
UpdateCurves(BRep_ListOfCurveRepresentation & lcr,const Handle (Geom2d_Curve)& C1,const Handle (Geom2d_Curve)& C2,const Handle (Geom_Surface)& S,const TopLoc_Location & L)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 //=======================================================================
UpdateCurves(BRep_ListOfCurveRepresentation & lcr,const Handle (Geom2d_Curve)& C1,const Handle (Geom2d_Curve)& C2,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const gp_Pnt2d & Pf,const gp_Pnt2d & Pl)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
UpdateCurves(BRep_ListOfCurveRepresentation & lcr,const Handle (Geom_Surface)& S1,const Handle (Geom_Surface)& S2,const TopLoc_Location & L1,const TopLoc_Location & L2,const GeomAbs_Shape C)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
UpdatePoints(BRep_ListOfPointRepresentation & lpr,Standard_Real p,const Handle (Geom_Curve)& C,const TopLoc_Location & L)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
UpdatePoints(BRep_ListOfPointRepresentation & lpr,Standard_Real p,const Handle (Geom2d_Curve)& PC,const Handle (Geom_Surface)& S,const TopLoc_Location & L)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
UpdatePoints(BRep_ListOfPointRepresentation & lpr,Standard_Real p1,Standard_Real p2,const Handle (Geom_Surface)& S,const TopLoc_Location & L)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
MakeFace(TopoDS_Face & F,const Handle (Geom_Surface)& S,const Standard_Real Tol) const453 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 //=======================================================================
MakeFace(TopoDS_Face & theFace,const Handle (Poly_Triangulation)& theTriangulation) const472 void BRep_Builder::MakeFace(TopoDS_Face& theFace,
473 const Handle(Poly_Triangulation)& theTriangulation) const
474 {
475 Handle(BRep_TFace) aTFace = new BRep_TFace();
476 if(!theFace.IsNull() && theFace.Locked())
477 {
478 throw TopoDS_LockedShape("BRep_Builder::MakeFace");
479 }
480 aTFace->Triangulation (theTriangulation);
481 MakeShape (theFace, aTFace);
482 }
483
484 //=======================================================================
485 //function : MakeFace
486 //purpose :
487 //=======================================================================
MakeFace(TopoDS_Face & theFace,const Poly_ListOfTriangulation & theTriangulations,const Handle (Poly_Triangulation)& theActiveTriangulation) const488 void BRep_Builder::MakeFace (TopoDS_Face& theFace,
489 const Poly_ListOfTriangulation& theTriangulations,
490 const Handle(Poly_Triangulation)& theActiveTriangulation) const
491 {
492 Handle(BRep_TFace) aTFace = new BRep_TFace();
493 if(!theFace.IsNull() && theFace.Locked())
494 {
495 throw TopoDS_LockedShape ("BRep_Builder::MakeFace");
496 }
497 aTFace->Triangulations (theTriangulations, theActiveTriangulation);
498 MakeShape (theFace, aTFace);
499 }
500
501 //=======================================================================
502 //function : MakeFace
503 //purpose :
504 //=======================================================================
505
MakeFace(TopoDS_Face & F,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol) const506 void BRep_Builder::MakeFace(TopoDS_Face& F,
507 const Handle(Geom_Surface)& S,
508 const TopLoc_Location& L,
509 const Standard_Real Tol) const
510 {
511 Handle(BRep_TFace) TF = new BRep_TFace();
512 if(!F.IsNull() && F.Locked())
513 {
514 throw TopoDS_LockedShape("BRep_Builder::MakeFace");
515 }
516 TF->Surface(S);
517 TF->Tolerance(Tol);
518 TF->Location(L);
519 MakeShape(F,TF);
520 }
521
522
523 //=======================================================================
524 //function : UpdateFace
525 //purpose :
526 //=======================================================================
527
UpdateFace(const TopoDS_Face & F,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol) const528 void BRep_Builder::UpdateFace(const TopoDS_Face& F,
529 const Handle(Geom_Surface)& S,
530 const TopLoc_Location& L,
531 const Standard_Real Tol) const
532 {
533 const Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &F.TShape());
534 if(TF->Locked())
535 {
536 throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
537 }
538 TF->Surface(S);
539 TF->Tolerance(Tol);
540 TF->Location(L.Predivided(F.Location()));
541 F.TShape()->Modified(Standard_True);
542 }
543
544
545 //=======================================================================
546 //function : UpdateFace
547 //purpose :
548 //=======================================================================
UpdateFace(const TopoDS_Face & theFace,const Handle (Poly_Triangulation)& theTriangulation,const Standard_Boolean theToReset) const549 void BRep_Builder::UpdateFace (const TopoDS_Face& theFace,
550 const Handle(Poly_Triangulation)& theTriangulation,
551 const Standard_Boolean theToReset) const
552 {
553 const Handle(BRep_TFace)& aTFace = *((Handle(BRep_TFace)*) &theFace.TShape());
554 if(aTFace->Locked())
555 {
556 throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
557 }
558 aTFace->Triangulation (theTriangulation, theToReset);
559 theFace.TShape()->Modified (Standard_True);
560 }
561
562 //=======================================================================
563 //function : UpdateFace
564 //purpose :
565 //=======================================================================
566
UpdateFace(const TopoDS_Face & F,const Standard_Real Tol) const567 void BRep_Builder::UpdateFace(const TopoDS_Face& F,
568 const Standard_Real Tol) const
569 {
570 const Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &F.TShape());
571 if(TF->Locked())
572 {
573 throw TopoDS_LockedShape("BRep_Builder::UpdateFace");
574 }
575 TF->Tolerance(Tol);
576 F.TShape()->Modified(Standard_True);
577 }
578
579
580 //=======================================================================
581 //function : NaturalRestriction
582 //purpose :
583 //=======================================================================
584
NaturalRestriction(const TopoDS_Face & F,const Standard_Boolean N) const585 void BRep_Builder::NaturalRestriction(const TopoDS_Face& F,
586 const Standard_Boolean N) const
587 {
588 const Handle(BRep_TFace)& TF = (*((Handle(BRep_TFace)*) &F.TShape()));
589 if(TF->Locked())
590 {
591 throw TopoDS_LockedShape("BRep_Builder::NaturalRestriction");
592 }
593 TF->NaturalRestriction(N);
594 F.TShape()->Modified(Standard_True);
595 }
596
597
598 //=======================================================================
599 //function : MakeEdge
600 //purpose : make undefined edge
601 //=======================================================================
602
MakeEdge(TopoDS_Edge & E) const603 void BRep_Builder::MakeEdge(TopoDS_Edge& E) const
604 {
605 Handle(BRep_TEdge) TE = new BRep_TEdge();
606 if(!E.IsNull() && E.Locked())
607 {
608 throw TopoDS_LockedShape("BRep_Builder::MakeEdge");
609 }
610 MakeShape(E,TE);
611 }
612
613
614 //=======================================================================
615 //function : UpdateEdge
616 //purpose :
617 //=======================================================================
618
UpdateEdge(const TopoDS_Edge & E,const Handle (Geom_Curve)& C,const TopLoc_Location & L,const Standard_Real Tol) const619 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
620 const Handle(Geom_Curve)& C,
621 const TopLoc_Location& L,
622 const Standard_Real Tol) const
623 {
624 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
625 if(TE->Locked())
626 {
627 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
628 }
629 const TopLoc_Location l = L.Predivided(E.Location());
630
631 UpdateCurves(TE->ChangeCurves(),C,l);
632
633 TE->UpdateTolerance(Tol);
634 TE->Modified(Standard_True);
635 }
636
637
638 //=======================================================================
639 //function : UpdateEdge
640 //purpose :
641 //=======================================================================
642
UpdateEdge(const TopoDS_Edge & E,const Handle (Geom2d_Curve)& C,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol) const643 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
644 const Handle(Geom2d_Curve)& C,
645 const Handle(Geom_Surface)& S,
646 const TopLoc_Location& L,
647 const Standard_Real Tol) const
648 {
649 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
650 if(TE->Locked())
651 {
652 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
653 }
654 const TopLoc_Location l = L.Predivided(E.Location());
655
656 UpdateCurves(TE->ChangeCurves(),C,S,l);
657
658 TE->UpdateTolerance(Tol);
659 TE->Modified(Standard_True);
660 }
661
662
663 //=======================================================================
664 //function : UpdateEdge
665 //purpose : for the second format (for XML Persistence)
666 //=======================================================================
667
UpdateEdge(const TopoDS_Edge & E,const Handle (Geom2d_Curve)& C,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol,const gp_Pnt2d & Pf,const gp_Pnt2d & Pl) const668 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
669 const Handle(Geom2d_Curve)& C,
670 const Handle(Geom_Surface)& S,
671 const TopLoc_Location& L,
672 const Standard_Real Tol,
673 const gp_Pnt2d& Pf,
674 const gp_Pnt2d& Pl) const
675 {
676 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
677 if(TE->Locked())
678 {
679 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
680 }
681 const TopLoc_Location l = L.Predivided(E.Location());
682
683 UpdateCurves(TE->ChangeCurves(),C,S,l,Pf,Pl);
684
685 TE->UpdateTolerance(Tol);
686 TE->Modified(Standard_True);
687 }
688
689
690 //=======================================================================
691 //function : UpdateEdge
692 //purpose :
693 //=======================================================================
694
UpdateEdge(const TopoDS_Edge & E,const Handle (Geom2d_Curve)& C1,const Handle (Geom2d_Curve)& C2,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol) const695 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
696 const Handle(Geom2d_Curve)& C1,
697 const Handle(Geom2d_Curve)& C2,
698 const Handle(Geom_Surface)& S,
699 const TopLoc_Location& L,
700 const Standard_Real Tol) const
701 {
702 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
703 if(TE->Locked())
704 {
705 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
706 }
707 const TopLoc_Location l = L.Predivided(E.Location());
708
709 UpdateCurves(TE->ChangeCurves(),C1,C2,S,l);
710
711 TE->UpdateTolerance(Tol);
712 TE->Modified(Standard_True);
713 }
714
715
716 //=======================================================================
717 //function : UpdateEdge
718 //purpose : for the second format (for XML Persistence)
719 //=======================================================================
720
UpdateEdge(const TopoDS_Edge & E,const Handle (Geom2d_Curve)& C1,const Handle (Geom2d_Curve)& C2,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol,const gp_Pnt2d & Pf,const gp_Pnt2d & Pl) const721 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
722 const Handle(Geom2d_Curve)& C1,
723 const Handle(Geom2d_Curve)& C2,
724 const Handle(Geom_Surface)& S,
725 const TopLoc_Location& L,
726 const Standard_Real Tol,
727 const gp_Pnt2d& Pf,
728 const gp_Pnt2d& Pl) const
729 {
730 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
731 if(TE->Locked())
732 {
733 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
734 }
735 const TopLoc_Location l = L.Predivided(E.Location());
736
737 UpdateCurves(TE->ChangeCurves(),C1,C2,S,l,Pf,Pl);
738
739 TE->UpdateTolerance(Tol);
740 TE->Modified(Standard_True);
741 }
742
743
744 //=======================================================================
745 //function : UpdateEdge
746 //purpose :
747 //=======================================================================
748
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_Polygon3D)& P,const TopLoc_Location & L) const749 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
750 const Handle(Poly_Polygon3D)& P,
751 const TopLoc_Location& L) const
752 {
753 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
754 if(TE->Locked())
755 {
756 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
757 }
758 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
759 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
760
761 while (itcr.More())
762 {
763 if (itcr.Value()->IsPolygon3D())
764 {
765 if (P.IsNull())
766 lcr.Remove(itcr);
767 else
768 itcr.Value()->Polygon3D(P);
769 TE->Modified(Standard_True);
770 return;
771 }
772 itcr.Next();
773 }
774
775 const TopLoc_Location l = L.Predivided(E.Location());
776 Handle(BRep_Polygon3D) P3d = new BRep_Polygon3D(P,l);
777 lcr.Append(P3d);
778
779 TE->Modified(Standard_True);
780 }
781
782
783 //=======================================================================
784 //function : UpdateEdge
785 //purpose :
786 //=======================================================================
787
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_PolygonOnTriangulation)& P,const Handle (Poly_Triangulation)& T,const TopLoc_Location & L) const788 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
789 const Handle(Poly_PolygonOnTriangulation)& P,
790 const Handle(Poly_Triangulation)& T,
791 const TopLoc_Location& L) const
792 {
793 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
794 if(TE->Locked())
795 {
796 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
797 }
798 const TopLoc_Location l = L.Predivided(E.Location());
799
800 Standard_Boolean isModified = Standard_False;
801
802 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
803 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
804 Handle(BRep_CurveRepresentation) cr;
805
806 while (itcr.More())
807 {
808 if (itcr.Value()->IsPolygonOnTriangulation(T,l))
809 {
810 // cr is used to keep a reference on the curve representation
811 // this avoid deleting it as its content may be referenced by T
812 cr = itcr.Value();
813 lcr.Remove(itcr);
814 isModified = Standard_True;
815 break;
816 }
817 itcr.Next();
818 }
819
820 if (!P.IsNull())
821 {
822 Handle(BRep_PolygonOnTriangulation) PT =
823 new BRep_PolygonOnTriangulation(P,T,l);
824 lcr.Append(PT);
825 isModified = Standard_True;
826 }
827
828 if (isModified)
829 TE->Modified(Standard_True);
830 }
831
832
833 //=======================================================================
834 //function : UpdateEdge
835 //purpose :
836 //=======================================================================
837
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_PolygonOnTriangulation)& P1,const Handle (Poly_PolygonOnTriangulation)& P2,const Handle (Poly_Triangulation)& T,const TopLoc_Location & L) const838 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
839 const Handle(Poly_PolygonOnTriangulation)& P1,
840 const Handle(Poly_PolygonOnTriangulation)& P2,
841 const Handle(Poly_Triangulation)& T,
842 const TopLoc_Location& L) const
843 {
844 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
845 if(TE->Locked())
846 {
847 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
848 }
849 const TopLoc_Location l = L.Predivided(E.Location());
850
851 Standard_Boolean isModified = Standard_False;
852
853 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
854 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
855 Handle(BRep_CurveRepresentation) cr;
856
857 while (itcr.More())
858 {
859 if (itcr.Value()->IsPolygonOnTriangulation(T,l)) //szv:was L
860 {
861 // cr is used to keep a reference on the curve representation
862 // this avoid deleting it as its content may be referenced by T
863 cr = itcr.Value();
864 lcr.Remove(itcr);
865 isModified = Standard_True;
866 break;
867 }
868 itcr.Next();
869 }
870
871 if (!P1.IsNull() && !P2.IsNull())
872 {
873 Handle(BRep_PolygonOnClosedTriangulation) PT =
874 new BRep_PolygonOnClosedTriangulation(P1,P2,T,l);
875 lcr.Append(PT);
876 isModified = Standard_True;
877 }
878
879 if (isModified)
880 TE->Modified(Standard_True);
881 }
882
883 //=======================================================================
884 //function : UpdateEdge
885 //purpose :
886 //=======================================================================
887
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_Polygon2D)& P,const TopoDS_Face & F) const888 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
889 const Handle(Poly_Polygon2D)& P,
890 const TopoDS_Face& F) const
891 {
892 TopLoc_Location l;
893 const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
894 UpdateEdge(E, P, S, l);
895 }
896
897 //=======================================================================
898 //function : UpdateEdge
899 //purpose :
900 //=======================================================================
901
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_Polygon2D)& P,const Handle (Geom_Surface)& S,const TopLoc_Location & L) const902 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
903 const Handle(Poly_Polygon2D)& P,
904 const Handle(Geom_Surface)& S,
905 const TopLoc_Location& L) const
906 {
907 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
908 if(TE->Locked())
909 {
910 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
911 }
912 TopLoc_Location l = L.Predivided(E.Location());
913
914 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
915 Handle(BRep_CurveRepresentation) cr;
916
917 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
918 while (itcr.More()) {
919 if (itcr.Value()->IsPolygonOnSurface(S, l)) break;
920 itcr.Next();
921 }
922
923 if (itcr.More()) {
924 // cr is used to keep a reference on the curve representation
925 // this avoid deleting it as its content may be referenced by T
926 cr = itcr.Value();
927 lcr.Remove(itcr);
928 }
929
930 if (!P.IsNull()) {
931 Handle(BRep_PolygonOnSurface) PS =
932 new BRep_PolygonOnSurface(P, S, l);
933 lcr.Append(PS);
934 }
935
936 TE->Modified(Standard_True);
937 }
938
939 //=======================================================================
940 //function : UpdateEdge
941 //purpose :
942 //=======================================================================
943
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_Polygon2D)& P1,const Handle (Poly_Polygon2D)& P2,const TopoDS_Face & F) const944 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
945 const Handle(Poly_Polygon2D)& P1,
946 const Handle(Poly_Polygon2D)& P2,
947 const TopoDS_Face& F) const
948 {
949 TopLoc_Location l;
950 const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,l);
951 UpdateEdge(E, P1, P2, S, l);
952 }
953
954 //=======================================================================
955 //function : UpdateEdge
956 //purpose :
957 //=======================================================================
958
UpdateEdge(const TopoDS_Edge & E,const Handle (Poly_Polygon2D)& P1,const Handle (Poly_Polygon2D)& P2,const Handle (Geom_Surface)& S,const TopLoc_Location & L) const959 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
960 const Handle(Poly_Polygon2D)& P1,
961 const Handle(Poly_Polygon2D)& P2,
962 const Handle(Geom_Surface)& S,
963 const TopLoc_Location& L) const
964 {
965 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
966 if(TE->Locked())
967 {
968 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
969 }
970 TopLoc_Location l = L.Predivided(E.Location());
971
972 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
973 Handle(BRep_CurveRepresentation) cr;
974
975 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
976 while (itcr.More()) {
977 if (itcr.Value()->IsPolygonOnSurface(S, l)) break;
978 itcr.Next();
979 }
980
981 if (itcr.More()) {
982 // cr is used to keep a reference on the curve representation
983 // this avoid deleting it as its content may be referenced by T
984 cr = itcr.Value();
985 lcr.Remove(itcr);
986 }
987
988 if (!P1.IsNull() && !P2.IsNull()) {
989 Handle(BRep_PolygonOnClosedSurface) PS =
990 new BRep_PolygonOnClosedSurface(P1, P2, S, TopLoc_Location());
991 lcr.Append(PS);
992 }
993
994 TE->Modified(Standard_True);
995 }
996
997 //=======================================================================
998 //function : UpdateEdge
999 //purpose :
1000 //=======================================================================
1001
UpdateEdge(const TopoDS_Edge & E,const Standard_Real Tol) const1002 void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
1003 const Standard_Real Tol) const
1004 {
1005 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1006 if(TE->Locked())
1007 {
1008 throw TopoDS_LockedShape("BRep_Builder::UpdateEdge");
1009 }
1010 TE->UpdateTolerance(Tol);
1011 TE->Modified(Standard_True);
1012 }
1013
1014
1015 //=======================================================================
1016 //function : Continuity
1017 //purpose :
1018 //=======================================================================
1019
Continuity(const TopoDS_Edge & E,const TopoDS_Face & F1,const TopoDS_Face & F2,const GeomAbs_Shape C) const1020 void BRep_Builder::Continuity(const TopoDS_Edge& E,
1021 const TopoDS_Face& F1,
1022 const TopoDS_Face& F2,
1023 const GeomAbs_Shape C) const
1024 {
1025 TopLoc_Location l1,l2;
1026 const Handle(Geom_Surface)& S1 = BRep_Tool::Surface(F1,l1);
1027 const Handle(Geom_Surface)& S2 = BRep_Tool::Surface(F2,l2);
1028 Continuity(E,S1,S2,l1,l2,C);
1029 }
1030
1031 //=======================================================================
1032 //function : Continuity
1033 //purpose :
1034 //=======================================================================
1035
Continuity(const TopoDS_Edge & E,const Handle (Geom_Surface)& S1,const Handle (Geom_Surface)& S2,const TopLoc_Location & L1,const TopLoc_Location & L2,const GeomAbs_Shape C) const1036 void BRep_Builder::Continuity(const TopoDS_Edge& E,
1037 const Handle(Geom_Surface)& S1,
1038 const Handle(Geom_Surface)& S2,
1039 const TopLoc_Location& L1,
1040 const TopLoc_Location& L2,
1041 const GeomAbs_Shape C)const
1042 {
1043 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1044 if(TE->Locked())
1045 {
1046 throw TopoDS_LockedShape("BRep_Builder::Continuity");
1047 }
1048 const TopLoc_Location l1 = L1.Predivided(E.Location());
1049 const TopLoc_Location l2 = L2.Predivided(E.Location());
1050
1051 UpdateCurves(TE->ChangeCurves(),S1,S2,l1,l2,C);
1052
1053 TE->Modified(Standard_True);
1054 }
1055
1056 //=======================================================================
1057 //function : SameParameter
1058 //purpose :
1059 //=======================================================================
1060
SameParameter(const TopoDS_Edge & E,const Standard_Boolean S) const1061 void BRep_Builder::SameParameter(const TopoDS_Edge& E,
1062 const Standard_Boolean S) const
1063 {
1064 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1065 if(TE->Locked())
1066 {
1067 throw TopoDS_LockedShape("BRep_Builder::SameParameter");
1068 }
1069 TE->SameParameter(S);
1070 TE->Modified(Standard_True);
1071 }
1072
1073 //=======================================================================
1074 //function : SameRange
1075 //purpose :
1076 //=======================================================================
1077
SameRange(const TopoDS_Edge & E,const Standard_Boolean S) const1078 void BRep_Builder::SameRange(const TopoDS_Edge& E,
1079 const Standard_Boolean S) const
1080 {
1081 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1082 if(TE->Locked())
1083 {
1084 throw TopoDS_LockedShape("BRep_Builder::SameRange");
1085 }
1086 TE->SameRange(S);
1087 TE->Modified(Standard_True);
1088 }
1089
1090 //=======================================================================
1091 //function : Degenerated
1092 //purpose :
1093 //=======================================================================
1094
Degenerated(const TopoDS_Edge & E,const Standard_Boolean D) const1095 void BRep_Builder::Degenerated(const TopoDS_Edge& E,
1096 const Standard_Boolean D) const
1097 {
1098 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1099 if(TE->Locked())
1100 {
1101 throw TopoDS_LockedShape("BRep_Builder::Degenerated");
1102 }
1103 TE->Degenerated(D);
1104 if (D) {
1105 // set a null 3d curve
1106 UpdateCurves(TE->ChangeCurves(),Handle(Geom_Curve)(),E.Location());
1107 }
1108 TE->Modified(Standard_True);
1109 }
1110
1111
1112 //=======================================================================
1113 //function : Range
1114 //purpose :
1115 //=======================================================================
1116
Range(const TopoDS_Edge & E,const Standard_Real First,const Standard_Real Last,const Standard_Boolean Only3d) const1117 void BRep_Builder::Range(const TopoDS_Edge& E,
1118 const Standard_Real First,
1119 const Standard_Real Last,
1120 const Standard_Boolean Only3d) const
1121 {
1122 // set the range to all the representations if Only3d=FALSE
1123 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1124 if(TE->Locked())
1125 {
1126 throw TopoDS_LockedShape("BRep_Builder::Range");
1127 }
1128 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1129 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1130 Handle(BRep_GCurve) GC;
1131
1132 while (itcr.More()) {
1133 GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1134 if (!GC.IsNull() && (!Only3d || GC->IsCurve3D()))
1135 GC->SetRange(First,Last);
1136 itcr.Next();
1137 }
1138
1139 TE->Modified(Standard_True);
1140 }
1141
1142
1143 //=======================================================================
1144 //function : Range
1145 //purpose :
1146 //=======================================================================
1147
Range(const TopoDS_Edge & E,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real First,const Standard_Real Last) const1148 void BRep_Builder::Range(const TopoDS_Edge& E,
1149 const Handle(Geom_Surface)& S,
1150 const TopLoc_Location& L,
1151 const Standard_Real First,
1152 const Standard_Real Last) const
1153 {
1154 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1155 if(TE->Locked())
1156 {
1157 throw TopoDS_LockedShape("BRep_Builder::Range");
1158 }
1159 const TopLoc_Location l = L.Predivided(E.Location());
1160
1161 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1162 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1163 Handle(BRep_GCurve) GC;
1164
1165 while (itcr.More()) {
1166 GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1167 if (!GC.IsNull() && GC->IsCurveOnSurface(S,l))
1168 {
1169 GC->SetRange(First,Last);
1170 break;
1171 }
1172 itcr.Next();
1173 }
1174
1175 if (!itcr.More())
1176 throw Standard_DomainError("BRep_Builder::Range, no pcurve");
1177
1178 TE->Modified(Standard_True);
1179 }
1180
1181
1182 //=======================================================================
1183 //function : Transfert
1184 //purpose :
1185 //=======================================================================
1186
Transfert(const TopoDS_Edge & Ein,const TopoDS_Edge & Eout) const1187 void BRep_Builder::Transfert(const TopoDS_Edge& Ein,
1188 const TopoDS_Edge& Eout) const
1189 {
1190 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &Ein.TShape());
1191 const Standard_Real tol = TE->Tolerance();
1192
1193 const BRep_ListOfCurveRepresentation& lcr = TE->Curves();
1194 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1195
1196 while (itcr.More()) {
1197
1198 const Handle(BRep_CurveRepresentation)& CR = itcr.Value();
1199
1200 if (CR->IsCurveOnSurface()) {
1201 UpdateEdge(Eout,
1202 CR->PCurve(),
1203 CR->Surface(),
1204 Ein.Location() * CR->Location(),tol);
1205 }
1206
1207 else if (CR->IsCurveOnClosedSurface()) {
1208 UpdateEdge(Eout,
1209 CR->PCurve(),
1210 CR->PCurve2(),
1211 CR->Surface(),
1212 Ein.Location() * CR->Location(),tol);
1213 }
1214
1215 if (CR->IsRegularity()) {
1216 Continuity(Eout,
1217 CR->Surface(),
1218 CR->Surface2(),
1219 Ein.Location() * CR->Location(),
1220 Ein.Location() * CR->Location2(),
1221 CR->Continuity());
1222 }
1223
1224 itcr.Next();
1225 }
1226 }
1227
1228
1229 //=======================================================================
1230 //function : UpdateVertex
1231 //purpose : update vertex with 3d point
1232 //=======================================================================
1233
UpdateVertex(const TopoDS_Vertex & V,const gp_Pnt & P,const Standard_Real Tol) const1234 void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1235 const gp_Pnt& P,
1236 const Standard_Real Tol) const
1237 {
1238 const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1239 if(TV->Locked())
1240 {
1241 throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1242 }
1243 TV->Pnt(P.Transformed(V.Location().Inverted().Transformation()));
1244 TV->UpdateTolerance(Tol);
1245 TV->Modified(Standard_True);
1246 }
1247
1248
1249 //=======================================================================
1250 //function : UpdateVertex
1251 //purpose : update vertex with parameter on edge
1252 //=======================================================================
1253
UpdateVertex(const TopoDS_Vertex & V,const Standard_Real Par,const TopoDS_Edge & E,const Standard_Real Tol) const1254 void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1255 const Standard_Real Par,
1256 const TopoDS_Edge& E,
1257 const Standard_Real Tol) const
1258 {
1259 if (Precision::IsPositiveInfinite(Par) ||
1260 Precision::IsNegativeInfinite(Par))
1261 throw Standard_DomainError("BRep_Builder::Infinite parameter");
1262
1263 const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1264 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1265
1266 if(TV->Locked() || TE->Locked())
1267 {
1268 throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1269 }
1270
1271 TopLoc_Location L = E.Location().Predivided(V.Location());
1272
1273 // Search the vertex in the edge
1274 TopAbs_Orientation ori = TopAbs_INTERNAL;
1275
1276 TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
1277
1278 // if the edge has no vertices
1279 // and is degenerated use the vertex orientation
1280 // RLE, june 94
1281
1282 if (!itv.More() && TE->Degenerated())
1283 ori = V.Orientation();
1284
1285 while (itv.More()) {
1286 const TopoDS_Shape& Vcur = itv.Value();
1287 if (V.IsSame(Vcur)) {
1288 ori = Vcur.Orientation();
1289 if (ori == V.Orientation()) break;
1290 }
1291 itv.Next();
1292 }
1293
1294 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1295 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1296 Handle(BRep_GCurve) GC;
1297
1298 while (itcr.More()) {
1299 GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1300 if (!GC.IsNull()) {
1301 if (ori == TopAbs_FORWARD)
1302 GC->First(Par);
1303 else if (ori == TopAbs_REVERSED)
1304 GC->Last(Par);
1305 else {
1306 BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1307 const TopLoc_Location& GCloc = GC->Location();
1308 TopLoc_Location LGCloc = L*GCloc;
1309 if (GC->IsCurve3D()) {
1310 const Handle(Geom_Curve)& GC3d = GC->Curve3D();
1311 UpdatePoints(lpr,Par,GC3d,LGCloc);
1312 }
1313 else if (GC->IsCurveOnSurface()) {
1314 const Handle(Geom2d_Curve)& GCpc = GC->PCurve();
1315 const Handle(Geom_Surface)& GCsu = GC->Surface();
1316 UpdatePoints(lpr,Par,GCpc,GCsu,LGCloc);
1317 }
1318 }
1319 }
1320 itcr.Next();
1321 }
1322
1323 if ((ori != TopAbs_FORWARD) && (ori != TopAbs_REVERSED))
1324 TV->Modified(Standard_True);
1325 TV->UpdateTolerance(Tol);
1326 TE->Modified(Standard_True);
1327 }
1328
1329
1330 //=======================================================================
1331 //function : UpdateVertex
1332 //purpose : update vertex with parameter on edge on face
1333 //=======================================================================
1334
UpdateVertex(const TopoDS_Vertex & V,const Standard_Real Par,const TopoDS_Edge & E,const Handle (Geom_Surface)& S,const TopLoc_Location & L,const Standard_Real Tol) const1335 void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1336 const Standard_Real Par,
1337 const TopoDS_Edge& E,
1338 const Handle(Geom_Surface)& S,
1339 const TopLoc_Location& L,
1340 const Standard_Real Tol) const
1341 {
1342 if (Precision::IsPositiveInfinite(Par) ||
1343 Precision::IsNegativeInfinite(Par))
1344 throw Standard_DomainError("BRep_Builder::Infinite parameter");
1345
1346 // Find the curve representation
1347 TopLoc_Location l = L.Predivided(V.Location());
1348
1349 const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1350 const Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &E.TShape());
1351
1352 if(TV->Locked() || TE->Locked())
1353 {
1354 throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1355 }
1356
1357 // Search the vertex in the edge
1358 TopAbs_Orientation ori = TopAbs_INTERNAL;
1359
1360 TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
1361
1362 // if the edge has no vertices
1363 // and is degenerated use the vertex orientation
1364 // RLE, june 94
1365
1366 if (!itv.More() && TE->Degenerated())
1367 ori = V.Orientation();
1368
1369 while (itv.More()) {
1370 const TopoDS_Shape& Vcur = itv.Value();
1371 if (V.IsSame(Vcur)) {
1372 ori = Vcur.Orientation();
1373 if (ori == V.Orientation()) break;
1374 }
1375 itv.Next();
1376 }
1377
1378 BRep_ListOfCurveRepresentation& lcr = TE->ChangeCurves();
1379 BRep_ListIteratorOfListOfCurveRepresentation itcr(lcr);
1380 Handle(BRep_GCurve) GC;
1381
1382 while (itcr.More()) {
1383 GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
1384 if (!GC.IsNull()) {
1385 // if (GC->IsCurveOnSurface(S,l)) {
1386 if (GC->IsCurveOnSurface(S,L)) { //xpu020198 : BUC60407
1387 if (ori == TopAbs_FORWARD)
1388 GC->First(Par);
1389 else if (ori == TopAbs_REVERSED)
1390 GC->Last(Par);
1391 else {
1392 BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1393 const Handle(Geom2d_Curve)& GCpc = GC->PCurve();
1394 UpdatePoints(lpr,Par,GCpc,S,l);
1395 TV->Modified(Standard_True);
1396 }
1397 break;
1398 }
1399 }
1400 itcr.Next();
1401 }
1402
1403 if (!itcr.More())
1404 throw Standard_DomainError("BRep_Builder:: no pcurve");
1405
1406 TV->UpdateTolerance(Tol);
1407 TE->Modified(Standard_True);
1408 }
1409
1410 //=======================================================================
1411 //function : UpdateVertex
1412 //purpose : update vertex with parameters on face
1413 //=======================================================================
1414
UpdateVertex(const TopoDS_Vertex & Ve,const Standard_Real U,const Standard_Real V,const TopoDS_Face & F,const Standard_Real Tol) const1415 void BRep_Builder::UpdateVertex(const TopoDS_Vertex& Ve,
1416 const Standard_Real U,
1417 const Standard_Real V,
1418 const TopoDS_Face& F,
1419 const Standard_Real Tol) const
1420 {
1421 const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &Ve.TShape());
1422
1423 if(TV->Locked())
1424 {
1425 throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1426 }
1427
1428 TopLoc_Location L;
1429 const Handle(Geom_Surface)& S = BRep_Tool::Surface(F,L);
1430 L = L.Predivided(Ve.Location());
1431 BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1432 UpdatePoints(lpr,U,V,S,L);
1433
1434 TV->UpdateTolerance(Tol);
1435 TV->Modified(Standard_True);
1436 }
1437
1438 //=======================================================================
1439 //function : UpdateVertex
1440 //purpose : update vertex with 3d point
1441 //=======================================================================
1442
UpdateVertex(const TopoDS_Vertex & V,const Standard_Real Tol) const1443 void BRep_Builder::UpdateVertex(const TopoDS_Vertex& V,
1444 const Standard_Real Tol) const
1445 {
1446 const Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &V.TShape());
1447
1448 if(TV->Locked())
1449 {
1450 throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
1451 }
1452
1453 TV->UpdateTolerance(Tol);
1454 TV->Modified(Standard_True);
1455 }
1456
1457
1458 //=======================================================================
1459 //function : Transfert
1460 //purpose :
1461 //=======================================================================
1462
Transfert(const TopoDS_Edge & Ein,const TopoDS_Edge & Eout,const TopoDS_Vertex & Vin,const TopoDS_Vertex & Vout) const1463 void BRep_Builder::Transfert(const TopoDS_Edge& Ein,
1464 const TopoDS_Edge& Eout,
1465 const TopoDS_Vertex& Vin,
1466 const TopoDS_Vertex& Vout) const
1467 {
1468 const Standard_Real tol = BRep_Tool::Tolerance(Vin);
1469 const Standard_Real parin = BRep_Tool::Parameter(Vin,Ein);
1470 UpdateVertex(Vout,parin,Eout,tol);
1471 }
1472