1 // Created on: 1994-10-03
2 // Created by: Bruno DUMORTIER
3 // Copyright (c) 1994-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 <Bisector_Bisec.hxx>
19 #include <Bisector_BisecAna.hxx>
20 #include <Bnd_Box2d.hxx>
21 #include <BndLib_Add2dCurve.hxx>
22 #include <BRep_Builder.hxx>
23 #include <BRep_Tool.hxx>
24 #include <BRepAdaptor_Curve.hxx>
25 #include <BRepAlgo_FaceRestrictor.hxx>
26 #include <BRepAlgo_Loop.hxx>
27 #include <BRepClass3d_SolidClassifier.hxx>
28 #include <BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape.hxx>
29 #include <BRepFill_DataMapOfNodeDataMapOfShapeShape.hxx>
30 #include <BRepFill_DataMapOfShapeDataMapOfShapeListOfShape.hxx>
31 #include <BRepFill_DataMapOfShapeSequenceOfPnt.hxx>
32 #include <BRepFill_DataMapOfShapeSequenceOfReal.hxx>
33 #include <BRepFill_Evolved.hxx>
34 #include <BRepFill_OffsetAncestors.hxx>
35 #include <BRepFill_OffsetWire.hxx>
36 #include <BRepFill_Pipe.hxx>
37 #include <BRepFill_TrimSurfaceTool.hxx>
38 #include <BRepLib.hxx>
39 #include <BRepLib_FindSurface.hxx>
40 #include <BRepLib_MakeEdge.hxx>
41 #include <BRepLib_MakeFace.hxx>
42 #include <BRepLib_MakeVertex.hxx>
43 #include <BRepLib_MakeWire.hxx>
44 #include <BRepLProp.hxx>
45 #include <BRepMAT2d_BisectingLocus.hxx>
46 #include <BRepMAT2d_Explorer.hxx>
47 #include <BRepMAT2d_LinkTopoBilo.hxx>
48 #include <BRepSweep_Prism.hxx>
49 #include <BRepSweep_Revol.hxx>
50 #include <BRepTools.hxx>
51 #include <BRepTools_Modifier.hxx>
52 #include <BRepTools_Quilt.hxx>
53 #include <BRepTools_TrsfModification.hxx>
54 #include <BRepTools_WireExplorer.hxx>
55 #include <Geom2d_CartesianPoint.hxx>
56 #include <Geom2d_Circle.hxx>
57 #include <Geom2d_Curve.hxx>
58 #include <Geom2d_Geometry.hxx>
59 #include <Geom2d_Line.hxx>
60 #include <Geom2d_TrimmedCurve.hxx>
61 #include <Geom2dAdaptor_Curve.hxx>
62 #include <Geom2dAPI_ExtremaCurveCurve.hxx>
63 #include <Geom2dInt_GInter.hxx>
64 #include <Geom_Curve.hxx>
65 #include <Geom_Line.hxx>
66 #include <Geom_Plane.hxx>
67 #include <Geom_RectangularTrimmedSurface.hxx>
68 #include <Geom_Surface.hxx>
69 #include <Geom_TrimmedCurve.hxx>
70 #include <GeomAPI.hxx>
71 #include <GeomProjLib.hxx>
72 #include <gp.hxx>
73 #include <gp_Ax1.hxx>
74 #include <gp_Ax3.hxx>
75 #include <gp_Circ2d.hxx>
76 #include <gp_Dir.hxx>
77 #include <gp_Pln.hxx>
78 #include <gp_Pnt.hxx>
79 #include <gp_Pnt2d.hxx>
80 #include <gp_Trsf.hxx>
81 #include <gp_Vec.hxx>
82 #include <gp_Vec2d.hxx>
83 #include <IntRes2d_IntersectionPoint.hxx>
84 #include <MAT2d_CutCurve.hxx>
85 #include <MAT_Arc.hxx>
86 #include <MAT_BasicElt.hxx>
87 #include <MAT_Graph.hxx>
88 #include <MAT_Node.hxx>
89 #include <MAT_Side.hxx>
90 #include <Precision.hxx>
91 #include <Standard_ConstructionError.hxx>
92 #include <Standard_NoSuchObject.hxx>
93 #include <Standard_NotImplemented.hxx>
94 #include <TColgp_SequenceOfPnt.hxx>
95 #include <TColStd_SequenceOfReal.hxx>
96 #include <TopAbs.hxx>
97 #include <TopExp.hxx>
98 #include <TopExp_Explorer.hxx>
99 #include <TopLoc_Location.hxx>
100 #include <TopoDS.hxx>
101 #include <TopoDS_Compound.hxx>
102 #include <TopoDS_Edge.hxx>
103 #include <TopoDS_Face.hxx>
104 #include <TopoDS_Iterator.hxx>
105 #include <TopoDS_Shape.hxx>
106 #include <TopoDS_Solid.hxx>
107 #include <TopoDS_Vertex.hxx>
108 #include <TopoDS_Wire.hxx>
109 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
110 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
111 #include <TopTools_DataMapOfShapeSequenceOfShape.hxx>
112 #include <TopTools_DataMapOfShapeShape.hxx>
113 #include <TopTools_ListIteratorOfListOfShape.hxx>
114 #include <TopTools_SequenceOfShape.hxx>
115
116 //#define DRAW
117 #ifdef DRAW
118 #include <DBRep.hxx>
119 #include <DrawTrSurf.hxx>
120 #include <stdio.h>
121 static Standard_Boolean AffichGeom = Standard_False;
122 static Standard_Boolean AffichEdge = Standard_False;
123 static Standard_Integer NbFACES = 0;
124 static Standard_Integer NbTRIMFACES = 0;
125 static Standard_Integer NbVEVOS = 0;
126 static Standard_Integer NbPROFILS = 0;
127 static Standard_Integer NbEDGES = 0;
128 #endif
129
BRepFill_Confusion()130 static Standard_Real BRepFill_Confusion()
131 {
132 Standard_Real Tol = 1.e-6;
133 return Tol;
134 }
135
136 static const TopoDS_Wire PutProfilAt (const TopoDS_Wire& ProfRef,
137 const gp_Ax3& AxeRef,
138 const TopoDS_Edge& E,
139 const TopoDS_Face& F,
140 const Standard_Boolean AtStart);
141
142 static void TrimFace(const TopoDS_Face& Face,
143 TopTools_SequenceOfShape& TheEdges,
144 TopTools_SequenceOfShape& S);
145
146 static void TrimEdge (const TopoDS_Edge& Edge,
147 const TopTools_SequenceOfShape& TheEdgesControle,
148 TopTools_SequenceOfShape& TheVer,
149 TColStd_SequenceOfReal& ThePar,
150 TopTools_SequenceOfShape& S);
151
152 static Standard_Integer PosOnFace (Standard_Real d1,
153 Standard_Real d2,
154 Standard_Real d3);
155
156 static void ComputeIntervals (const TopTools_SequenceOfShape& VonF,
157 const TopTools_SequenceOfShape& VOnL,
158 const TColgp_SequenceOfPnt& ParOnF,
159 const TColgp_SequenceOfPnt& ParOnL,
160 const BRepFill_TrimSurfaceTool& Trim,
161 const Handle(Geom2d_Curve)& Bis,
162 const TopoDS_Vertex& VS,
163 const TopoDS_Vertex& VE,
164 TColStd_SequenceOfReal& FirstPar,
165 TColStd_SequenceOfReal& LastPar,
166 TopTools_SequenceOfShape& FirstV,
167 TopTools_SequenceOfShape& LastV );
168
169 static Standard_Real DistanceToOZ (const TopoDS_Vertex& V);
170
171 static Standard_Real Altitud (const TopoDS_Vertex& V);
172
173 static Standard_Boolean DoubleOrNotInFace (const TopTools_SequenceOfShape& EC,
174 const TopoDS_Vertex& V);
175
176 static void SimpleExpression (const Bisector_Bisec& B,
177 Handle(Geom2d_Curve)& Bis);
178
179 static TopAbs_Orientation Relative (const TopoDS_Wire& W1,
180 const TopoDS_Wire& W2,
181 const TopoDS_Vertex& V,
182 Standard_Boolean& Commun);
183
184 static void CutEdge (const TopoDS_Edge& E,
185 const TopoDS_Face& F,TopTools_ListOfShape& Cuts);
186
187 static void CutEdgeProf (const TopoDS_Edge& E,
188 const Handle(Geom_Plane)& Plane,
189 const Handle(Geom2d_Line)& Line,
190 TopTools_ListOfShape& Cuts,
191 TopTools_DataMapOfShapeShape& MapVerRefMoved);
192
193 static Standard_Integer VertexFromNode
194 (const Handle(MAT_Node)& aNode,
195 const TopoDS_Edge& E,
196 const TopoDS_Vertex& VF,
197 const TopoDS_Vertex& VL,
198 BRepFill_DataMapOfNodeDataMapOfShapeShape& MapNodeVertex,
199 TopoDS_Vertex& VS);
200
201 //=======================================================================
202 //function : EdgeVertices
203 //purpose :
204 //=======================================================================
205
EdgeVertices(const TopoDS_Edge & E,TopoDS_Vertex & V1,TopoDS_Vertex & V2)206 static void EdgeVertices (const TopoDS_Edge& E,
207 TopoDS_Vertex& V1,
208 TopoDS_Vertex& V2)
209 {
210 if (E.Orientation() == TopAbs_REVERSED) {
211 TopExp::Vertices(E,V2,V1);
212 }
213 else {
214 TopExp::Vertices(E,V1,V2);
215 }
216 }
217
218 //=======================================================================
219 //function : BRepFill_Evolved
220 //purpose :
221 //=======================================================================
222
BRepFill_Evolved()223 BRepFill_Evolved::BRepFill_Evolved()
224 :
225 myIsDone (Standard_False),
226 mySpineType(Standard_True)
227 {
228 }
229
230
231 //=======================================================================
232 //function : BRepFill_Evolved
233 //purpose :
234 //=======================================================================
235
BRepFill_Evolved(const TopoDS_Wire & Spine,const TopoDS_Wire & Profile,const gp_Ax3 & AxeProf,const GeomAbs_JoinType Join,const Standard_Boolean Solid)236 BRepFill_Evolved::BRepFill_Evolved(const TopoDS_Wire& Spine,
237 const TopoDS_Wire& Profile,
238 const gp_Ax3& AxeProf,
239 const GeomAbs_JoinType Join,
240 const Standard_Boolean Solid)
241
242 : myIsDone(Standard_False)
243 {
244 Perform( Spine, Profile, AxeProf, Join, Solid);
245 }
246
247
248 //=======================================================================
249 //function : BRepFill_Evolved
250 //purpose :
251 //=======================================================================
252
BRepFill_Evolved(const TopoDS_Face & Spine,const TopoDS_Wire & Profile,const gp_Ax3 & AxeProf,const GeomAbs_JoinType Join,const Standard_Boolean Solid)253 BRepFill_Evolved::BRepFill_Evolved(const TopoDS_Face& Spine,
254 const TopoDS_Wire& Profile,
255 const gp_Ax3& AxeProf,
256 const GeomAbs_JoinType Join,
257 const Standard_Boolean Solid)
258 : myIsDone(Standard_False)
259 {
260 Perform( Spine, Profile, AxeProf, Join, Solid);
261 }
262
263 //=======================================================================
264 //function : IsVertical
265 //purpose :
266 //=======================================================================
267
IsVertical(const TopoDS_Edge & E)268 static Standard_Boolean IsVertical(const TopoDS_Edge& E)
269 {
270 TopoDS_Vertex V1,V2;
271 TopExp::Vertices(E,V1,V2);
272 gp_Pnt P1 = BRep_Tool::Pnt(V1);
273 gp_Pnt P2 = BRep_Tool::Pnt(V2);
274
275 if ( Abs(P1.Y() - P2.Y()) < BRepFill_Confusion()) {
276 // It is a Line ?
277 TopLoc_Location Loc;
278 Standard_Real f,l;
279 Handle(Geom_Curve) GC = BRep_Tool::Curve(E,Loc,f,l);
280 if ( GC->DynamicType() == STANDARD_TYPE(Geom_Line))
281 return Standard_True;
282 }
283 return Standard_False;
284 }
285
286 //=======================================================================
287 //function : IsPlanar
288 //purpose :
289 //=======================================================================
290
IsPlanar(const TopoDS_Edge & E)291 static Standard_Boolean IsPlanar(const TopoDS_Edge& E)
292 {
293 TopoDS_Vertex V1,V2;
294 TopExp::Vertices(E,V1,V2);
295 gp_Pnt P1 = BRep_Tool::Pnt(V1);
296 gp_Pnt P2 = BRep_Tool::Pnt(V2);
297
298 if ( Abs(P1.Z() - P2.Z()) < BRepFill_Confusion()) {
299 // It is a Line ?
300 TopLoc_Location Loc;
301 Standard_Real f,l;
302 Handle(Geom_Curve) GC = BRep_Tool::Curve(E,Loc,f,l);
303 if ( GC->DynamicType() == STANDARD_TYPE(Geom_Line))
304 return Standard_True;
305 }
306 return Standard_False;
307
308 }
309
310 //=======================================================================
311 //function : Side
312 //purpose : determine the position of the profil correspondingly to plane XOZ.
313 // Return 1 : MAT_Left.
314 // Return 2 : MAT_Left and Planar.
315 // Return 3 : MAT_Left and Vertical.
316 // Return 4 : MAT_Right.
317 // Return 5 : MAT_Right and Planar.
318 // Return 6 : MAT_Right and Vertical.
319 //=======================================================================
320
Side(const TopoDS_Wire & Profil,const Standard_Real Tol)321 static Standard_Integer Side(const TopoDS_Wire& Profil,
322 const Standard_Real Tol)
323 {
324 TopoDS_Vertex V1,V2;
325 // Rem : it is enough to test the first edge of the Wire.
326 // ( Correctly cut in PrepareProfil)
327 TopExp_Explorer Explo(Profil,TopAbs_EDGE);
328
329 Standard_Integer TheSide;
330 const TopoDS_Edge& E = TopoDS::Edge(Explo.Current());
331
332 TopExp::Vertices(E,V1,V2);
333 gp_Pnt P1 = BRep_Tool::Pnt(V1);
334 gp_Pnt P2 = BRep_Tool::Pnt(V2);
335
336 if ( P1.Y() < -Tol || P2.Y() < -Tol) TheSide = 4;
337 else TheSide = 1;
338 if (IsVertical(E)) TheSide+=2;
339 else if (IsPlanar(E)) TheSide++;
340 return TheSide;
341 }
342
343
344 //=======================================================================
345 //function : Perform
346 //purpose :
347 //=======================================================================
348
Perform(const TopoDS_Wire & Spine,const TopoDS_Wire & Profile,const gp_Ax3 & AxeProf,const GeomAbs_JoinType Join,const Standard_Boolean Solid)349 void BRepFill_Evolved::Perform(const TopoDS_Wire& Spine,
350 const TopoDS_Wire& Profile,
351 const gp_Ax3& AxeProf,
352 const GeomAbs_JoinType Join,
353 const Standard_Boolean Solid)
354 {
355 mySpineType = Standard_False;
356 TopoDS_Face aFace = BRepLib_MakeFace(Spine,Standard_True);
357 PrivatePerform( aFace, Profile, AxeProf, Join, Solid);
358 }
359
360 //=======================================================================
361 //function : Perform
362 //purpose :
363 //=======================================================================
364
Perform(const TopoDS_Face & Spine,const TopoDS_Wire & Profile,const gp_Ax3 & AxeProf,const GeomAbs_JoinType Join,const Standard_Boolean Solid)365 void BRepFill_Evolved::Perform(const TopoDS_Face& Spine,
366 const TopoDS_Wire& Profile,
367 const gp_Ax3& AxeProf,
368 const GeomAbs_JoinType Join,
369 const Standard_Boolean Solid)
370 {
371 mySpineType = Standard_True;
372 PrivatePerform( Spine, Profile, AxeProf, Join, Solid);
373 }
374
375 //=======================================================================
376 //function : PrivatePerform
377 //purpose :
378 //=======================================================================
379
PrivatePerform(const TopoDS_Face & Spine,const TopoDS_Wire & Profile,const gp_Ax3 & AxeProf,const GeomAbs_JoinType Join,const Standard_Boolean Solid)380 void BRepFill_Evolved::PrivatePerform(const TopoDS_Face& Spine,
381 const TopoDS_Wire& Profile,
382 const gp_Ax3& AxeProf,
383 const GeomAbs_JoinType Join,
384 const Standard_Boolean Solid)
385 {
386 TopoDS_Shape aLocalShape = Spine.Oriented(TopAbs_FORWARD);
387 mySpine = TopoDS::Face(aLocalShape);
388 // mySpine = TopoDS::Face(Spine.Oriented(TopAbs_FORWARD));
389 aLocalShape = Profile.Oriented(TopAbs_FORWARD);
390 myProfile = TopoDS::Wire(aLocalShape);
391 // myProfile = TopoDS::Wire(Profile.Oriented(TopAbs_FORWARD));
392 myJoinType = Join;
393 myMap.Clear();
394
395 if (myJoinType > GeomAbs_Arc) {
396 throw Standard_NotImplemented();
397 }
398
399 TopTools_ListOfShape WorkProf;
400 TopoDS_Face WorkSpine;
401 TopTools_ListIteratorOfListOfShape WPIte;
402
403 //-------------------------------------------------------------------
404 // Positioning of mySpine and myProfil in the workspace.
405 //-------------------------------------------------------------------
406 TopLoc_Location LSpine = FindLocation(mySpine);
407 gp_Trsf T;
408 T.SetTransformation(AxeProf);
409 TopLoc_Location LProfile (T);
410 TopLoc_Location InitLS = mySpine .Location();
411 TopLoc_Location InitLP = myProfile.Location();
412 TransformInitWork(LSpine,LProfile);
413
414 //------------------------------------------------------------------
415 // projection of the profile and cut of the spine.
416 //------------------------------------------------------------------
417 TopTools_DataMapOfShapeShape MapProf, MapSpine;
418
419 PrepareProfile(WorkProf , MapProf);
420 PrepareSpine (WorkSpine, MapSpine);
421
422 Standard_Real Tol = BRepFill_Confusion();
423 Standard_Boolean YaLeft = Standard_False;
424 Standard_Boolean YaRight = Standard_False;
425 TopoDS_Wire SP;
426
427 for (WPIte.Initialize(WorkProf); WPIte.More(); WPIte.Next()) {
428 SP = TopoDS::Wire(WPIte.Value());
429 if ( Side(SP,Tol) < 4) YaLeft = Standard_True;
430 else YaRight = Standard_True;
431 if (YaLeft && YaRight) break;
432 }
433
434 TopoDS_Face Face;
435 BRepMAT2d_BisectingLocus Locus;
436
437 //----------------------------------------------------------
438 // Initialisation of cut volevo.
439 // For each part of the profile create a volevo added to CutVevo
440 //----------------------------------------------------------
441 BRepFill_Evolved CutVevo;
442 TopoDS_Wire WP;
443 BRep_Builder BB;
444 BRepTools_WireExplorer WExp;
445
446 BB.MakeWire(WP);
447
448 for (WPIte.Initialize(WorkProf); WPIte.More(); WPIte.Next()) {
449 for (WExp.Init(TopoDS::Wire(WPIte.Value())); WExp.More(); WExp.Next()) {
450 BB.Add(WP,WExp.Current());
451 }
452 }
453 CutVevo.SetWork(WorkSpine,WP);
454
455 BRepTools_Quilt Glue;
456 Standard_Integer CSide;
457
458 //---------------------------------
459 // Construction of vevos to the left.
460 //---------------------------------
461 if (YaLeft) {
462 //-----------------------------------------------------
463 // Calculate the map of bisector locations at the left.
464 // and links Topology -> base elements of the map.
465 //-----------------------------------------------------
466 BRepMAT2d_Explorer Exp(WorkSpine);
467 Locus.Compute(Exp,1,MAT_Left);
468 BRepMAT2d_LinkTopoBilo Link(Exp,Locus);
469
470 for (WPIte.Initialize(WorkProf); WPIte.More(); WPIte.Next()) {
471 SP = TopoDS::Wire(WPIte.Value());
472 CSide = Side(SP,Tol);
473 //-----------------------------------------------
474 // Construction and adding of elementary volevo.
475 //-----------------------------------------------
476 BRepFill_Evolved Vevo;
477 if ( CSide == 1) {
478 Vevo.ElementaryPerform (WorkSpine, SP, Locus, Link, Join);
479 }
480 else if (CSide == 2) {
481 Vevo.PlanarPerform (WorkSpine, SP, Locus, Link, Join);
482 }
483 else if (CSide == 3) {
484 Vevo.VerticalPerform (WorkSpine, SP, Locus, Link, Join);
485 }
486 CutVevo.Add (Vevo, SP, Glue);
487 }
488 }
489
490 //---------------------------------
491 // Construction of vevos to the right.
492 //---------------------------------
493 if (YaRight) {
494 //-----------------------------------
495 // Decomposition of the face into wires.
496 //-----------------------------------
497 TopExp_Explorer SpineExp (WorkSpine, TopAbs_WIRE);
498 for ( ; SpineExp.More(); SpineExp.Next()) {
499 //----------------------------------------------
500 // Calculate the map to the right of the current wire.
501 //----------------------------------------------
502 BRepLib_MakeFace B(gp_Pln(0.,0.,1.,0.));
503 TopoDS_Shape aLocalShapeRev = SpineExp.Current().Reversed();
504 B.Add(TopoDS::Wire(aLocalShapeRev));
505 // B.Add(TopoDS::Wire(SpineExp.Current().Reversed()));
506 Face = B.Face();
507 BRepMAT2d_Explorer Exp(Face);
508 Locus.Compute(Exp,1,MAT_Left);
509 BRepMAT2d_LinkTopoBilo Link(Exp,Locus);
510
511 for (WPIte.Initialize(WorkProf); WPIte.More(); WPIte.Next()) {
512 SP = TopoDS::Wire(WPIte.Value());
513 CSide = Side(SP,Tol);
514 //-----------------------------------------------
515 // Construction and adding of an elementary volevo
516 //-----------------------------------------------
517 BRepFill_Evolved Vevo;
518 if ( CSide == 4) {
519 Vevo.ElementaryPerform (Face, SP, Locus, Link, Join);
520 }
521 else if (CSide == 5) {
522 Vevo.PlanarPerform (Face, SP, Locus, Link, Join);
523 }
524 else if (CSide == 6) {
525 Vevo.VerticalPerform (Face, SP, Locus, Link, Join);
526 }
527 CutVevo.Add (Vevo, SP, Glue);
528 }
529 }
530 }
531
532 if (Solid) CutVevo.AddTopAndBottom(Glue);
533
534 //-------------------------------------------------------------------------
535 // Gluing of regularites on parallel edges generate4d by vertices of the
536 // cut of the profile.
537 //-------------------------------------------------------------------------
538 CutVevo.ContinuityOnOffsetEdge(WorkProf);
539
540 //-----------------------------------------------------------------
541 // construction of the shape via the quilt, ie:
542 // - sharing of topologies of elementary added volevos.
543 // - Orientation of faces correspondingly to each other.
544 //-----------------------------------------------------------------
545 TopoDS_Shape& SCV = CutVevo.ChangeShape();
546 SCV = Glue.Shells();
547 //------------------------------------------------------------------------
548 // Transfer of the map of generated elements and of the shape of Cutvevo
549 // in myMap and repositioning in the initial space.
550 //------------------------------------------------------------------------
551 Transfert (CutVevo, MapProf, MapSpine, LSpine.Inverted(), InitLS, InitLP);
552
553 //Orientation of the solid.
554 if (Solid) MakeSolid();
555
556 // modified by NIZHNY-EAP Mon Jan 24 11:26:48 2000 ___BEGIN___
557 BRepLib::UpdateTolerances(myShape,Standard_False);
558 // modified by NIZHNY-EAP Mon Jan 24 11:26:50 2000 ___END___
559 myIsDone = Standard_True;
560 }
561
562
563
564 //=======================================================================
565 //function : IsInversed
566 //purpose :
567 //=======================================================================
568
IsInversed(const TopoDS_Shape & S,const TopoDS_Edge & E1,const TopoDS_Edge & E2,Standard_Boolean * Inverse)569 static void IsInversed(const TopoDS_Shape& S,
570 const TopoDS_Edge& E1,
571 const TopoDS_Edge& E2,
572 Standard_Boolean* Inverse)
573 {
574
575 Inverse[0] = Inverse[1] = 0;
576 if (S.ShapeType() != TopAbs_EDGE) return;
577
578 gp_Pnt P;
579 gp_Vec DS,DC1,DC2 ;
580 BRepAdaptor_Curve CS(TopoDS::Edge(S));
581 if (S.Orientation() == TopAbs_FORWARD) {
582 CS.D1(CS.FirstParameter(),P,DS);
583 }
584 else {
585 CS.D1(CS.LastParameter(),P,DS);
586 DS.Reverse();
587 }
588
589
590 if (!BRep_Tool::Degenerated(E1)) {
591 BRepAdaptor_Curve C1(TopoDS::Edge(E1));
592 if (E1.Orientation() == TopAbs_FORWARD) {
593 C1.D1(C1.FirstParameter(),P,DC1);
594 }
595 else {
596 C1.D1(C1.LastParameter(),P,DC1);
597 DC1.Reverse();
598 }
599 Inverse[0] = (DS.Dot(DC1) < 0.);
600 }
601 else Inverse[0] = 1;
602
603 if (!BRep_Tool::Degenerated(E2)) {
604 BRepAdaptor_Curve C2(TopoDS::Edge(E2));
605 if (E2.Orientation() == TopAbs_FORWARD) {
606 C2.D1(C2.FirstParameter(),P,DC2);
607 }
608 else {
609 C2.D1(C2.LastParameter(),P,DC2);
610 DC2.Reverse();
611 }
612 Inverse[1] = (DS.Dot(DC2) < 0.);
613 }
614 else Inverse[1] = 1;
615 }
616
617 //=======================================================================
618 //function : SetWork
619 //purpose :
620 //=======================================================================
621
SetWork(const TopoDS_Face & Sp,const TopoDS_Wire & Pr)622 void BRepFill_Evolved::SetWork(const TopoDS_Face& Sp,
623 const TopoDS_Wire& Pr)
624 {
625 mySpine = Sp;
626 myProfile = Pr;
627 }
628
629 //=======================================================================
630 //function : ConcaveSide
631 //purpose : Determine if the pipes were at the side of the
632 // concavity. In this case they can be closed.
633 // WARNING: Not finished. Done only for circles.
634 //=======================================================================
635
ConcaveSide(const TopoDS_Shape & S,const TopoDS_Face & F)636 static Standard_Boolean ConcaveSide(const TopoDS_Shape& S,
637 const TopoDS_Face& F)
638 {
639
640 if (S.ShapeType() == TopAbs_VERTEX) return Standard_False;
641
642 if (S.ShapeType() == TopAbs_EDGE) {
643 Standard_Real f,l;
644 Handle(Geom2d_Curve) G2d =
645 BRep_Tool::CurveOnSurface(TopoDS::Edge(S),F,f,l);
646 Handle(Geom2d_Curve) G2dOC;
647
648 Geom2dAdaptor_Curve AC(G2d,f,l);
649 if ( AC.GetType() == GeomAbs_Circle) {
650 Standard_Boolean Direct = AC.Circle().IsDirect();
651 if (S.Orientation() == TopAbs_REVERSED) Direct = (!Direct);
652 return Direct;
653 }
654 }
655 return Standard_False;
656 }
657
658 //=======================================================================
659 //function : ElementaryPerform
660 //purpose :
661 //=======================================================================
662
ElementaryPerform(const TopoDS_Face & Sp,const TopoDS_Wire & Pr,const BRepMAT2d_BisectingLocus & Locus,BRepMAT2d_LinkTopoBilo & Link,const GeomAbs_JoinType)663 void BRepFill_Evolved::ElementaryPerform (const TopoDS_Face& Sp,
664 const TopoDS_Wire& Pr,
665 const BRepMAT2d_BisectingLocus& Locus,
666 BRepMAT2d_LinkTopoBilo& Link,
667 const GeomAbs_JoinType /*Join*/)
668 {
669
670 #ifdef DRAW
671 if (AffichEdge) {
672 char name[100];
673 sprintf(name,"PROFIL_%d",++NbPROFILS);
674 DBRep::Set(name,Pr);
675 }
676 #endif
677 TopoDS_Shape aLocalShape = Sp.Oriented(TopAbs_FORWARD);
678 mySpine = TopoDS::Face(aLocalShape);
679 // mySpine = TopoDS::Face(Sp.Oriented(TopAbs_FORWARD));
680 myProfile = Pr;
681 myMap.Clear();
682
683 BRep_Builder myBuilder;
684 myBuilder.MakeCompound(TopoDS::Compound(myShape));
685
686 //---------------------------------------------------------------------
687 // MapNodeVertex : associate to each node of the map (key1) and
688 // to each element of the profile (key2) a vertex (item).
689 // MapBis : a set of edges or vertexes (item) generated by
690 // a bisectrice on a face or an edge (key) of
691 // tubes or revolutions.
692 // MapVerPar : Map of parameters of vertices on parallel edges
693 // the list contained in MapVerPar (E) corresponds
694 // to parameters on E of vertices contained in MapBis(E);
695 // MapBS : links BasicElt of the map => Topology of the spine.
696 //---------------------------------------------------------------------
697
698
699 BRepFill_DataMapOfNodeDataMapOfShapeShape MapNodeVertex;
700 TopTools_DataMapOfShapeSequenceOfShape MapBis;
701 BRepFill_DataMapOfShapeSequenceOfReal MapVerPar;
702
703 TopTools_DataMapOfShapeShape EmptyMap;
704 TopTools_SequenceOfShape EmptySeq;
705 TopTools_ListOfShape EmptyList;
706 TColStd_SequenceOfReal EmptySeqOfReal;
707
708 // mark of the profile.
709 gp_Ax3 AxeRef(gp_Pnt(0.,0.,0.),
710 gp_Dir(0.,0.,1.),
711 gp_Dir(1.,0.,0.));
712
713 //---------------------------------------------------------------
714 // Construction of revolutions and tubes.
715 //---------------------------------------------------------------
716 BRepTools_WireExplorer ProfExp;
717 TopExp_Explorer FaceExp;
718 BRepTools_WireExplorer WireExp;
719
720 for (FaceExp.Init(mySpine,TopAbs_WIRE); FaceExp.More(); FaceExp.Next()){
721
722 for (WireExp.Init(TopoDS::Wire(FaceExp.Current())); WireExp.More();
723 WireExp.Next()) {
724
725 TopoDS_Edge CurrentEdge = WireExp.Current();
726 TopoDS_Vertex VFirst,VLast;
727 EdgeVertices(CurrentEdge,VFirst,VLast);
728
729 for (Link.Init(VLast); Link.More(); Link.Next()) {
730 //----------------------------.
731 //Construction of a Revolution
732 //----------------------------.
733 MakeRevol (CurrentEdge, VLast, AxeRef);
734 }
735
736 for (Link.Init(CurrentEdge); Link.More(); Link.Next()) {
737 //------------------------.
738 //Construction of a Tube
739 //-------------------------
740 MakePipe (CurrentEdge, AxeRef);
741 }
742 }
743 }
744
745 #ifdef DRAW
746 if (AffichEdge) {
747 std::cout << " End Construction of geometric primitives"<<std::endl;
748 }
749 #endif
750
751 //---------------------------------------------------
752 // Construction of edges associated to bissectrices.
753 //---------------------------------------------------
754 Handle(MAT_Arc) CurrentArc;
755 Handle(Geom2d_Curve) Bis, PCurve1, PCurve2 ;
756 Handle(Geom_Curve) CBis;
757 Standard_Boolean Reverse;
758 TopoDS_Edge CurrentEdge;
759 TopoDS_Shape S [2];
760 TopoDS_Face F [2];
761 TopoDS_Edge E [4];
762 TopLoc_Location L;
763 Standard_Integer k;
764
765 for (Standard_Integer i = 1; i <= Locus.Graph()->NumberOfArcs(); i++) {
766 CurrentArc = Locus.Graph()->Arc(i);
767 SimpleExpression(Locus.GeomBis(CurrentArc,Reverse), Bis);
768
769 //------------------------------------------------------------------
770 // Return elements of the spine corresponding to separate basicElts.
771 //------------------------------------------------------------------
772 S [0] = Link.GeneratingShape(CurrentArc->FirstElement());
773 S [1] = Link.GeneratingShape(CurrentArc->SecondElement());
774
775 Standard_Boolean Concave0 = ConcaveSide(S[0],mySpine);
776 Standard_Boolean Concave1 = ConcaveSide(S[1],mySpine);
777
778 TopTools_SequenceOfShape VOnF,VOnL;
779 TColgp_SequenceOfPnt ParOnF,ParOnL;
780
781 TopTools_DataMapOfShapeSequenceOfShape MapSeqVer;
782 BRepFill_DataMapOfShapeSequenceOfPnt MapSeqPar;
783
784 Standard_Integer vv = 0;
785 for(ProfExp.Init(myProfile); ProfExp.More(); ProfExp.Next()) {
786 vv++;
787 //-----------------------------------------------
788 // Return two faces separated by the bissectrice.
789 //-----------------------------------------------
790 F [0] = TopoDS::Face(myMap(S[0])(ProfExp.Current()).First());
791 F [1] = TopoDS::Face(myMap(S[1])(ProfExp.Current()).First());
792
793 //------------------------------------
794 // Return parallel edges on each face.
795 //------------------------------------
796 TopoDS_Vertex VF,VL;
797
798 EdgeVertices(ProfExp.Current(),VF,VL);
799
800 E [0] = TopoDS::Edge(myMap(S[0])(VF).First());
801 E [1] = TopoDS::Edge(myMap(S[0])(VL).First());
802 E [2] = TopoDS::Edge(myMap(S[1])(VF).First());
803 E [3] = TopoDS::Edge(myMap(S[1])(VL).First());
804
805 Standard_Boolean Inv0[2];
806 Standard_Boolean Inv1[2];
807
808 Inv0[0] = Inv0[1] = Inv1[0]= Inv1[1] = 0;
809 if (Concave0) IsInversed(S[0],E[0],E[1],Inv0);
810 if (Concave1) IsInversed(S[1],E[2],E[3],Inv1);
811
812 //---------------------------------------------
813 // Construction of geometries.
814 //---------------------------------------------
815 BRepFill_TrimSurfaceTool Trim (Bis,F[0],F[1],
816 E[0],E[2],Inv0[0],Inv1[0]);
817 //-----------------------------------------------------------
818 //Construction of vertices corresponding to the node of the map
819 //-----------------------------------------------------------
820 TopoDS_Vertex VS,VE;
821 Handle(MAT_Node) Node1, Node2;
822
823 if (Reverse) {
824 Node1 = CurrentArc->SecondNode();
825 Node2 = CurrentArc->FirstNode();
826 }
827 else {
828 Node1 = CurrentArc->FirstNode();
829 Node2 = CurrentArc->SecondNode();
830 }
831 //--------------------------------------------------------
832 // Particular case when the node is on a vertex of the spine.
833 //--------------------------------------------------------
834 if (Node1->OnBasicElt()) {
835 if (S[0].ShapeType() == TopAbs_VERTEX) {
836 Node1 = CurrentArc->FirstElement()->StartArc()->FirstNode();
837 }
838 else if (S[1].ShapeType() == TopAbs_VERTEX) {
839 Node1 = CurrentArc->SecondElement()->StartArc()->FirstNode();
840 }
841 }
842 // End of particular case.
843
844 Standard_Integer
845 StartOnF = VertexFromNode(Node1,
846 TopoDS::Edge(ProfExp.Current()),
847 VF, VL ,
848 MapNodeVertex,VS);
849
850 Standard_Integer
851 EndOnF = VertexFromNode(Node2,
852 TopoDS::Edge(ProfExp.Current()),
853 VF, VL ,
854 MapNodeVertex,VE);
855
856 //-----------------------------------------------------------
857 // Construction of vertices on edges parallel to the spine.
858 //-----------------------------------------------------------
859 if (!MapSeqVer.IsBound(VF)) {
860 if (Inv0 [0] || Inv1 [0]) {
861 ParOnF.Clear();
862 VOnF .Clear();
863 }
864 else {
865 Trim.IntersectWith(E [0], E [2], ParOnF);
866 VOnF .Clear();
867 for (Standard_Integer s = 1; s <= ParOnF.Length(); s++) {
868 TopoDS_Vertex VC;
869 myBuilder.MakeVertex (VC);
870 VOnF.Append(VC);
871 }
872 if (StartOnF == 1) {
873 VOnF .SetValue(1,VS);
874 }
875 if (EndOnF == 1) {
876 VOnF .SetValue(ParOnF.Length(),VE);
877 }
878 }
879 }
880 else {
881 ParOnF = MapSeqPar(VF);
882 VOnF = MapSeqVer(VF);
883 }
884
885 if (!MapSeqVer.IsBound(VL)) {
886 if (Inv0 [1] || Inv1 [1]) {
887 ParOnL.Clear();
888 VOnL .Clear();
889 }
890 else {
891 Trim.IntersectWith(E [1], E [3], ParOnL);
892 VOnL.Clear();
893 for (Standard_Integer s = 1; s <= ParOnL.Length(); s++) {
894 TopoDS_Vertex VC;
895 myBuilder.MakeVertex (VC);
896 VOnL.Append(VC);
897 }
898 if (StartOnF == 3) {
899 VOnL .SetValue(1,VS);
900 }
901 if (EndOnF == 3) {
902 VOnL .SetValue(ParOnL.Length(),VE);
903 }
904 }
905 }
906 else {
907 ParOnL = MapSeqPar(VL);
908 VOnL = MapSeqVer(VL);
909 }
910
911 //------------------------------------------------------
912 // Test if the Bissectrice is not projected on the face
913 //------------------------------------------------------
914 if ((StartOnF == 0) && (EndOnF == 0) &&
915 VOnL.IsEmpty() && VOnF.IsEmpty())
916 // No trace of the bisectrice on the face.
917 continue;
918
919 if ((StartOnF == 0) && (EndOnF == 0) &&
920 (VOnL.Length() + VOnF.Length() == 1))
921 // the first or last node of the arc is on the edge
922 // but the arc is not on the face.
923 continue;
924
925 //---------------------------------------------------------
926 // determine the intervals of the bissectrice that are
927 // projected on F[0] and F[1].
928 //---------------------------------------------------------
929 TColStd_SequenceOfReal LastPar,FirstPar;
930 TopTools_SequenceOfShape FirstV,LastV;
931
932 ComputeIntervals (VOnF,VOnL,ParOnF,ParOnL,Trim,Bis,
933 VS,VE,FirstPar,LastPar,FirstV,LastV);
934
935 for (Standard_Integer Ti = 1; Ti <= FirstPar.Length(); Ti++) {
936 TopoDS_Vertex V1 = TopoDS::Vertex(FirstV.Value(Ti));
937 TopoDS_Vertex V2 = TopoDS::Vertex(LastV .Value(Ti));
938
939 GeomAbs_Shape Continuity;
940
941 Trim.Project(FirstPar.Value(Ti),LastPar.Value(Ti),
942 CBis,PCurve1,PCurve2,Continuity);
943
944 //-------------------------------------
945 // Coding of the edge.
946 //-------------------------------------
947 myBuilder.MakeEdge(CurrentEdge, CBis,
948 BRepFill_Confusion());
949
950 myBuilder.UpdateVertex(V1,CBis->Value(CBis->FirstParameter()),
951 BRepFill_Confusion());
952 myBuilder.UpdateVertex(V2,CBis->Value(CBis->LastParameter()),
953 BRepFill_Confusion());
954
955 myBuilder.Add(CurrentEdge,V1.Oriented(TopAbs_FORWARD));
956 myBuilder.Add(CurrentEdge,V2.Oriented(TopAbs_REVERSED));
957
958 myBuilder.Range(CurrentEdge,
959 CBis->FirstParameter(),
960 CBis->LastParameter());
961 myBuilder.UpdateEdge(CurrentEdge,PCurve1,F[0],BRepFill_Confusion());
962 myBuilder.UpdateEdge(CurrentEdge,PCurve2,F[1],BRepFill_Confusion());
963
964 myBuilder.Continuity(CurrentEdge,F[0],F[1],Continuity);
965
966 #ifdef DRAW
967 if (AffichEdge) {
968 char name[100];
969 sprintf(name,"ARCEDGE_%d_%d_%d",i,vv,Ti);
970 DBRep::Set(name,CurrentEdge);
971 }
972 #endif
973 //-------------------------------------------
974 // Storage of the edge for each of faces.
975 //-------------------------------------------
976 for (k = 0; k <= 1;k++) {
977 if (!MapBis.IsBound(F[k])) {
978 MapBis.Bind(F[k],EmptySeq);
979 }
980 }
981 //---------------------------------------------------------------
982 // orientation of the edge depends on the direction of the skin.
983 // skin => same orientation E[0] , inverted orientation E[2]
984 // if contreskin it is inverted.
985 //--------------------------------------------------------------
986 E[0].Orientation(BRepTools::OriEdgeInFace(E[0],F[0]));
987 E[2].Orientation(BRepTools::OriEdgeInFace(E[2],F[1]));
988
989 if (DistanceToOZ(VF) < DistanceToOZ(VL) ) {
990 // Skin
991 MapBis(F[0]).Append(CurrentEdge.Oriented (E[0].Orientation()));
992 CurrentEdge.Orientation(TopAbs::Complement(E[2].Orientation()));
993 MapBis(F[1]).Append(CurrentEdge);
994 }
995 else {
996 //Contreskin
997 MapBis(F[1]).Append(CurrentEdge.Oriented (E[2].Orientation()));
998 CurrentEdge.Orientation(TopAbs::Complement(E[0].Orientation()));
999 MapBis(F[0]).Append(CurrentEdge);
1000 }
1001 }
1002
1003 //----------------------------------------------
1004 // Storage of vertices on parallel edges.
1005 // fill MapBis and MapVerPar.
1006 // VOnF for E[0] and E[2].
1007 // VOnL for E[1] and E[3].
1008 //----------------------------------------------
1009 for (k = 0; k <= 2; k = k+2) {
1010 if ( !MapSeqVer.IsBound(VF)) {
1011 if (!VOnF.IsEmpty()) {
1012 if (!MapBis.IsBound(E[k])) {
1013 MapBis .Bind(E[k],EmptySeq);
1014 MapVerPar.Bind(E[k],EmptySeqOfReal);
1015 }
1016 for (Standard_Integer ii = 1; ii <= VOnF.Length(); ii++) {
1017 MapBis (E[k]).Append(VOnF.Value(ii));
1018 if (k == 0) MapVerPar (E[k]).Append(ParOnF.Value(ii).Y());
1019 else MapVerPar (E[k]).Append(ParOnF.Value(ii).Z());
1020 }
1021 }
1022 }
1023 }
1024
1025 for (k = 1; k <= 3; k = k+2) {
1026 if ( !MapSeqVer.IsBound(VL)) {
1027 if (!VOnL.IsEmpty()) {
1028 if (!MapBis.IsBound(E[k])) {
1029 MapBis .Bind(E[k],EmptySeq);
1030 MapVerPar.Bind(E[k],EmptySeqOfReal);
1031 }
1032 for (Standard_Integer ii = 1; ii <= VOnL.Length(); ii++) {
1033 MapBis(E[k]).Append(VOnL.Value(ii));
1034 if (k == 1) MapVerPar (E[k]).Append(ParOnL.Value(ii).Y());
1035 else MapVerPar (E[k]).Append(ParOnL.Value(ii).Z());
1036 }
1037 }
1038 }
1039 }
1040
1041 //----------------------------------------------------------------
1042 // Edge [1] of the current face will be Edge [0] of the next face.
1043 // => copy of VonL in VonF. To avoid creating the same vertices twice.
1044 //-----------------------------------------------------------------
1045
1046 MapSeqPar.Bind(VF,ParOnF);
1047 MapSeqVer.Bind(VF,VOnF);
1048 MapSeqPar.Bind(VL,ParOnL);
1049 MapSeqVer.Bind(VL,VOnL);
1050
1051 }
1052 }
1053
1054 #ifdef DRAW
1055 if (AffichEdge) {
1056 std::cout << " End of Construction of edges and vertices on bissectrices"<<std::endl;
1057 }
1058 #endif
1059
1060 //----------------------------------
1061 // Construction of parallel edges.
1062 //----------------------------------
1063 BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape ite1;
1064 TopoDS_Shape CurrentProf,PrecProf;
1065 TopoDS_Face CurrentFace;
1066 TopoDS_Shape CurrentSpine;
1067 TopoDS_Vertex VCF,VCL;
1068
1069 for (ite1.Initialize(myMap); ite1.More(); ite1.Next()) {
1070 CurrentSpine = ite1.Key();
1071
1072 for (ProfExp.Init(myProfile); ProfExp.More(); ProfExp.Next()){
1073 CurrentProf = ProfExp.Current();
1074 EdgeVertices(TopoDS::Edge(CurrentProf),VCF,VCL);
1075 CurrentEdge = TopoDS::Edge(myMap(CurrentSpine)(VCF).First());
1076
1077 //-------------------------------------------------------------
1078 //RQ : Current Edge is oriented relatively to the face (oriented forward)
1079 // generated by edge CurrentProf .
1080 //-------------------------------------------------------------
1081 if (MapBis.IsBound(CurrentEdge)) {
1082
1083 //--------------------------------------------------------
1084 // Find if one of two faces connected to the edge
1085 // belongs to volevo. The edges on this face serve
1086 // to eliminate certain vertices that can appear twice
1087 // on the parallel edge. These Vertices correspond to the
1088 // nodes of the map.
1089 //---------------------------------------------------------
1090 TopoDS_Shape FaceControle;
1091 Standard_Boolean YaFace = Standard_True;
1092
1093 FaceControle = myMap(CurrentSpine)(CurrentProf).First();
1094 if (!MapBis.IsBound(FaceControle)){
1095 YaFace = Standard_False;
1096 if (!PrecProf.IsNull()) {
1097 FaceControle = myMap(CurrentSpine)(PrecProf).First();
1098 if (MapBis.IsBound(FaceControle)){
1099 YaFace = Standard_True;
1100 }
1101 }
1102 }
1103
1104 if (YaFace) {
1105 //------------------------------------------------------------
1106 // No connected face in the volevo => no parallel edge.
1107 //------------------------------------------------------------
1108 TopTools_SequenceOfShape aSeqOfShape;
1109 TrimEdge (CurrentEdge,
1110 MapBis (FaceControle),
1111 MapBis (CurrentEdge) ,
1112 MapVerPar(CurrentEdge) , aSeqOfShape);
1113
1114 for ( k = 1; k <= aSeqOfShape.Length(); k++) {
1115 myMap(CurrentSpine)(VCF).Append(aSeqOfShape.Value(k));
1116
1117 #ifdef DRAW
1118 if (AffichEdge) {
1119 char name[100];
1120 sprintf(name,"PAREDGE_%d_%d",++NbEDGES,k);
1121 DBRep::Set(name,aSeqOfShape.Value(k));
1122 }
1123 #endif
1124 }
1125 }
1126 }
1127 PrecProf = CurrentProf;
1128 }
1129
1130 //------------------------------------------------------------
1131 // Construction of the parallel edge from the last vertex of myProfile.
1132 //------------------------------------------------------------
1133 CurrentEdge = TopoDS::Edge(myMap(CurrentSpine)(VCL).First());
1134
1135 if (MapBis.IsBound(CurrentEdge)) {
1136 Standard_Boolean YaFace = Standard_True;
1137 TopoDS_Shape FaceControle;
1138
1139 FaceControle = myMap(CurrentSpine)(CurrentProf).First();
1140 if (!MapBis.IsBound(FaceControle)){
1141 YaFace = Standard_False;
1142 }
1143 // the number of element of the list allows to know
1144 // if the edges have already been done (closed profile) .
1145 if (YaFace && myMap(CurrentSpine)(VCL).Extent()<= 1) {
1146 TopTools_SequenceOfShape aSeqOfShape;
1147 TrimEdge (CurrentEdge,
1148 MapBis (FaceControle),
1149 MapBis (CurrentEdge) ,
1150 MapVerPar(CurrentEdge) , aSeqOfShape);
1151
1152 for ( k = 1; k <= aSeqOfShape.Length(); k++) {
1153 myMap(CurrentSpine)(VCL).Append(aSeqOfShape.Value(k));
1154
1155 #ifdef DRAW
1156 if (AffichEdge) {
1157 char name[100];
1158 sprintf(name,"PAREDGE_%d_%d",++NbEDGES,k);
1159 DBRep::Set(name,aSeqOfShape.Value(k));
1160 }
1161 #endif
1162 }
1163 }
1164 }
1165 }
1166
1167 #ifdef DRAW
1168 if (AffichEdge) {
1169 std::cout <<" End Construction of parallel edges "<<std::endl;
1170 }
1171 #endif
1172
1173 //-------------------------------------------------------------------
1174 // Cut faces by edges.
1175 //-------------------------------------------------------------------
1176 for (ite1.Initialize(myMap); ite1.More(); ite1.Next()) {
1177 CurrentSpine = ite1.Key();
1178
1179 for (ProfExp.Init(myProfile); ProfExp.More(); ProfExp.Next()){
1180 CurrentProf = ProfExp.Current();
1181 CurrentFace = TopoDS::Face(myMap(CurrentSpine)(CurrentProf).First());
1182 myMap(CurrentSpine)(CurrentProf).Clear();
1183
1184 if (MapBis.IsBound(CurrentFace)) {
1185 //----------------------------------------------------------
1186 // If the face does not contain edges that can limit it
1187 // it does not appear in volevo.
1188 // cut of face by edges can generate many faces.
1189 //
1190 // Add edges generated on the edges parallel to the set
1191 // of edges that limit the face.
1192 //
1193 //------------------------------------------------------------
1194 EdgeVertices(TopoDS::Edge(CurrentProf),VCF,VCL);
1195
1196 TopTools_ListIteratorOfListOfShape itl;
1197 const TopTools_ListOfShape& LF = myMap(CurrentSpine)(VCF);
1198
1199 TopAbs_Orientation Ori = BRepTools::OriEdgeInFace(TopoDS::Edge(LF.First()),
1200 CurrentFace);
1201 for (itl.Initialize(LF), itl.Next(); itl.More(); itl.Next()) {
1202 TopoDS_Edge RE = TopoDS::Edge(itl.Value());
1203 MapBis(CurrentFace).Append(RE.Oriented(Ori));
1204 }
1205 const TopTools_ListOfShape& LL = myMap(CurrentSpine)(VCL);
1206 Ori = BRepTools::OriEdgeInFace(TopoDS::Edge(LL.First()),CurrentFace);
1207 for (itl.Initialize(LL), itl.Next() ; itl.More(); itl.Next()) {
1208 TopoDS_Edge RE = TopoDS::Edge(itl.Value());
1209 MapBis(CurrentFace).Append(RE.Oriented(Ori));
1210 }
1211
1212 //Cut of the face.
1213 TopTools_SequenceOfShape aSeqOfShape;
1214
1215 TrimFace (CurrentFace, MapBis(CurrentFace), aSeqOfShape);
1216
1217 for (Standard_Integer ii = 1; ii <= aSeqOfShape.Length(); ii++) {
1218 myBuilder.Add (myShape, aSeqOfShape.Value(ii));
1219 myMap(CurrentSpine)(CurrentProf).Append(aSeqOfShape.Value(ii));
1220 }
1221 }
1222 }
1223 //-----------------------------------------------------------------
1224 // Removal of first edge (edge of origin) from lists of myMap
1225 // corresponding to vertices of the profile.
1226 //-----------------------------------------------------------------
1227 TopExp_Explorer Explo(myProfile,TopAbs_VERTEX);
1228 TopTools_MapOfShape vmap;
1229
1230 for ( ; Explo.More(); Explo.Next()){
1231 if (vmap.Add(Explo.Current())) {
1232 myMap(CurrentSpine)(Explo.Current()).RemoveFirst();
1233 }
1234 }
1235 }
1236 myIsDone = Standard_True;
1237
1238 #ifdef DRAW
1239 if (AffichEdge) {
1240 std::cout <<" End of construction of an elementary volevo."<<std::endl;
1241 char name[100];
1242 sprintf(name,"VEVO_%d",++NbVEVOS);
1243 DBRep::Set(name,myShape);
1244 }
1245 #endif
1246 }
1247
1248 //=======================================================================
1249 //function : PlanarPerform
1250 //purpose :
1251 //=======================================================================
1252
PlanarPerform(const TopoDS_Face & Sp,const TopoDS_Wire & Pr,const BRepMAT2d_BisectingLocus & Locus,BRepMAT2d_LinkTopoBilo & Link,const GeomAbs_JoinType Join)1253 void BRepFill_Evolved::PlanarPerform (const TopoDS_Face& Sp,
1254 const TopoDS_Wire& Pr,
1255 const BRepMAT2d_BisectingLocus& Locus,
1256 BRepMAT2d_LinkTopoBilo& Link,
1257 const GeomAbs_JoinType Join)
1258 {
1259 TopoDS_Shape aLocalShapeOriented = Sp.Oriented(TopAbs_FORWARD);
1260 mySpine = TopoDS::Face(aLocalShapeOriented);
1261 // mySpine = TopoDS::Face(Sp.Oriented(TopAbs_FORWARD));
1262 myProfile = Pr;
1263 myMap.Clear();
1264
1265 BRep_Builder B;
1266 B.MakeCompound(TopoDS::Compound(myShape));
1267
1268 BRepTools_WireExplorer ProfExp;
1269 TopExp_Explorer Exp,exp1,exp2;
1270 TopTools_DataMapOfShapeListOfShape EmptyMap;
1271 TopTools_ListOfShape EmptyList;
1272 TopTools_DataMapOfShapeShape MapVP;
1273 BRepFill_OffsetWire Paral;
1274
1275 for (ProfExp.Init(myProfile); ProfExp.More(); ProfExp.Next()){
1276 const TopoDS_Edge& E = ProfExp.Current();
1277 BRepAlgo_FaceRestrictor FR;
1278 BRepFill_OffsetAncestors OffAnc;
1279
1280 TopoDS_Vertex V[2];
1281 EdgeVertices(E,V[0],V[1]);
1282 Standard_Real Alt = Altitud(V[0]);
1283 Standard_Real Offset[2];
1284 Offset[0] = DistanceToOZ(V[0]);
1285 Offset[1] = DistanceToOZ(V[1]);
1286 Standard_Boolean IsMinV1 = ( Offset[0] < Offset[1]);
1287
1288 for (Standard_Integer i = 0; i <= 1; i++) {
1289 if (!MapVP.IsBound(V[i])) {
1290 //------------------------------------------------
1291 // Calculate parallel lines corresponding to vertices.
1292 //------------------------------------------------
1293 Paral.PerformWithBiLo(mySpine,Offset[i],Locus,Link,Join,Alt);
1294 OffAnc.Perform(Paral);
1295 MapVP.Bind(V[i],Paral.Shape());
1296
1297 //-----------------------------
1298 // Update myMap (.)(V[i])
1299 //-----------------------------
1300 for (Exp.Init(Paral.Shape(),TopAbs_EDGE);
1301 Exp.More();
1302 Exp.Next()) {
1303 const TopoDS_Edge& WC = TopoDS::Edge(Exp.Current());
1304 const TopoDS_Shape& GS = OffAnc.Ancestor(WC);
1305 if ( !myMap.IsBound(GS))
1306 myMap.Bind(GS, EmptyMap);
1307 if ( !myMap(GS).IsBound(V[i]))
1308 myMap(GS).Bind(V[i],Paral.GeneratedShapes(GS));
1309 }
1310 }
1311 TopoDS_Shape Rest = MapVP(V[i]);
1312
1313 Standard_Boolean ToReverse = Standard_False;
1314 if ( ( IsMinV1 && (i==1)) || (!IsMinV1 && (i==0)) )
1315 ToReverse = Standard_True;
1316
1317 if (!Rest.IsNull()) {
1318 if (Rest.ShapeType() == TopAbs_WIRE) {
1319 if ( ToReverse){
1320 TopoDS_Shape aLocalShape = Rest.Reversed();
1321 TopoDS_Wire aWire = TopoDS::Wire(aLocalShape);
1322 FR.Add(aWire);
1323 }
1324 else
1325 FR.Add(TopoDS::Wire(Rest));
1326 }
1327 else {
1328 for (Exp.Init(Rest,TopAbs_WIRE);Exp.More();Exp.Next()) {
1329 TopoDS_Wire WCop = TopoDS::Wire(Exp.Current());
1330 if ( ToReverse){
1331 TopoDS_Shape aLocalShape = WCop.Reversed();
1332 TopoDS_Wire bWire = TopoDS::Wire(aLocalShape);
1333 // TopoDS_Wire bWire = TopoDS::Wire(WCop.Reversed());
1334 FR.Add(bWire);
1335 }
1336 else
1337 FR.Add(WCop);
1338 }
1339 }
1340 }
1341 }
1342 #ifdef DRAW
1343 if (AffichEdge) {
1344 TopTools_DataMapIteratorOfDataMapOfShapeShape it(MapVP);
1345 Standard_Integer k = 0;
1346 for (; it.More(); it.Next()) {
1347 char name[100];
1348 sprintf(name,"PARALI_%d",++k);
1349 DBRep::Set(name,it.Value());
1350 }
1351 }
1352 #endif
1353
1354 //----------------------------------------------------
1355 // Construction of faces limited by parallels.
1356 // - set to the height of the support face.
1357 //----------------------------------------------------
1358 gp_Trsf T; T.SetTranslation(gp_Vec(0,0,Alt));
1359 TopLoc_Location LT(T);
1360 TopoDS_Shape aLocalShape = mySpine.Moved(LT);
1361 FR.Init(TopoDS::Face(aLocalShape));
1362 // FR.Init(TopoDS::Face(mySpine.Moved(LT)));
1363 FR.Perform();
1364
1365 for ( ;FR.More(); FR.Next()) {
1366 const TopoDS_Face& F = FR.Current();
1367 B.Add(myShape,F);
1368 //---------------------------------------
1369 // Update myMap(.)(E)
1370 //---------------------------------------
1371 for ( Exp.Init(F,TopAbs_EDGE); Exp.More(); Exp.Next()) {
1372 const TopoDS_Edge& CE = TopoDS::Edge(Exp.Current());
1373 if (OffAnc.HasAncestor(CE)) {
1374 const TopoDS_Shape& InitE = OffAnc.Ancestor(CE);
1375 if ( !myMap.IsBound(InitE))
1376 myMap.Bind(InitE, EmptyMap);
1377 if ( !myMap(InitE).IsBound(E))
1378 myMap(InitE).Bind(E,EmptyList);
1379 myMap(InitE)(E).Append(F);
1380 }
1381 }
1382 }
1383 } // End loop on profile.
1384 }
1385
1386
1387 //=======================================================================
1388 //function : VerticalPerform
1389 //purpose :
1390 //=======================================================================
1391
VerticalPerform(const TopoDS_Face & Sp,const TopoDS_Wire & Pr,const BRepMAT2d_BisectingLocus & Locus,BRepMAT2d_LinkTopoBilo & Link,const GeomAbs_JoinType Join)1392 void BRepFill_Evolved::VerticalPerform (const TopoDS_Face& Sp,
1393 const TopoDS_Wire& Pr,
1394 const BRepMAT2d_BisectingLocus& Locus,
1395 BRepMAT2d_LinkTopoBilo& Link,
1396 const GeomAbs_JoinType Join)
1397 {
1398 TopoDS_Shape aLocalShape = Sp.Oriented(TopAbs_FORWARD);
1399 mySpine = TopoDS::Face(aLocalShape);
1400 // mySpine = TopoDS::Face(Sp.Oriented(TopAbs_FORWARD));
1401 myProfile = Pr;
1402 myMap.Clear();
1403
1404 BRep_Builder B;
1405 B.MakeCompound(TopoDS::Compound(myShape));
1406
1407 BRepTools_WireExplorer ProfExp;
1408 TopExp_Explorer Exp;
1409 BRepFill_OffsetWire Paral;
1410 BRepFill_OffsetAncestors OffAnc;
1411 TopoDS_Vertex V1,V2;
1412
1413 Standard_Boolean First = Standard_True;
1414 TopoDS_Shape Base;
1415 TopTools_DataMapOfShapeListOfShape EmptyMap;
1416
1417 for (ProfExp.Init(myProfile); ProfExp.More(); ProfExp.Next()){
1418 const TopoDS_Edge& E = ProfExp.Current();
1419 EdgeVertices(E,V1,V2);
1420 Standard_Real Alt1 = Altitud(V1);
1421 Standard_Real Alt2 = Altitud(V2);
1422
1423 if (First) {
1424 Standard_Real Offset = DistanceToOZ(V1);
1425 if (Abs(Offset) < BRepFill_Confusion()) {
1426 Offset = 0.;
1427 }
1428 Paral.PerformWithBiLo(mySpine,Offset,Locus,Link,Join,Alt1);
1429 OffAnc.Perform(Paral);
1430 Base = Paral.Shape();
1431
1432 // MAJ myMap
1433 for (Exp.Init(Base,TopAbs_EDGE); Exp.More(); Exp.Next()) {
1434 const TopoDS_Edge& anEdge = TopoDS::Edge(Exp.Current());
1435 const TopoDS_Shape& AE = OffAnc.Ancestor(anEdge);
1436 if (!myMap.IsBound(AE)) {
1437 myMap.Bind(AE,EmptyMap);
1438 }
1439 if (!myMap(AE).IsBound(V1)) {
1440 TopTools_ListOfShape L;
1441 myMap(AE).Bind(V1,L);
1442 }
1443 myMap(AE)(V1).Append(anEdge);
1444 }
1445 First = Standard_False;
1446 }
1447
1448
1449 #ifdef DRAW
1450 if (AffichEdge) {
1451 char name[100];
1452 sprintf(name,"PARALI_%d",++NbVEVOS);
1453 DBRep::Set(name,Base);
1454 }
1455 #endif
1456
1457 BRepSweep_Prism PS(Base,gp_Vec(0,0,Alt2 - Alt1),Standard_False);
1458 #ifdef DRAW
1459 if (AffichEdge) {
1460 char name[100];
1461 sprintf(name,"PRISM_%d",NbVEVOS);
1462 DBRep::Set(name,PS.Shape());
1463 }
1464 #endif
1465
1466 Base = PS.LastShape();
1467
1468 for (Exp.Init(PS.Shape(),TopAbs_FACE); Exp.More(); Exp.Next()) {
1469 B.Add(myShape,Exp.Current());
1470 }
1471
1472 // MAJ myMap
1473 BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape
1474 it(myMap);
1475
1476 for (; it.More(); it.Next()) {
1477 const TopTools_ListOfShape& LOF = it.Value()(V1);
1478 TopTools_ListIteratorOfListOfShape itLOF(LOF);
1479 if (!myMap(it.Key()).IsBound(V2)) {
1480 TopTools_ListOfShape L;
1481 myMap(it.Key()).Bind(V2,L);
1482 }
1483
1484 if (!myMap(it.Key()).IsBound(E)) {
1485 TopTools_ListOfShape L;
1486 myMap(it.Key()).Bind(E,L);
1487 }
1488
1489 for (; itLOF.More(); itLOF.Next()) {
1490 const TopoDS_Shape& OS = itLOF.Value();
1491 myMap(it.Key())(V2).Append(PS.LastShape(OS));
1492 myMap(it.Key())(E).Append(PS.Shape(OS));
1493 }
1494 }
1495 }
1496 }
1497
1498 //=======================================================================
1499 //function : Bubble
1500 //purpose : Order the sequence of points by growing x.
1501 //=======================================================================
1502
Bubble(TColStd_SequenceOfReal & Seq)1503 static void Bubble(TColStd_SequenceOfReal& Seq)
1504 {
1505 Standard_Boolean Invert = Standard_True;
1506 Standard_Integer NbPoints = Seq.Length();
1507
1508 while (Invert) {
1509 Invert = Standard_False;
1510 for ( Standard_Integer i = 1; i < NbPoints; i++) {
1511 if ( Seq.Value(i+1) < Seq.Value(i)) {
1512 Seq.Exchange(i,i+1);
1513 Invert = Standard_True;
1514 }
1515 }
1516 }
1517 }
1518
1519
1520 //=======================================================================
1521 //function : PrepareProfile
1522 //purpose : - Projection of the profile on the working plane.
1523 // - Cut of the profile at the extrema of distance from profile to axis Oz.
1524 // - Isolate vertical and horizontal parts.
1525 // - Reconstruction of wires starting from cut edges.
1526 // New wires stored in <WorkProf> are always at the same
1527 // side of axis OZ or mixed with it.
1528 //=======================================================================
1529
PrepareProfile(TopTools_ListOfShape & WorkProf,TopTools_DataMapOfShapeShape & MapProf) const1530 void BRepFill_Evolved::PrepareProfile(TopTools_ListOfShape& WorkProf,
1531 TopTools_DataMapOfShapeShape& MapProf )
1532 const
1533 {
1534 // Supposedly the profile is located so that the only transformation
1535 // to be carried out is a projection on plane yOz.
1536
1537 // initialise the projection Plane and the Line to evaluate the extrema.
1538 Handle(Geom_Plane) Plane = new Geom_Plane(gp_Ax3(gp::YOZ()));
1539 Handle(Geom2d_Line) Line = new Geom2d_Line(gp::OY2d());
1540
1541 // Map initial vertex -> projected vertex.
1542 TopTools_DataMapOfShapeShape MapVerRefMoved;
1543
1544 TopoDS_Vertex V1,V2,VRef1,VRef2;
1545 TopoDS_Wire W;
1546 BRep_Builder B;
1547 TopTools_ListOfShape WP;
1548 B.MakeWire(W);
1549 WP.Append(W);
1550
1551 BRepTools_WireExplorer Exp(myProfile) ;
1552
1553 while (Exp.More()) {
1554 TopTools_ListOfShape Cuts;
1555 Standard_Boolean NewWire = Standard_False;
1556 const TopoDS_Edge& E = TopoDS::Edge(Exp.Current());
1557
1558 // Cut of the edge.
1559 CutEdgeProf (E ,Plane ,Line ,Cuts ,MapVerRefMoved);
1560
1561 EdgeVertices(E,VRef1,VRef2);
1562
1563 if ( Cuts.IsEmpty()) {
1564 // Neither extrema nor intersections nor vertices on the axis.
1565 B.Add(W,E);
1566 MapProf.Bind(E,E);
1567 }
1568 else {
1569 while (!Cuts.IsEmpty()) {
1570 const TopoDS_Edge& NE = TopoDS::Edge(Cuts.First());
1571 MapProf.Bind(NE,E);
1572 EdgeVertices(NE,V1,V2);
1573 if (!MapProf.IsBound(V1)) MapProf.Bind(V1,E);
1574 if (!MapProf.IsBound(V2)) MapProf.Bind(V2,E);
1575
1576 B.Add(W,NE);
1577 Cuts.RemoveFirst();
1578
1579 if (DistanceToOZ(V2) < BRepFill_Confusion() &&
1580 DistanceToOZ(V1) > BRepFill_Confusion()) {
1581 // NE ends on axis OZ => new wire
1582 if (Cuts.IsEmpty()) {
1583 // last part of the current edge
1584 // If it is not the last edge of myProfile
1585 // create a new wire.
1586 NewWire = Standard_True;
1587 }
1588 else {
1589 // New wire.
1590 B.MakeWire(W);
1591 WP.Append(W);
1592 }
1593 }
1594 }
1595 }
1596 Exp.Next();
1597 if (Exp.More() && NewWire) {
1598 B.MakeWire(W);
1599 WP.Append(W);
1600 }
1601 }
1602
1603 // In the list of Wires, find edges generating plane or vertical vevo.
1604 TopTools_ListIteratorOfListOfShape ite;
1605 TopoDS_Wire CurW,NW;
1606 TopExp_Explorer EW;
1607
1608
1609 for (ite.Initialize(WP); ite.More(); ite.Next()) {
1610 CurW = TopoDS::Wire(ite.Value());
1611 Standard_Boolean YaModif = Standard_False;
1612 for (EW.Init(CurW,TopAbs_EDGE); EW.More(); EW.Next()) {
1613 const TopoDS_Edge& EE = TopoDS::Edge(EW.Current());
1614 if (IsVertical(EE) || IsPlanar(EE)) {
1615 YaModif = Standard_True;
1616 break;
1617 }
1618 }
1619
1620 if (YaModif) {
1621 //Status = 0 for the beginning
1622 // 3 vertical
1623 // 2 horizontal
1624 // 1 other
1625 Standard_Integer Status = 0;
1626
1627 for (EW.Init(CurW,TopAbs_EDGE); EW.More(); EW.Next()) {
1628 const TopoDS_Edge& EE = TopoDS::Edge(EW.Current());
1629 if (IsVertical(EE)) {
1630 if (Status != 3) {
1631 B.MakeWire(NW);
1632 WorkProf.Append(NW);
1633 Status = 3;
1634 }
1635 }
1636 else if (IsPlanar(EE)) {
1637 if (Status != 2) {
1638 B.MakeWire(NW);
1639 WorkProf.Append(NW);
1640 Status = 2;
1641 }
1642 }
1643 else if ( Status != 1) {
1644 B.MakeWire(NW);
1645 WorkProf.Append(NW);
1646 Status = 1;
1647 }
1648 B.Add(NW,EE);
1649 }
1650 }
1651 else {
1652 WorkProf.Append(CurW);
1653 }
1654 }
1655
1656 //connect vertices modified in MapProf;
1657 TopTools_DataMapIteratorOfDataMapOfShapeShape gilbert(MapVerRefMoved);
1658 for ( ;gilbert.More() ;gilbert.Next()) {
1659 MapProf.Bind(gilbert.Value(),gilbert.Key());
1660 }
1661 }
1662
1663
1664 //=======================================================================
1665 //function : PrepareSpine
1666 //purpose :
1667 //=======================================================================
1668
PrepareSpine(TopoDS_Face & WorkSpine,TopTools_DataMapOfShapeShape & MapSpine) const1669 void BRepFill_Evolved::PrepareSpine(TopoDS_Face& WorkSpine,
1670 TopTools_DataMapOfShapeShape& MapSpine)
1671 const
1672 {
1673 BRep_Builder B;
1674 TopTools_ListOfShape Cuts;
1675 TopTools_ListIteratorOfListOfShape IteCuts;
1676 TopoDS_Vertex V1,V2;
1677
1678 TopLoc_Location L;
1679 const Handle(Geom_Surface)& S = BRep_Tool::Surface (mySpine,L);
1680 Standard_Real TolF = BRep_Tool::Tolerance(mySpine);
1681 B.MakeFace(WorkSpine,S,L,TolF);
1682
1683 for (TopoDS_Iterator IteF(mySpine) ; IteF.More(); IteF.Next()) {
1684
1685 TopoDS_Wire NW;
1686 B.MakeWire (NW);
1687 Standard_Boolean IsClosed = IteF.Value().Closed();
1688
1689 for (TopoDS_Iterator IteW(IteF.Value()); IteW.More(); IteW.Next()) {
1690
1691 TopoDS_Edge E = TopoDS::Edge(IteW.Value());
1692 EdgeVertices(E,V1,V2);
1693 MapSpine.Bind(V1,V1);
1694 MapSpine.Bind(V2,V2);
1695 Cuts.Clear();
1696
1697 // Cut
1698 CutEdge (E, mySpine, Cuts);
1699
1700 if (Cuts.IsEmpty()) {
1701 B.Add(NW,E);
1702 MapSpine.Bind(E,E);
1703 }
1704 else {
1705 for (IteCuts.Initialize(Cuts); IteCuts.More(); IteCuts.Next()) {
1706 const TopoDS_Edge& NE = TopoDS::Edge(IteCuts.Value());
1707 B.Add(NW,NE);
1708 MapSpine.Bind(NE,E);
1709 EdgeVertices(NE,V1,V2);
1710 if (!MapSpine.IsBound(V1)) MapSpine.Bind(V1,E);
1711 if (!MapSpine.IsBound(V2)) MapSpine.Bind(V2,E);
1712 }
1713 }
1714 }
1715 NW.Closed(IsClosed);
1716 B.Add(WorkSpine, NW);
1717 }
1718
1719 // Construct curves 3D of the spine
1720 BRepLib::BuildCurves3d(WorkSpine);
1721
1722 #ifdef DRAW
1723 if (AffichEdge) {
1724 char name[100];
1725 sprintf(name,"workspine");
1726 DBRep::Set(name,WorkSpine);
1727 }
1728 #endif
1729
1730 }
1731 //=======================================================================
1732 //function : GeneratedShapes
1733 //purpose :
1734 //=======================================================================
1735
Top() const1736 const TopoDS_Shape& BRepFill_Evolved::Top() const
1737 {
1738 return myTop;
1739 }
1740
1741 //=======================================================================
1742 //function : GeneratedShapes
1743 //purpose :
1744 //=======================================================================
1745
Bottom() const1746 const TopoDS_Shape& BRepFill_Evolved::Bottom() const
1747 {
1748 return myBottom;
1749 }
1750
1751 //=======================================================================
1752 //function : GeneratedShapes
1753 //purpose :
1754 //=======================================================================
1755
GeneratedShapes(const TopoDS_Shape & SpineShape,const TopoDS_Shape & ProfShape) const1756 const TopTools_ListOfShape& BRepFill_Evolved::GeneratedShapes (
1757 const TopoDS_Shape& SpineShape,
1758 const TopoDS_Shape& ProfShape )
1759 const
1760 {
1761 if (myMap .IsBound(SpineShape) &&
1762 myMap(SpineShape).IsBound(ProfShape) ) {
1763 return myMap(SpineShape)(ProfShape);
1764 }
1765 else {
1766 static TopTools_ListOfShape Empty;
1767 return Empty;
1768 }
1769 }
1770
1771 //=======================================================================
1772 //function : Generated
1773 //purpose :
1774 //=================================================================== ====
1775
Generated()1776 BRepFill_DataMapOfShapeDataMapOfShapeListOfShape& BRepFill_Evolved::Generated()
1777 {
1778 return myMap;
1779 }
1780
1781 //=======================================================================
1782 //function : Compare
1783 //purpose :
1784 //=======================================================================
1785
Compare(const TopoDS_Edge & E1,const TopoDS_Edge & E2)1786 static TopAbs_Orientation Compare (const TopoDS_Edge& E1,
1787 const TopoDS_Edge& E2)
1788 {
1789 TopAbs_Orientation OO = TopAbs_FORWARD;
1790 TopoDS_Vertex V1[2],V2[2];
1791 TopExp::Vertices (E1,V1[0],V1[1]);
1792 TopExp::Vertices (E2,V2[0],V2[1]);
1793 gp_Pnt P1 = BRep_Tool::Pnt(V1[0]);
1794 gp_Pnt P2 =BRep_Tool::Pnt(V2[0]);
1795 gp_Pnt P3 =BRep_Tool::Pnt(V2[1]);
1796 if (P1.Distance(P3) < P1.Distance(P2)) OO = TopAbs_REVERSED;
1797
1798 return OO;
1799 }
1800
1801 //=======================================================================
1802 //function : Add
1803 //purpose :
1804 //=======================================================================
1805
Add(BRepFill_Evolved & Vevo,const TopoDS_Wire & Prof,BRepTools_Quilt & Glue)1806 void BRepFill_Evolved::Add( BRepFill_Evolved& Vevo,
1807 const TopoDS_Wire& Prof,
1808 BRepTools_Quilt& Glue)
1809
1810 {
1811 BRepFill_DataMapOfShapeDataMapOfShapeListOfShape& MapVevo = Vevo.Generated();
1812 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iteP;
1813 BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape iteS;
1814 TopoDS_Shape CurrentSpine, CurrentProf;
1815
1816 if (Vevo.Shape().IsNull()) return;
1817
1818 //-------------------------------------------------
1819 // Find wires common to <me> and <Vevo>.
1820 //-------------------------------------------------
1821
1822 TopExp_Explorer ExProf;
1823 for (ExProf.Init(Prof,TopAbs_VERTEX); ExProf.More(); ExProf.Next()) {
1824 const TopoDS_Shape& VV = ExProf.Current();
1825 //---------------------------------------------------------------
1826 // Parse edges generated by VV in myMap if they existent
1827 // and Bind in Glue
1828 //---------------------------------------------------------------
1829
1830 //------------------------------------------------- -------------
1831 // Note: the curves of of reinforced edges are in the same direction
1832 // if one remains on the same edge.
1833 // if one passes from left to the right they are inverted.
1834 //------------------------------------------------- -------------
1835 Standard_Boolean Commun = Standard_False;
1836 Relative(myProfile,Prof,
1837 TopoDS::Vertex(VV),
1838 Commun);
1839
1840 if (Commun) {
1841 for (iteS.Initialize(myMap); iteS.More(); iteS.Next()) {
1842 const TopoDS_Shape& SP = iteS.Key();
1843 if (iteS.Value().IsBound(VV) &&
1844 MapVevo.IsBound(SP) && MapVevo(SP).IsBound(VV)) {
1845
1846 const TopTools_ListOfShape& MyList = myMap(SP)(VV);
1847 const TopTools_ListOfShape& VevoList = Vevo.GeneratedShapes(SP,VV);
1848 TopTools_ListIteratorOfListOfShape MyIte (MyList);
1849 TopTools_ListIteratorOfListOfShape VevoIte(VevoList);
1850 for (; MyIte.More(); MyIte.Next(), VevoIte.Next()) {
1851 const TopoDS_Edge& ME = TopoDS::Edge(MyIte .Value());
1852 const TopoDS_Edge& VE = TopoDS::Edge(VevoIte.Value());
1853 TopAbs_Orientation OG = Compare(ME,VE);
1854 TopoDS_Shape aLocalShape = VE.Oriented (TopAbs_FORWARD);
1855 TopoDS_Shape aLocalShape2 = ME.Oriented (OG);
1856 Glue.Bind(TopoDS::Edge(aLocalShape),TopoDS::Edge(aLocalShape2));
1857 // Glue.Bind(TopoDS::Edge(VE.Oriented (TopAbs_FORWARD)),
1858 // TopoDS::Edge(ME.Oriented (OG)));
1859 }
1860 }
1861 }
1862 }
1863 }
1864 Glue.Add(Vevo.Shape());
1865
1866 //----------------------------------------------------------
1867 // Add map of elements generate in Vevo in myMap.
1868 //----------------------------------------------------------
1869 TopTools_DataMapOfShapeListOfShape EmptyMap;
1870 TopTools_ListOfShape EmptyList;
1871
1872 for (iteS.Initialize(MapVevo); iteS.More() ; iteS.Next()) {
1873 CurrentSpine = iteS.Key();
1874 for (iteP.Initialize(MapVevo(CurrentSpine)); iteP.More(); iteP.Next()) {
1875 CurrentProf = iteP.Key();
1876 if (!myMap.IsBound(CurrentSpine)) {
1877 //------------------------------------------------
1878 // The element of spine is not yet present .
1879 // => previous profile not on the border.
1880 //-------------------------------------------------
1881 myMap.Bind(CurrentSpine,EmptyMap);
1882 }
1883 if (!myMap(CurrentSpine).IsBound(CurrentProf)) {
1884 myMap(CurrentSpine).Bind(CurrentProf,EmptyList);
1885 const TopTools_ListOfShape& GenShapes
1886 = MapVevo (CurrentSpine)(CurrentProf);
1887 TopTools_ListIteratorOfListOfShape itl (GenShapes);
1888 for (; itl.More(); itl.Next()) {
1889 // during Glue.Add the shared shapes are recreated.
1890 if (Glue.IsCopied(itl.Value()))
1891 myMap(CurrentSpine)(CurrentProf).Append(Glue.Copy(itl.Value()));
1892 else
1893 myMap(CurrentSpine)(CurrentProf).Append(itl.Value());
1894 }
1895 }
1896 }
1897 }
1898 }
1899
1900 //=======================================================================
1901 //function : ChangeShape
1902 //purpose :
1903 //=======================================================================
1904
ChangeShape()1905 TopoDS_Shape& BRepFill_Evolved::ChangeShape()
1906 {
1907 return myShape;
1908 }
1909
1910 //=======================================================================
1911 //function : Transfert
1912 //purpose :
1913 //=======================================================================
1914
Transfert(BRepFill_Evolved & Vevo,const TopTools_DataMapOfShapeShape & MapProf,const TopTools_DataMapOfShapeShape & MapSpine,const TopLoc_Location & LS,const TopLoc_Location & InitLS,const TopLoc_Location & InitLP)1915 void BRepFill_Evolved::Transfert( BRepFill_Evolved& Vevo,
1916 const TopTools_DataMapOfShapeShape& MapProf,
1917 const TopTools_DataMapOfShapeShape& MapSpine,
1918 const TopLoc_Location& LS,
1919 const TopLoc_Location& InitLS,
1920 const TopLoc_Location& InitLP)
1921 {
1922 //----------------------------------------------------------------
1923 // Transfer the shape from Vevo in myShape and Reposition shapes.
1924 //----------------------------------------------------------------
1925 myShape = Vevo.Shape();
1926 mySpine .Location(InitLS);
1927 myProfile.Location(InitLP);
1928 myShape .Move (LS);
1929
1930 //
1931 // Expecting for better, the Same Parameter is forced here
1932 // ( Pb Sameparameter between YaPlanar and Tuyaux
1933 //
1934 BRep_Builder B;
1935 TopExp_Explorer ex(myShape,TopAbs_EDGE);
1936 while (ex.More()) {
1937 B.SameRange(TopoDS::Edge(ex.Current()), Standard_False);
1938 B.SameParameter(TopoDS::Edge(ex.Current()), Standard_False);
1939 BRepLib::SameParameter(TopoDS::Edge(ex.Current()));
1940 ex.Next();
1941 }
1942
1943
1944 //--------------------------------------------------------------
1945 // Transfer of myMap of Vevo into myMap.
1946 //--------------------------------------------------------------
1947 BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape iteS;
1948 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iteP;
1949 TopTools_DataMapOfShapeListOfShape EmptyMap;
1950 TopTools_ListOfShape EmptyList;
1951 TopoDS_Shape InitialSpine, InitialProf;
1952
1953 BRepFill_DataMapOfShapeDataMapOfShapeListOfShape& MapVevo
1954 = Vevo.Generated();
1955
1956 for (iteS.Initialize(MapVevo); iteS.More(); iteS.Next()) {
1957 InitialSpine = MapSpine(iteS.Key());
1958 InitialSpine.Move(LS);
1959
1960 for (iteP.Initialize(MapVevo(iteS.Key())); iteP.More(); iteP.Next()) {
1961 InitialProf = MapProf (iteP.Key());
1962 InitialProf.Location(InitLP);
1963
1964 TopTools_ListOfShape& GenShapes =
1965 MapVevo.ChangeFind(iteS.Key()).ChangeFind(iteP.Key());
1966
1967 TopTools_ListIteratorOfListOfShape itl;
1968 for (itl.Initialize(GenShapes); itl.More(); itl.Next()) {
1969 itl.Value().Move(LS);
1970 }
1971
1972 if (!myMap.IsBound(InitialSpine)) {
1973 myMap.Bind(InitialSpine,EmptyMap);
1974 }
1975
1976 if (!myMap(InitialSpine).IsBound(InitialProf)) {
1977 myMap(InitialSpine).Bind(InitialProf,EmptyList);
1978 }
1979 myMap(InitialSpine)(InitialProf).Append(GenShapes);
1980 }
1981 }
1982 //--------------------------------------------------------------
1983 // Transfer of Top and Bottom of Vevo in myTop and myBottom.
1984 //--------------------------------------------------------------
1985 myTop = Vevo.Top() ; myTop.Move(LS);
1986 myBottom = Vevo.Bottom(); myBottom.Move(LS);
1987 }
1988
1989 //=======================================================================
1990 //function : IsDone
1991 //purpose :
1992 //=======================================================================
1993
IsDone() const1994 Standard_Boolean BRepFill_Evolved::IsDone() const
1995 {
1996 return myIsDone;
1997 }
1998
1999 //=======================================================================
2000 //function : Shape
2001 //purpose :
2002 //=======================================================================
2003
Shape() const2004 const TopoDS_Shape& BRepFill_Evolved::Shape() const
2005 {
2006 return myShape;
2007 }
2008
2009 //=======================================================================
2010 //function : JoinType
2011 //purpose :
2012 //=======================================================================
2013
JoinType() const2014 GeomAbs_JoinType BRepFill_Evolved::JoinType() const
2015 {
2016 return myJoinType;
2017 }
2018
2019 //=======================================================================
2020 //function : AddTopAndBottom
2021 //purpose :
2022 //=======================================================================
2023
AddTopAndBottom(BRepTools_Quilt & Glue)2024 void BRepFill_Evolved::AddTopAndBottom(BRepTools_Quilt& Glue)
2025 {
2026 // return first and last vertex of the profile.
2027 TopoDS_Vertex V[2];
2028 TopExp::Vertices (myProfile,V[0],V[1]);
2029 if (V[0].IsSame(V[1])) return;
2030
2031 TopTools_ListIteratorOfListOfShape itL;
2032 Standard_Boolean ToReverse=Standard_False;
2033 for (Standard_Integer i = 0; i<=1; i++) {
2034
2035 BRepAlgo_Loop Loop;
2036 // Construction of supports.
2037 gp_Pln S (0.,0.,1.,- Altitud(V[i]));
2038 TopoDS_Face F = BRepLib_MakeFace(S);
2039 Loop.Init(F);
2040
2041 TopExp_Explorer ExpSpine(mySpine,TopAbs_EDGE);
2042 TopTools_MapOfShape View;
2043
2044 for (; ExpSpine.More(); ExpSpine.Next()) {
2045 const TopoDS_Edge& ES = TopoDS::Edge(ExpSpine.Current());
2046 const TopTools_ListOfShape& L = GeneratedShapes(ES,V[i]);
2047 Standard_Boolean ComputeOrientation = 0;
2048
2049 for (itL.Initialize(L); itL.More(); itL.Next()) {
2050 const TopoDS_Edge& E = TopoDS::Edge(itL.Value());
2051
2052 if (!ComputeOrientation) {
2053 BRepAdaptor_Curve C1(ES);
2054 BRepAdaptor_Curve C2(E);
2055 Standard_Real f,l,fs,ls;
2056 BRep_Tool::Range(E ,f ,l);
2057 BRep_Tool::Range(ES,fs,ls);
2058 Standard_Real u = 0.3*f + 0.7*l;
2059 Standard_Real us = 0.3*fs + 0.7*ls;
2060 gp_Pnt P;
2061 gp_Vec V1,V2;
2062 C1.D1(us,P,V1); C2.D1(u,P,V2);
2063 ToReverse = (V1.Dot(V2) < 0.);
2064 ComputeOrientation = 1;
2065 }
2066
2067 TopAbs_Orientation Or = ES.Orientation();
2068 if (ToReverse) Or = TopAbs::Reverse(Or);
2069 TopoDS_Shape aLocalShape = E.Oriented(Or);
2070 Loop.AddConstEdge(TopoDS::Edge(aLocalShape));
2071 // Loop.AddConstEdge(TopoDS::Edge(E.Oriented(Or)));
2072 }
2073 }
2074
2075 gp_Pnt PV = BRep_Tool::Pnt(V[i]);
2076 Standard_Boolean IsOut = PV.Y() < 0;
2077
2078 for (ExpSpine.Init(mySpine,TopAbs_VERTEX); ExpSpine.More(); ExpSpine.Next()) {
2079 const TopoDS_Vertex& ES = TopoDS::Vertex(ExpSpine.Current());
2080 if (View.Add(ES)) {
2081 const TopTools_ListOfShape& L = GeneratedShapes(ES,V[i]);
2082 for (itL.Initialize(L); itL.More(); itL.Next()) {
2083 const TopoDS_Edge& E = TopoDS::Edge(itL.Value());
2084 if (!BRep_Tool::Degenerated(E)){
2085 // the center of circle (ie vertex) is IN the cap if vertex IsOut
2086 // OUT !IsOut
2087 BRepAdaptor_Curve C(E);
2088 Standard_Real f,l;
2089 BRep_Tool::Range(E,f,l);
2090 Standard_Real u = 0.3*f + 0.7*l;
2091 gp_Pnt P = BRep_Tool::Pnt(ES);
2092 gp_Pnt PC;
2093 gp_Vec VC;
2094 C.D1(u,PC,VC);
2095 gp_Vec aPPC(P,PC);
2096 gp_Vec Prod = aPPC.Crossed(VC);
2097 if (IsOut) {
2098 ToReverse = Prod.Z() < 0.;
2099 }
2100 else {
2101 ToReverse = Prod.Z() > 0.;
2102 }
2103 TopAbs_Orientation Or = TopAbs_FORWARD;
2104 if (ToReverse) Or = TopAbs_REVERSED;
2105 TopoDS_Shape aLocalShape = E.Oriented(Or);
2106 Loop.AddConstEdge(TopoDS::Edge(aLocalShape));
2107 // Loop.AddConstEdge(TopoDS::Edge(E.Oriented(Or)));
2108 }
2109 }
2110 }
2111 }
2112
2113 Loop.Perform();
2114 Loop.WiresToFaces();
2115 const TopTools_ListOfShape& L = Loop.NewFaces();
2116 TopTools_ListIteratorOfListOfShape anIterL(L);
2117
2118 // Maj of myTop and myBottom for the history
2119 // and addition of constructed faces.
2120 TopoDS_Compound Bouchon;
2121 BRep_Builder B;
2122 B.MakeCompound(Bouchon);
2123 Standard_Integer j = 0;
2124
2125 for (anIterL.Initialize(L); anIterL.More(); anIterL.Next()) {
2126 j++;
2127 Glue.Add(anIterL.Value());
2128 if (j ==1 && i == 0) myTop = anIterL.Value();
2129 if (j ==1 && i == 1) myBottom = anIterL.Value();
2130 B.Add(Bouchon,anIterL.Value());
2131 }
2132 if (i == 0 && j > 1) myTop = Bouchon;
2133 if (i == 1 && j > 1) myBottom = Bouchon;
2134 }
2135 }
2136
2137 //================================================================== =====
2138 //function : MakePipe
2139 //purpose :
2140 //=======================================================================
2141
MakeSolid()2142 void BRepFill_Evolved::MakeSolid()
2143 {
2144
2145 TopExp_Explorer exp(myShape,TopAbs_SHELL);
2146 Standard_Integer ish=0;
2147 TopoDS_Compound Res;
2148 TopoDS_Solid Sol;
2149 BRep_Builder B;
2150 B.MakeCompound(Res);
2151
2152 for (; exp.More(); exp.Next()) {
2153 TopoDS_Shape Sh = exp.Current();
2154 B.MakeSolid(Sol);
2155 B.Add(Sol,Sh);
2156 BRepClass3d_SolidClassifier SC(Sol);
2157 SC.PerformInfinitePoint(BRepFill_Confusion());
2158 if (SC.State() == TopAbs_IN) {
2159 B.MakeSolid(Sol);
2160 B.Add(Sol,Sh.Reversed());
2161 }
2162 B.Add(Res,Sol);
2163 ish++;
2164 }
2165 if (ish == 1) { myShape = Sol;}
2166 else { myShape = Res;}
2167
2168 }
2169
2170 //=======================================================================
2171 //function : MakePipe
2172 //purpose :
2173 //=======================================================================
2174
MakePipe(const TopoDS_Edge & SE,const gp_Ax3 & AxeRef)2175 void BRepFill_Evolved::MakePipe(const TopoDS_Edge& SE,
2176 const gp_Ax3& AxeRef)
2177 {
2178 BRepTools_WireExplorer ProfExp;
2179 TopExp_Explorer FaceExp;
2180
2181 gp_Trsf trsf;
2182 if (Side(myProfile,BRepFill_Confusion()) > 3) { // side right
2183 trsf.SetRotation(gp::OZ(),M_PI);
2184 }
2185 TopLoc_Location DumLoc (trsf);
2186 TopoDS_Shape aLocalShape = myProfile.Moved(DumLoc);
2187 TopoDS_Wire DummyProf =
2188 PutProfilAt (TopoDS::Wire(aLocalShape),
2189 AxeRef,SE,
2190 mySpine,Standard_True);
2191 // TopoDS_Wire DummyProf =
2192 // PutProfilAt (TopoDS::Wire(myProfile.Moved(DumLoc)),
2193 // AxeRef,SE,
2194 // mySpine,Standard_True);
2195
2196 // Copy of the profile to avoid the accumulation of
2197 // locations on the Edges of myProfile!
2198
2199 Handle(BRepTools_TrsfModification) TrsfMod
2200 = new BRepTools_TrsfModification(gp_Trsf());
2201 BRepTools_Modifier Modif(DummyProf,TrsfMod);
2202
2203 TopoDS_Wire GenProf = TopoDS::Wire(Modif.ModifiedShape(DummyProf));
2204
2205 #ifdef DRAW
2206 if (AffichGeom) {
2207 char name[100];
2208 sprintf(name,"EVOLBASE_%d",++NbFACES);
2209 DBRep::Set(name,SE);
2210 sprintf(name,"EVOLPROF_%d",NbFACES);
2211 DBRep::Set(name,GenProf);
2212 }
2213 #endif
2214
2215 BRepFill_Pipe Pipe(BRepLib_MakeWire(SE), GenProf);
2216 //BRepFill_Pipe Pipe = BRepFill_Pipe(BRepLib_MakeWire(SE),GenProf);
2217
2218 #ifdef DRAW
2219 if (AffichGeom) {
2220 char name[100];
2221 sprintf(name,"EVOL_%d",++NbFACES);
2222 DBRep::Set(name,Pipe.Shape());
2223 }
2224 #endif
2225 //---------------------------------------------
2226 // Arrangement of Tubes in myMap.
2227 //---------------------------------------------
2228
2229 BRepTools_WireExplorer GenProfExp;
2230 TopTools_ListOfShape L;
2231 TopoDS_Vertex VF,VL,VFG,VLG;
2232 Standard_Boolean FirstVertex = Standard_True;
2233 TopTools_DataMapOfShapeListOfShape P;
2234
2235 myMap.Bind(SE,P);
2236
2237 for (ProfExp.Init(myProfile),GenProfExp.Init(GenProf);
2238 ProfExp.More();
2239 ProfExp.Next(),GenProfExp.Next()) {
2240
2241 EdgeVertices(ProfExp .Current(),VF ,VL);
2242 EdgeVertices(GenProfExp.Current(),VFG,VLG);
2243
2244 if (FirstVertex) {
2245 myMap(SE).Bind(VF,L);
2246 myMap(SE)(VF).Append(Pipe.Edge(SE,VFG));
2247 FirstVertex = Standard_False;
2248 }
2249 myMap(SE).Bind(VL,L);
2250 myMap(SE)(VL).Append(Pipe.Edge(SE,VLG));
2251 myMap(SE).Bind(ProfExp.Current(),L);
2252 myMap(SE)(ProfExp.Current()).Append
2253 (Pipe.Face(SE,GenProfExp.Current()));
2254 }
2255 }
2256
2257
2258 //=======================================================================
2259 //function : MakeRevol
2260 //purpose :
2261 //=======================================================================
2262
MakeRevol(const TopoDS_Edge & SE,const TopoDS_Vertex & VLast,const gp_Ax3 & AxeRef)2263 void BRepFill_Evolved::MakeRevol(const TopoDS_Edge& SE,
2264 const TopoDS_Vertex& VLast,
2265 const gp_Ax3& AxeRef)
2266 {
2267 BRepTools_WireExplorer ProfExp;
2268 TopExp_Explorer FaceExp;
2269
2270 gp_Trsf trsf;
2271 if (Side(myProfile,BRepFill_Confusion()) > 3) { // side right
2272 trsf.SetRotation(gp::OZ(),M_PI);
2273 }
2274 TopLoc_Location DumLoc (trsf);
2275 TopoDS_Shape aLocalShape = myProfile.Moved(DumLoc);
2276 TopoDS_Wire GenProf =
2277 PutProfilAt (TopoDS::Wire(aLocalShape),
2278 AxeRef,SE,
2279 mySpine,Standard_False);
2280 // TopoDS_Wire GenProf =
2281 // PutProfilAt (TopoDS::Wire(myProfile.Moved(DumLoc)),
2282 // AxeRef,SE,
2283 // mySpine,Standard_False);
2284
2285 gp_Ax1 AxeRev( BRep_Tool::Pnt(VLast), -gp::DZ());
2286
2287 // Position of the sewing on the edge of the spine
2288 // so that the bissectrices didn't cross the sewings.
2289 gp_Trsf dummy;
2290 dummy.SetRotation(AxeRev, 1.5*M_PI);
2291 TopLoc_Location DummyLoc(dummy);
2292 GenProf.Move(DummyLoc);
2293
2294 BRepSweep_Revol Rev(GenProf,AxeRev,Standard_True);
2295
2296 #ifdef DRAW
2297 if (AffichGeom) {
2298 char name[100];
2299 sprintf(name,"EVOLBASE_%d",++NbFACES);
2300 DrawTrSurf::Set(name,new Geom_Line(AxeRev));
2301 // DrawTrSurf::Set(name,new Geom_Line(AxeRev));
2302 sprintf(name,"EVOLPROF_%d",NbFACES);
2303 DBRep::Set(name,GenProf);
2304
2305 sprintf(name,"EVOL_%d",NbFACES);
2306 DBRep::Set(name,Rev.Shape());
2307 }
2308 #endif
2309 //--------------------------------------------
2310 // Arrangement of revolutions in myMap.
2311 //---------------------------------------------
2312 BRepTools_WireExplorer GenProfExp;
2313 TopTools_ListOfShape L;
2314 TopoDS_Vertex VF,VL,VFG,VLG;
2315 Standard_Boolean FirstVertex = Standard_True;
2316 TopTools_DataMapOfShapeListOfShape R;
2317
2318 myMap.Bind(VLast,R);
2319
2320 for (ProfExp.Init(myProfile),GenProfExp.Init(GenProf);
2321 ProfExp.More();
2322 ProfExp.Next(),GenProfExp.Next()) {
2323
2324 EdgeVertices(ProfExp .Current(),VF ,VL);
2325 EdgeVertices(GenProfExp.Current(),VFG,VLG);
2326
2327 TopAbs_Orientation Or = GenProfExp.Current().Orientation();
2328
2329 if (FirstVertex) {
2330 myMap(VLast).Bind(VF,L);
2331 const TopoDS_Shape& RV = Rev.Shape(VFG);
2332 // TopAbs_Orientation OO = TopAbs::Compose(RV.Orientation(),Or);
2333 TopAbs_Orientation OO = RV.Orientation();
2334 myMap(VLast)(VF).Append(RV.Oriented(OO));
2335 FirstVertex = Standard_False;
2336 }
2337 myMap(VLast).Bind(ProfExp.Current(),L);
2338 const TopoDS_Shape& RF = Rev.Shape(GenProfExp.Current());
2339 TopAbs_Orientation OO = TopAbs::Compose(RF.Orientation(),Or);
2340
2341 myMap(VLast)(ProfExp.Current()).Append(RF.Oriented(OO));
2342 myMap(VLast).Bind(VL,L);
2343 const TopoDS_Shape& RV = Rev.Shape(VLG);
2344 // OO = TopAbs::Compose(RV.Orientation(),Or);
2345 OO = RV.Orientation();
2346 myMap(VLast)(VL).Append(RV.Oriented(OO));
2347 }
2348 }
2349
2350 //=======================================================================
2351 //function : FindLocation
2352 //purpose :
2353 //=======================================================================
2354
FindLocation(const TopoDS_Face & Face) const2355 TopLoc_Location BRepFill_Evolved::FindLocation(const TopoDS_Face& Face)
2356 const
2357 {
2358 TopLoc_Location L;
2359 Handle(Geom_Surface) S;
2360 S = BRep_Tool::Surface(Face, L);
2361
2362 if ( !S->IsKind(STANDARD_TYPE(Geom_Plane))) {
2363 BRepLib_FindSurface FS( Face, -1, Standard_True);
2364 if ( FS.Found()) {
2365 S = FS.Surface();
2366 L = FS.Location();
2367 }
2368 else
2369 throw Standard_NoSuchObject("BRepFill_Evolved : The Face is not planar");
2370 }
2371
2372 if (!L.IsIdentity())
2373 S = Handle(Geom_Surface)::DownCast(S->Transformed(L.Transformation()));
2374
2375 Handle(Geom_Plane) P = Handle(Geom_Plane)::DownCast(S);
2376 gp_Ax3 Axis = P->Position();
2377
2378 gp_Trsf T;
2379 gp_Ax3 AxeRef(gp_Pnt(0.,0.,0.),
2380 gp_Dir(0.,0.,1.),
2381 gp_Dir(1.,0.,0.));
2382 T.SetTransformation(AxeRef,Axis);
2383
2384 return TopLoc_Location(T);
2385 }
2386
2387
2388 //=======================================================================
2389 //function : TransformInitWork
2390 //purpose :
2391 //=======================================================================
2392
TransformInitWork(const TopLoc_Location & LS,const TopLoc_Location & LP)2393 void BRepFill_Evolved::TransformInitWork(const TopLoc_Location& LS,
2394 const TopLoc_Location& LP)
2395 {
2396 mySpine.Move (LS);
2397 myProfile.Move(LP);
2398
2399 #ifdef DRAW
2400 if (AffichEdge) {
2401 char name[100];
2402 sprintf(name,"movedspine");
2403 TopoDS_Face SL = mySpine;
2404 DBRep::Set(name,SL);
2405 sprintf(name,"movedprofile");
2406 TopoDS_Wire PL = myProfile;
2407 DBRep::Set(name,PL);
2408 }
2409 #endif
2410 }
2411
2412
2413 //=======================================================================
2414 //function : ContinuityOnOffsetEdge
2415 //purpose : Coding of regularities on edges parallel to CutVevo
2416 // common to left and right parts of volevo.
2417 //=======================================================================
ContinuityOnOffsetEdge(const TopTools_ListOfShape &)2418 void BRepFill_Evolved::ContinuityOnOffsetEdge (const TopTools_ListOfShape&)
2419 {
2420 BRepTools_WireExplorer WExp ;
2421 BRepFill_DataMapIteratorOfDataMapOfShapeDataMapOfShapeListOfShape iteS;
2422 TopoDS_Vertex VF,VL,V;
2423 TopoDS_Edge PrecE,CurE,FirstE;
2424 BRep_Builder B;
2425
2426
2427 WExp.Init(myProfile);
2428 FirstE = WExp.Current();
2429 PrecE = FirstE;
2430 EdgeVertices (FirstE, VF, V);
2431 if (WExp.More()) WExp.Next();
2432
2433 for (; WExp.More(); WExp.Next()) {
2434 CurE = WExp.Current();
2435 V = WExp.CurrentVertex();
2436
2437 if (DistanceToOZ(V) <= BRepFill_Confusion()) {
2438 // the regularities are already coded on the edges of elementary volevos
2439 Standard_Real U1 = BRep_Tool::Parameter(V,CurE);
2440 Standard_Real U2 = BRep_Tool::Parameter(V,PrecE);
2441 BRepAdaptor_Curve Curve1(CurE);
2442 BRepAdaptor_Curve Curve2(PrecE);
2443 GeomAbs_Shape Continuity = BRepLProp::Continuity(Curve1,Curve2,U1,U2);
2444
2445 if (Continuity >=1) {
2446 //-----------------------------------------------------
2447 //Code continuity for all edges generated by V.
2448 //-----------------------------------------------------
2449 for (iteS.Initialize(myMap); iteS.More(); iteS.Next()) {
2450 const TopoDS_Shape& SP = iteS.Key();
2451 if (myMap (SP).IsBound(V)
2452 && myMap (SP).IsBound(CurE) && myMap (SP).IsBound(PrecE)){
2453 if (!myMap(SP)(V) .IsEmpty() &&
2454 !myMap(SP)(CurE) .IsEmpty() &&
2455 !myMap(SP)(PrecE).IsEmpty() )
2456 B.Continuity (TopoDS::Edge(myMap(SP)(V) .First()),
2457 TopoDS::Face(myMap(SP)(CurE) .First()),
2458 TopoDS::Face(myMap(SP)(PrecE).First()),
2459 Continuity);
2460 }
2461 }
2462 }
2463 }
2464 PrecE = CurE;
2465 }
2466
2467 EdgeVertices (PrecE, V, VL);
2468
2469 if (VF.IsSame(VL)) {
2470 //Closed profile.
2471 Standard_Real U1 = BRep_Tool::Parameter(VF,CurE);
2472 Standard_Real U2 = BRep_Tool::Parameter(VF,FirstE);
2473 BRepAdaptor_Curve Curve1(CurE);
2474 BRepAdaptor_Curve Curve2(FirstE);
2475 GeomAbs_Shape Continuity = BRepLProp::Continuity(Curve1,Curve2,U1,U2);
2476
2477 if (Continuity >=1) {
2478 //---------------------------------------------
2479 //Code continuity for all edges generated by V.
2480 //---------------------------------------------
2481 for (iteS.Initialize(myMap); iteS.More(); iteS.Next()) {
2482 const TopoDS_Shape& SP = iteS.Key();
2483 if (myMap (SP).IsBound(VF)
2484 && myMap (SP).IsBound(CurE) && myMap (SP).IsBound(FirstE)){
2485 if (!myMap(SP)(VF) .IsEmpty() &&
2486 !myMap(SP)(CurE) .IsEmpty() &&
2487 !myMap(SP)(FirstE).IsEmpty() )
2488 B.Continuity (TopoDS::Edge(myMap(SP)(VF) .First()),
2489 TopoDS::Face(myMap(SP)(CurE) .First()),
2490 TopoDS::Face(myMap(SP)(FirstE).First()),
2491 Continuity);
2492 }
2493 }
2494 }
2495 }
2496 }
2497
2498 //=======================================================================
2499 //function : AddDegeneratedEdge
2500 //purpose : degenerated edges can be missing in some face
2501 // the missing degenerated edges have vertices corresponding
2502 // to node of the map.
2503 // Now it is enough to compare points UV of vertices
2504 // on edges with a certain tolerance.
2505 //=======================================================================
2506
AddDegeneratedEdge(TopoDS_Face & F,TopoDS_Wire & W)2507 static void AddDegeneratedEdge(TopoDS_Face& F,
2508 TopoDS_Wire& W)
2509 {
2510 TopLoc_Location L;
2511 Handle(Geom_Surface) S = BRep_Tool::Surface(F,L);
2512 if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
2513 Handle(Geom_Surface) SB = Handle(Geom_RectangularTrimmedSurface)::DownCast(S)->BasisSurface();
2514 if (SB->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
2515 return;
2516 }
2517 }
2518
2519 if (S->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
2520 return;
2521 }
2522
2523
2524 BRep_Builder B;
2525 Standard_Real TolConf = 1.e-4;
2526
2527 Standard_Boolean Change = Standard_True;
2528
2529 while (Change) {
2530 Change = Standard_False;
2531 BRepTools_WireExplorer WE(W,F);
2532 gp_Pnt2d PF,PrevP,P1,P2;
2533 TopoDS_Vertex VF,V1,V2;
2534
2535 for (; WE.More(); WE.Next()) {
2536 const TopoDS_Edge& CE = WE.Current();
2537 EdgeVertices (CE,V1,V2);
2538 if (CE.Orientation() == TopAbs_REVERSED)
2539 BRep_Tool::UVPoints(CE, F, P2, P1);
2540 else
2541 BRep_Tool::UVPoints(CE, F, P1, P2);
2542 if (VF.IsNull()) {
2543 VF = V1;
2544 PF = P1;
2545 }
2546 else {
2547 if (!P1.IsEqual(PrevP,TolConf)) {
2548 // degenerated edge to be inserted.
2549 Change = Standard_True;
2550 gp_Vec2d V(PrevP,P1);
2551 Handle(Geom2d_Line) C2d = new Geom2d_Line(PrevP,gp_Dir2d(V));
2552 Standard_Real f = 0, l = PrevP.Distance(P1);
2553 Handle(Geom2d_TrimmedCurve) CT = new Geom2d_TrimmedCurve(C2d,f,l);
2554 TopoDS_Edge NE = BRepLib_MakeEdge(C2d,S);
2555 B.Degenerated(NE,Standard_True);
2556 B.Add(NE,V1.Oriented(TopAbs_FORWARD));
2557 B.Add(NE,V1.Oriented(TopAbs_REVERSED));
2558 B.Range(NE,f,l);
2559 B.Add(W,NE);
2560 break;
2561 }
2562 }
2563 PrevP = P2;
2564 }
2565 if (!Change && VF.IsSame(V2)) { // closed
2566 if (!PF.IsEqual(P2,TolConf)) {
2567 // Degenerated edge to be inserted.
2568 Change = Standard_True;
2569 gp_Vec2d V(P2,PF);
2570 Handle(Geom2d_Line) C2d = new Geom2d_Line(P2,gp_Dir2d(V));
2571 Standard_Real f = 0, l = P2.Distance(PF);
2572 Handle(Geom2d_TrimmedCurve) CT = new Geom2d_TrimmedCurve(C2d,f,l);
2573 TopoDS_Edge NE = BRepLib_MakeEdge(C2d,S);
2574 B.Degenerated(NE,Standard_True);
2575 B.Add(NE,VF.Oriented(TopAbs_FORWARD));
2576 B.Add(NE,VF.Oriented(TopAbs_REVERSED));
2577 B.Range(NE,f,l);
2578 B.Add(W,NE);
2579 }
2580 }
2581 }
2582 }
2583
2584 //=======================================================================
2585 //function : TrimFace
2586 //purpose :
2587 //=======================================================================
2588
TrimFace(const TopoDS_Face & Face,TopTools_SequenceOfShape & TheEdges,TopTools_SequenceOfShape & S)2589 void TrimFace(const TopoDS_Face& Face,
2590 TopTools_SequenceOfShape& TheEdges,
2591 TopTools_SequenceOfShape& S)
2592 {
2593
2594 #ifdef DRAW
2595 Standard_Integer NB = TheEdges.Length();
2596 if ( AffichEdge) {
2597 char name[100];
2598 std::cout << " TrimFace " << ++NbTRIMFACES;
2599 std::cout << " : " << NB << " edges within the restriction" << std::endl;
2600 for ( Standard_Integer j = 1; j <= NB; j++) {
2601 sprintf(name,"TRIMEDGE_%d_%d",NbTRIMFACES,j);
2602 DBRep::Set(name,TopoDS::Edge(TheEdges.Value(j)));
2603 }
2604 }
2605 #endif
2606
2607
2608 //--------------------------------------
2609 // Creation of wires limiting faces.
2610 //--------------------------------------
2611 BRep_Builder TheBuilder;
2612
2613 Standard_Integer NbEdges;
2614 Standard_Boolean NewWire = Standard_True;
2615 Standard_Boolean AddEdge = Standard_False;
2616 TopoDS_Wire GoodWire;
2617
2618
2619 while ( !TheEdges.IsEmpty()) {
2620
2621 BRepLib_MakeWire MWire(TopoDS::Edge(TheEdges.First()));
2622 GoodWire = MWire.Wire();
2623 TheEdges.Remove(1);
2624 NbEdges = TheEdges.Length();
2625 NewWire = Standard_False;
2626
2627 while (!NewWire) {
2628 AddEdge = Standard_False;
2629
2630 for ( Standard_Integer i = 1; i <= NbEdges && !AddEdge; i++) {
2631 const TopoDS_Edge& E = TopoDS::Edge(TheEdges.Value(i));
2632 if ( BRep_Tool::Degenerated(E)) {
2633 TheEdges.Remove(i);
2634 AddEdge = Standard_True;
2635 NbEdges = TheEdges.Length();
2636 GoodWire = MWire.Wire();
2637 }
2638 else {
2639 MWire.Add(E);
2640 if ( MWire.Error() == BRepLib_WireDone) {
2641 // the connection is successful
2642 // it is removed from the sequence and one restarts from the beginning.
2643 TheEdges.Remove(i);
2644 AddEdge = Standard_True;
2645 NbEdges = TheEdges.Length();
2646 GoodWire = MWire.Wire();
2647 }
2648 }
2649 }
2650 NewWire = (!AddEdge);
2651 }
2652 TopoDS_Shape aLocalShape = Face.EmptyCopied();
2653 TopoDS_Face FaceCut = TopoDS::Face(aLocalShape);
2654 // TopoDS_Face FaceCut = TopoDS::Face(Face.EmptyCopied());
2655 FaceCut.Orientation(TopAbs_FORWARD);
2656 BRepTools::Update (FaceCut);
2657 AddDegeneratedEdge (FaceCut,GoodWire);
2658 TheBuilder.Add (FaceCut,GoodWire);
2659 FaceCut.Orientation(Face.Orientation());
2660 S.Append(FaceCut);
2661 }
2662 }
2663
2664
2665
2666 //=======================================================================
2667 //function : PutProfilAt
2668 //purpose :
2669 //=======================================================================
2670
PutProfilAt(const TopoDS_Wire & ProfRef,const gp_Ax3 & AxeRef,const TopoDS_Edge & E,const TopoDS_Face & F,const Standard_Boolean AtStart)2671 const TopoDS_Wire PutProfilAt (const TopoDS_Wire& ProfRef,
2672 const gp_Ax3& AxeRef,
2673 const TopoDS_Edge& E,
2674 const TopoDS_Face& F,
2675 const Standard_Boolean AtStart)
2676 {
2677 gp_Vec2d D1;
2678 gp_Pnt2d P;
2679 TopoDS_Wire Prof;
2680 Handle(Geom2d_Curve) C2d;
2681 Standard_Real First,Last;
2682
2683 C2d = BRep_Tool::CurveOnSurface(E,F,First,Last);
2684 if (C2d.IsNull()) {
2685 throw Standard_ConstructionError("ConstructionError in PutProfilAt");
2686 }
2687
2688 if (E.Orientation() == TopAbs_REVERSED) {
2689 if (!AtStart) C2d->D1(First,P,D1);else C2d->D1(Last,P,D1);
2690 D1.Reverse();
2691 }
2692 else {
2693 if (!AtStart) C2d->D1(Last,P,D1) ;else C2d->D1(First,P,D1);
2694 }
2695 gp_Pnt P3d(P.X() ,P.Y() ,0.);
2696 gp_Vec V3d(D1.X(),D1.Y(),0.);
2697
2698 gp_Ax3 Ax( P3d, gp::DZ(), V3d);
2699 gp_Trsf Trans;
2700 Trans.SetTransformation(Ax,AxeRef);
2701 TopoDS_Shape aLocalShape = ProfRef.Moved(TopLoc_Location(Trans));
2702 Prof = TopoDS::Wire(aLocalShape);
2703 // Prof = TopoDS::Wire(ProfRef.Moved(TopLoc_Location(Trans)));
2704 return Prof;
2705 }
2706
2707
2708 //=======================================================================
2709 //function : TrimEdge
2710 //purpose :
2711 //=======================================================================
2712
TrimEdge(const TopoDS_Edge & Edge,const TopTools_SequenceOfShape & TheEdgesControle,TopTools_SequenceOfShape & TheVer,TColStd_SequenceOfReal & ThePar,TopTools_SequenceOfShape & S)2713 void TrimEdge (const TopoDS_Edge& Edge,
2714 const TopTools_SequenceOfShape& TheEdgesControle,
2715 TopTools_SequenceOfShape& TheVer,
2716 TColStd_SequenceOfReal& ThePar,
2717 TopTools_SequenceOfShape& S)
2718 {
2719 Standard_Boolean Change = Standard_True;
2720 BRep_Builder TheBuilder;
2721 S.Clear();
2722 //------------------------------------------------------------
2723 // Parse two sequences depending on the parameter on the edge.
2724 //------------------------------------------------------------
2725 while (Change) {
2726 Change = Standard_False;
2727 for (Standard_Integer i = 1; i < ThePar.Length(); i++) {
2728 if (ThePar.Value(i) > ThePar.Value(i+1)) {
2729 ThePar.Exchange(i,i+1);
2730 TheVer.Exchange(i,i+1);
2731 Change = Standard_True;
2732 }
2733 }
2734 }
2735
2736 //----------------------------------------------------------
2737 // If a vertex is not in the proofing point, it is removed.
2738 //----------------------------------------------------------
2739 if (!BRep_Tool::Degenerated(Edge)) {
2740 for (Standard_Integer k = 1; k <= TheVer.Length(); k ++) {
2741 if ( DoubleOrNotInFace (TheEdgesControle,
2742 TopoDS::Vertex(TheVer.Value(k)))) {
2743 TheVer.Remove(k);
2744 ThePar.Remove(k);
2745 k--;
2746 }
2747 }
2748 }
2749
2750 //-------------------------------------------------------------------
2751 // Processing of double vertices for non-degenerated edges.
2752 // If a vertex_double appears twice in the edges of control,
2753 // the vertex is eliminated .
2754 // otherwise its only representation is preserved.
2755 //-------------------------------------------------------------------
2756 if (!BRep_Tool::Degenerated(Edge)) {
2757 for (Standard_Integer k = 1; k < TheVer.Length(); k ++) {
2758 if (TheVer.Value(k).IsSame(TheVer.Value(k+1))) {
2759 TheVer.Remove(k+1);
2760 ThePar.Remove(k+1);
2761 if ( DoubleOrNotInFace (TheEdgesControle,
2762 TopoDS::Vertex(TheVer.Value(k)))) {
2763 TheVer.Remove(k);
2764 ThePar.Remove(k);
2765 // k--;
2766 }
2767 k--;
2768 }
2769 }
2770 }
2771
2772 //-----------------------------------------------------------
2773 // Creation of edges.
2774 // the number of vertices should be even. The edges to be created leave
2775 // from a vertex with uneven index i to vertex i+1;
2776 //-----------------------------------------------------------
2777 for (Standard_Integer k = 1; k < TheVer.Length(); k = k+2) {
2778 TopoDS_Shape aLocalShape = Edge.EmptyCopied();
2779 TopoDS_Edge NewEdge = TopoDS::Edge(aLocalShape);
2780 // TopoDS_Edge NewEdge = TopoDS::Edge(Edge.EmptyCopied());
2781
2782 if (NewEdge.Orientation() == TopAbs_REVERSED) {
2783 TheBuilder.Add (NewEdge,TheVer.Value(k) .Oriented(TopAbs_REVERSED));
2784 TheBuilder.Add (NewEdge,TheVer.Value(k+1).Oriented(TopAbs_FORWARD));
2785 }
2786 else {
2787 TheBuilder.Add (NewEdge,TheVer.Value(k) .Oriented(TopAbs_FORWARD));
2788 TheBuilder.Add (NewEdge,TheVer.Value(k+1).Oriented(TopAbs_REVERSED));
2789 }
2790 TheBuilder.Range(NewEdge,ThePar.Value(k),ThePar.Value(k+1));
2791 // modified by NIZHNY-EAP Wed Dec 22 12:09:48 1999 ___BEGIN___
2792 BRepLib::UpdateTolerances(NewEdge,Standard_False);
2793 // modified by NIZHNY-EAP Wed Dec 22 13:34:19 1999 ___END___
2794 S.Append(NewEdge);
2795 }
2796 }
2797
2798 //=======================================================================
2799 //function : ComputeIntervals
2800 //purpose :
2801 //=======================================================================
2802
ComputeIntervals(const TopTools_SequenceOfShape & VOnF,const TopTools_SequenceOfShape & VOnL,const TColgp_SequenceOfPnt & ParOnF,const TColgp_SequenceOfPnt & ParOnL,const BRepFill_TrimSurfaceTool & Trim,const Handle (Geom2d_Curve)& Bis,const TopoDS_Vertex & VS,const TopoDS_Vertex & VE,TColStd_SequenceOfReal & FirstPar,TColStd_SequenceOfReal & LastPar,TopTools_SequenceOfShape & FirstV,TopTools_SequenceOfShape & LastV)2803 void ComputeIntervals (const TopTools_SequenceOfShape& VOnF,
2804 const TopTools_SequenceOfShape& VOnL,
2805 const TColgp_SequenceOfPnt& ParOnF,
2806 const TColgp_SequenceOfPnt& ParOnL,
2807 const BRepFill_TrimSurfaceTool& Trim,
2808 const Handle(Geom2d_Curve)& Bis,
2809 const TopoDS_Vertex& VS,
2810 const TopoDS_Vertex& VE,
2811 TColStd_SequenceOfReal& FirstPar,
2812 TColStd_SequenceOfReal& LastPar,
2813 TopTools_SequenceOfShape& FirstV,
2814 TopTools_SequenceOfShape& LastV )
2815 {
2816 Standard_Integer IOnF = 1,IOnL = 1;
2817 Standard_Real U1 = 0.,U2;
2818 TopoDS_Shape V1,V2;
2819
2820 if (!VS.IsNull()) {
2821 U1 = Bis->FirstParameter();
2822 V1 = VS;
2823 }
2824 while ( IOnF <= VOnF.Length() || IOnL <= VOnL.Length()) {
2825 //---------------------------------------------------------
2826 // Return the smallest parameter on the bissectrice
2827 // corresponding to the current positions IOnF,IOnL.
2828 //---------------------------------------------------------
2829 if ( IOnL > VOnL.Length() ||
2830 (IOnF <= VOnF.Length() &&
2831 ParOnF.Value(IOnF).X() < ParOnL.Value(IOnL).X())) {
2832
2833 U2 = ParOnF.Value(IOnF).X();
2834 V2 = VOnF .Value(IOnF);
2835 IOnF++;
2836 }
2837 else{
2838 U2 = ParOnL.Value(IOnL).X();
2839 V2 = VOnL .Value(IOnL);
2840 IOnL++;
2841 }
2842 //---------------------------------------------------------------------
2843 // When V2 and V1 are different the medium point P of the
2844 // interval is tested compared to the face. If P is in the face the interval
2845 // is valid.
2846 //---------------------------------------------------------------------
2847 if (!V1.IsNull() && !V2.IsSame(V1)) {
2848 gp_Pnt2d P = Bis->Value((U2 + U1)*0.5);
2849 if (Trim.IsOnFace(P)) {
2850 FirstPar.Append(U1); LastPar .Append(U2);
2851 FirstV. Append(V1); LastV .Append(V2);
2852 }
2853 }
2854 U1 = U2;
2855 V1 = V2;
2856 }
2857
2858 if (!VE.IsNull()) {
2859 U2 = Bis->LastParameter();
2860 V2 = VE;
2861 if (!V2.IsSame(V1)) {
2862 gp_Pnt2d P = Bis->Value((U2 + U1)*0.5);
2863 if (Trim.IsOnFace(P)) {
2864 FirstPar.Append(U1); LastPar .Append(U2);
2865 FirstV.Append (V1); LastV .Append(V2);
2866 }
2867 }
2868 }
2869
2870 }
2871
2872 //=======================================================================
2873 //function : Relative
2874 //purpose : Commun is true if two wires have V in common
2875 // return FORWARD if the wires near the vertex are at
2876 // the same side. otherwise REVERSED.
2877 //=======================================================================
Relative(const TopoDS_Wire & W1,const TopoDS_Wire & W2,const TopoDS_Vertex & V,Standard_Boolean & Commun)2878 static TopAbs_Orientation Relative (const TopoDS_Wire& W1,
2879 const TopoDS_Wire& W2,
2880 const TopoDS_Vertex& V,
2881 Standard_Boolean& Commun)
2882 {
2883 TopExp_Explorer Exp;
2884 TopoDS_Edge E1,E2;
2885 TopoDS_Vertex V1,V2;
2886
2887 for (Exp.Init(W1,TopAbs_EDGE); Exp.More(); Exp.Next()) {
2888 const TopoDS_Edge& E = TopoDS::Edge(Exp.Current());
2889 TopExp::Vertices(E,V1,V2);
2890 if (V1.IsSame(V) || V2.IsSame(V)) {
2891 E1 = E;
2892 break;
2893 }
2894 }
2895 for (Exp.Init(W2,TopAbs_EDGE); Exp.More(); Exp.Next()) {
2896 const TopoDS_Edge& E = TopoDS::Edge(Exp.Current());
2897 TopExp::Vertices(E,V1,V2);
2898 if (V1.IsSame(V) || V2.IsSame(V)) {
2899 E2 = E;
2900 break;
2901 }
2902 }
2903
2904 if (E1.IsNull() || E2.IsNull()) {
2905 Commun = Standard_False;
2906 return TopAbs_FORWARD;
2907 }
2908 Commun = Standard_True;
2909
2910 TopoDS_Wire WW1 = BRepLib_MakeWire(E1);
2911 TopoDS_Wire WW2 = BRepLib_MakeWire(E2);
2912 Standard_Real Tol = BRepFill_Confusion();
2913 if (Side(WW1,Tol) < 4 && Side(WW2,Tol) < 4) // two to the left
2914 return TopAbs_FORWARD;
2915 if (Side(WW1,Tol) > 4 && Side(WW2,Tol) > 4) // two to the right
2916 return TopAbs_FORWARD;
2917
2918 return TopAbs_REVERSED;
2919 }
2920
2921 //=======================================================================
2922 //function : IsOnFace
2923 //purpose : Return the position of the point defined by d1
2924 // in the face defined by d2 d3.
2925 //
2926 // 0 : the point is out of the face.
2927 // 1 : the point is on edge corresponding to d2.
2928 // 2 : the point is inside the face.
2929 // 3 : the point is on edge corresponding to d3.
2930 //=======================================================================
2931
PosOnFace(Standard_Real d1,Standard_Real d2,Standard_Real d3)2932 Standard_Integer PosOnFace (Standard_Real d1,
2933 Standard_Real d2,
2934 Standard_Real d3)
2935 {
2936 if (Abs(d1 - d2) <= BRepFill_Confusion())
2937 return 1;
2938 if (Abs(d1 - d3) <= BRepFill_Confusion())
2939 return 3;
2940
2941 if (d2 < d3) {
2942 if (d1 > (d2 + BRepFill_Confusion()) &&
2943 d1 < (d3 - BRepFill_Confusion()) )
2944 return 2;
2945 }
2946 else {
2947 if (d1 > (d3 + BRepFill_Confusion()) &&
2948 d1 < (d2 - BRepFill_Confusion()) )
2949 return 2;
2950 }
2951 return 0;
2952 }
2953
2954 //=======================================================================
2955 //function : DoubleOrNotInFace
2956 //purpose : Return True if V appears zero or two times in the sequence
2957 // of edges EC
2958 //=======================================================================
2959
DoubleOrNotInFace(const TopTools_SequenceOfShape & EC,const TopoDS_Vertex & V)2960 Standard_Boolean DoubleOrNotInFace(const TopTools_SequenceOfShape& EC,
2961 const TopoDS_Vertex& V)
2962 {
2963 Standard_Boolean Vu = Standard_False;
2964
2965 for (Standard_Integer i = 1; i <= EC.Length(); i++) {
2966 TopoDS_Vertex V1,V2;
2967 TopExp::Vertices(TopoDS::Edge(EC.Value(i)),V1,V2);
2968 if (V1.IsSame(V)) {
2969 if (Vu) return Standard_True;
2970 else Vu = Standard_True;
2971 }
2972 if (V2.IsSame(V)) {
2973 if (Vu) return Standard_True;
2974 else Vu = Standard_True;
2975 }
2976 }
2977 if (Vu) return Standard_False;
2978 else return Standard_True;
2979 }
2980
2981
2982 //=======================================================================
2983 //function : DistanceToOZ
2984 //purpose :
2985 //=======================================================================
2986
DistanceToOZ(const TopoDS_Vertex & V)2987 Standard_Real DistanceToOZ (const TopoDS_Vertex& V)
2988 {
2989 gp_Pnt PV3d = BRep_Tool::Pnt(V);
2990 return Abs(PV3d.Y());
2991 }
2992
2993 //=======================================================================
2994 //function : Altitud
2995 //purpose :
2996 //=======================================================================
2997
Altitud(const TopoDS_Vertex & V)2998 Standard_Real Altitud (const TopoDS_Vertex& V)
2999 {
3000 gp_Pnt PV3d = BRep_Tool::Pnt(V);
3001 return PV3d.Z();
3002 }
3003
3004 //=======================================================================
3005 //function : SimpleExpression
3006 //purpose :
3007 //=======================================================================
3008
SimpleExpression(const Bisector_Bisec & B,Handle (Geom2d_Curve)& Bis)3009 void SimpleExpression (const Bisector_Bisec& B,
3010 Handle(Geom2d_Curve)& Bis)
3011 {
3012 Bis = B.Value();
3013
3014 Handle(Standard_Type) BT = Bis->DynamicType();
3015 if (BT == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
3016 Handle(Geom2d_TrimmedCurve) TrBis
3017 = Handle(Geom2d_TrimmedCurve)::DownCast(Bis);
3018 Handle(Geom2d_Curve) BasBis = TrBis->BasisCurve();
3019 BT = BasBis->DynamicType();
3020 if (BT == STANDARD_TYPE(Bisector_BisecAna)) {
3021 Bis = Handle(Bisector_BisecAna)::DownCast(BasBis)->Geom2dCurve();
3022 Bis = new Geom2d_TrimmedCurve (Bis,
3023 TrBis->FirstParameter(),
3024 TrBis->LastParameter());
3025 }
3026 }
3027 }
3028
3029 //=======================================================================
3030 //function : CutEdgeProf
3031 //purpose : Projection and Cut of an edge at extrema of distance to axis OZ.
3032 //=======================================================================
3033
CutEdgeProf(const TopoDS_Edge & E,const Handle (Geom_Plane)& Plane,const Handle (Geom2d_Line)& Line,TopTools_ListOfShape & Cuts,TopTools_DataMapOfShapeShape & MapVerRefMoved)3034 void CutEdgeProf (const TopoDS_Edge& E,
3035 const Handle(Geom_Plane)& Plane,
3036 const Handle(Geom2d_Line)& Line,
3037 TopTools_ListOfShape& Cuts,
3038 TopTools_DataMapOfShapeShape& MapVerRefMoved)
3039 {
3040 Cuts.Clear();
3041
3042 Standard_Real f,l;
3043 Handle(Geom_Curve) C;
3044 Handle(Geom_TrimmedCurve) CT;
3045 Handle(Geom2d_Curve) C2d;
3046 TopLoc_Location L;
3047
3048 // Return the curve associated to each Edge
3049 C = BRep_Tool::Curve(E,L,f,l);
3050 CT = new Geom_TrimmedCurve(C,f,l);
3051 CT->Transform(L.Transformation());
3052
3053 // project it in the plane and return the associated PCurve
3054 gp_Dir Normal = Plane->Pln().Axis().Direction();
3055 C = GeomProjLib::ProjectOnPlane (CT, Plane, Normal, Standard_False);
3056 C2d = GeomProjLib::Curve2d(C,Plane);
3057
3058 // Calculate the extrema with the straight line
3059 TColStd_SequenceOfReal Seq;
3060
3061 Standard_Real U1 = -Precision::Infinite();
3062 Standard_Real U2 = Precision::Infinite();
3063 f= C2d->FirstParameter();
3064 l= C2d->LastParameter();
3065
3066 Bnd_Box2d B;
3067 Geom2dAdaptor_Curve AC2d(C2d);
3068 BndLib_Add2dCurve::Add(AC2d,BRepFill_Confusion(),B);
3069 Standard_Real xmin,xmax;
3070 B.Get(xmin,U1,xmax,U2);
3071
3072 // modified by NIZHNY-EAP Wed Feb 2 16:32:37 2000 ___BEGIN___
3073 // no sense if C2 is normal to Line or really is a point
3074 if (U1 != U2) {
3075 Geom2dAPI_ExtremaCurveCurve Extrema(Line,C2d,U1-1.,U2+1.,f,l);
3076
3077 Standard_Integer i, Nb = Extrema.NbExtrema();
3078 for ( i = 1; i <= Nb; i++) {
3079 Extrema.Parameters(i,U1,U2);
3080 Seq.Append(U2);
3081 }
3082 }
3083 // modified by NIZHNY-EAP Wed Feb 2 16:33:05 2000 ___END___
3084
3085 // On calcule les intersection avec Oy.
3086 Geom2dAdaptor_Curve ALine(Line);
3087 Standard_Real Tol = Precision::Intersection();
3088 Standard_Real TolC = 0.;
3089
3090 Geom2dInt_GInter Intersector(ALine,AC2d,TolC,Tol);
3091 Standard_Integer i, Nb = Intersector.NbPoints();
3092
3093 for ( i = 1; i <= Nb; i++) {
3094 Seq.Append(Intersector.Point(i).ParamOnSecond());
3095 }
3096
3097 // Compute the new edges.
3098 BRep_Builder Builder;
3099 TopoDS_Vertex VV,Vf,Vl,VRf,VRl;
3100 TopExp::Vertices(E,VRf,VRl);
3101
3102 if (!MapVerRefMoved.IsBound(VRf)) {
3103 Builder.MakeVertex(Vf,C->Value(f),BRep_Tool::Tolerance(VRf));
3104 MapVerRefMoved.Bind(VRf,Vf);
3105 }
3106 else {
3107 Vf = TopoDS::Vertex(MapVerRefMoved(VRf));
3108 }
3109
3110 if (!MapVerRefMoved.IsBound(VRl)) {
3111 Builder.MakeVertex(Vl,C->Value(l),BRep_Tool::Tolerance(VRl));
3112 MapVerRefMoved.Bind(VRl,Vl);
3113 }
3114 else {
3115 Vl = TopoDS::Vertex(MapVerRefMoved(VRl));
3116 }
3117
3118 if ( !Seq.IsEmpty()) {
3119
3120 Bubble(Seq);
3121
3122 Standard_Boolean Empty = Standard_False;
3123
3124 Standard_Real CurParam = f;
3125 Standard_Real Param;
3126
3127 while ( !Empty) {
3128 Param = Seq.First();
3129 Seq.Remove(1);
3130 Empty = Seq.IsEmpty();
3131 if (Abs( Param - CurParam) > BRepFill_Confusion() &&
3132 Abs( Param - l) > BRepFill_Confusion() ) {
3133
3134 VV = BRepLib_MakeVertex( C->Value(Param));
3135
3136 TopoDS_Edge EE = BRepLib_MakeEdge(C,Vf,VV);
3137 EE.Orientation(E.Orientation());
3138 if ( EE.Orientation() == TopAbs_FORWARD)
3139 Cuts.Append(EE);
3140 else
3141 Cuts.Prepend(EE);
3142
3143 // reinitialize
3144 CurParam = Param;
3145 Vf = VV;
3146 }
3147 }
3148 }
3149
3150 TopoDS_Edge EE = BRepLib_MakeEdge(C,Vf,Vl);
3151 EE.Orientation(E.Orientation());
3152 if ( EE.Orientation() == TopAbs_FORWARD)
3153 Cuts.Append(EE);
3154 else
3155 Cuts.Prepend(EE);
3156 }
3157
3158 //=======================================================================
3159 //function : CutEdge
3160 //purpose : Cut an edge at thw extrema of curves and at points of inflexion.
3161 // Closed circles are also cut in two.
3162 // If <Cuts> are empty the edge is not modified.
3163 // The first and the last vertex of the original edge
3164 // belong to the first and last parts respectively.
3165 //=======================================================================
CutEdge(const TopoDS_Edge & E,const TopoDS_Face & F,TopTools_ListOfShape & Cuts)3166 void CutEdge (const TopoDS_Edge& E,
3167 const TopoDS_Face& F,
3168 TopTools_ListOfShape& Cuts)
3169 {
3170 Cuts.Clear();
3171 MAT2d_CutCurve Cuter;
3172 Standard_Real f,l;
3173 Handle(Geom2d_Curve) C2d;
3174 Handle(Geom2d_TrimmedCurve) CT2d;
3175
3176 TopoDS_Vertex V1,V2,VF,VL;
3177 TopExp::Vertices (E,V1,V2);
3178 BRep_Builder B;
3179
3180 C2d = BRep_Tool::CurveOnSurface (E,F,f,l);
3181 CT2d = new Geom2d_TrimmedCurve(C2d,f,l);
3182
3183 if (CT2d->BasisCurve()->IsKind(STANDARD_TYPE(Geom2d_Circle)) &&
3184 BRep_Tool::IsClosed(E)) {
3185 //---------------------------
3186 // Cut closed circle.
3187 //---------------------------
3188 Standard_Real m1 = (2*f + l)/3.;
3189 Standard_Real m2 = ( f + 2*l)/3.;
3190 gp_Pnt2d P1 = CT2d->Value(m1);
3191 gp_Pnt2d P2 = CT2d->Value(m2);
3192
3193 TopoDS_Vertex VL1 = BRepLib_MakeVertex(gp_Pnt(P1.X(), P1.Y(), 0.));
3194 TopoDS_Vertex VL2 = BRepLib_MakeVertex(gp_Pnt(P2.X(), P2.Y(), 0.));
3195 TopoDS_Shape aLocalShape1 = E.EmptyCopied();
3196 TopoDS_Shape aLocalShape2 = E.EmptyCopied();
3197 TopoDS_Shape aLocalShape3 = E.EmptyCopied();
3198 TopoDS_Edge FE = TopoDS::Edge(aLocalShape1);
3199 TopoDS_Edge ME = TopoDS::Edge(aLocalShape2);
3200 TopoDS_Edge LE = TopoDS::Edge(aLocalShape3);
3201 // TopoDS_Edge FE = TopoDS::Edge(E.EmptyCopied());
3202 // TopoDS_Edge ME = TopoDS::Edge(E.EmptyCopied());
3203 // TopoDS_Edge LE = TopoDS::Edge(E.EmptyCopied());
3204
3205 FE.Orientation(TopAbs_FORWARD);
3206 ME.Orientation(TopAbs_FORWARD);
3207 LE.Orientation(TopAbs_FORWARD );
3208
3209 B.Add (FE,V1);
3210 B.Add (FE,VL1.Oriented(TopAbs_REVERSED));
3211 B.Range(FE, f, m1);
3212
3213 B.Add (ME,VL1.Oriented(TopAbs_FORWARD));
3214 B.Add (ME,VL2.Oriented(TopAbs_REVERSED));
3215 B.Range(ME, m1, m2);
3216
3217 B.Add (LE,VL2.Oriented(TopAbs_FORWARD));
3218 B.Add (LE,V2);
3219 B.Range(LE, m2, l);
3220
3221 Cuts.Append(FE.Oriented(E.Orientation()));
3222 Cuts.Append(ME.Oriented(E.Orientation()));
3223 Cuts.Append(LE.Oriented(E.Orientation()));
3224 //--------
3225 // Return.
3226 //--------
3227 return;
3228 }
3229
3230 //-------------------------
3231 // Cut of the curve.
3232 //-------------------------
3233 Cuter.Perform(CT2d);
3234
3235 if (Cuter.UnModified()) {
3236 //-----------------------------
3237 // edge not modified => return.
3238 //-----------------------------
3239 return;
3240 }
3241 else {
3242 //------------------------
3243 // Creation of cut edges.
3244 //------------------------
3245 VF = V1;
3246
3247 for ( Standard_Integer k = 1; k <= Cuter.NbCurves(); k++) {
3248 Handle(Geom2d_TrimmedCurve)CC = Cuter.Value(k);
3249 if (k == Cuter.NbCurves()) {VL = V2;}
3250 else {
3251 gp_Pnt2d P = CC->Value(CC->LastParameter());
3252 VL = BRepLib_MakeVertex(gp_Pnt(P.X(), P.Y(), 0.));
3253 }
3254 TopoDS_Shape aLocalShape = E.EmptyCopied();
3255 TopoDS_Edge NE = TopoDS::Edge(aLocalShape);
3256 // TopoDS_Edge NE = TopoDS::Edge(E.EmptyCopied());
3257 NE.Orientation(TopAbs_FORWARD);
3258 B.Add (NE,VF.Oriented(TopAbs_FORWARD));
3259 B.Add (NE,VL.Oriented(TopAbs_REVERSED));
3260 B.Range(NE,CC->FirstParameter(),CC->LastParameter());
3261 Cuts.Append(NE.Oriented(E.Orientation()));
3262 VF = VL;
3263 }
3264 }
3265 }
3266
3267 //=======================================================================
3268 //function : VertexFromNode
3269 //purpose : Test if the position of aNode correspondingly to the distance to OZ
3270 // of vertices VF and VL. returns Status.
3271 // if Status is different from 0 Returned
3272 // the vertex corresponding to aNode is created.
3273 //=======================================================================
3274
VertexFromNode(const Handle (MAT_Node)& aNode,const TopoDS_Edge & E,const TopoDS_Vertex & VF,const TopoDS_Vertex & VL,BRepFill_DataMapOfNodeDataMapOfShapeShape & MapNodeVertex,TopoDS_Vertex & VN)3275 Standard_Integer VertexFromNode
3276 (const Handle(MAT_Node)& aNode,
3277 const TopoDS_Edge& E,
3278 const TopoDS_Vertex& VF,
3279 const TopoDS_Vertex& VL,
3280 BRepFill_DataMapOfNodeDataMapOfShapeShape& MapNodeVertex,
3281 TopoDS_Vertex& VN)
3282 {
3283 TopoDS_Shape ShapeOnNode;
3284 TopTools_DataMapOfShapeShape EmptyMap;
3285 Standard_Integer Status = 0;
3286 BRep_Builder B;
3287
3288 if (!aNode->Infinite()) {
3289 Status = PosOnFace(aNode->Distance(),
3290 DistanceToOZ(VF) , DistanceToOZ(VL));
3291 }
3292 if (Status == 2) ShapeOnNode = E;
3293 else if (Status == 1) ShapeOnNode = VF;
3294 else if (Status == 3) ShapeOnNode = VL;
3295
3296 if (!ShapeOnNode.IsNull()) {
3297 //-------------------------------------------------
3298 // the vertex will correspond to a node of the map
3299 //-------------------------------------------------
3300 if (MapNodeVertex.IsBound(aNode) &&
3301 MapNodeVertex(aNode).IsBound(ShapeOnNode)) {
3302 VN = TopoDS::Vertex
3303 (MapNodeVertex(aNode)(ShapeOnNode));
3304 }
3305 else {
3306 B.MakeVertex (VN);
3307 if (!MapNodeVertex.IsBound(aNode)) {
3308 MapNodeVertex.Bind(aNode,EmptyMap);
3309 }
3310 MapNodeVertex(aNode).Bind(ShapeOnNode,VN);
3311 }
3312 }
3313 return Status;
3314 }
3315
3316