1 // Created on: 1995-06-27
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <BRep_Builder.hxx>
19 #include <BRep_Tool.hxx>
20 #include <BRepAdaptor_Surface.hxx>
21 #include <BRepClass_FaceExplorer.hxx>
22 #include <BRepLib_MakeFace.hxx>
23 #include <BRepLib_MakeWire.hxx>
24 #include <BRepTools.hxx>
25 #include <BRepTools_WireExplorer.hxx>
26 #include <BRepTopAdaptor_FClass2d.hxx>
27 #include <Geom2d_Curve.hxx>
28 #include <gp_Dir2d.hxx>
29 #include <gp_Pnt2d.hxx>
30 #include <gp_Vec2d.hxx>
31 #include <LocOpe.hxx>
32 #include <LocOpe_SplitShape.hxx>
33 #include <Precision.hxx>
34 #include <Standard_ConstructionError.hxx>
35 #include <Standard_ErrorHandler.hxx>
36 #include <Standard_NoSuchObject.hxx>
37 #include <StdFail_NotDone.hxx>
38 #include <TopExp.hxx>
39 #include <TopExp_Explorer.hxx>
40 #include <TopoDS.hxx>
41 #include <TopoDS_Edge.hxx>
42 #include <TopoDS_Face.hxx>
43 #include <TopoDS_Iterator.hxx>
44 #include <TopoDS_Shape.hxx>
45 #include <TopoDS_Vertex.hxx>
46 #include <TopoDS_Wire.hxx>
47 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
48 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
49 #include <TopTools_DataMapOfShapeInteger.hxx>
50 #include <TopTools_DataMapOfShapeListOfShape.hxx>
51 #include <TopTools_DataMapOfShapeShape.hxx>
52 #include <TopTools_IndexedMapOfShape.hxx>
53 #include <TopTools_ListIteratorOfListOfShape.hxx>
54 #include <TopTools_ListOfShape.hxx>
55 #include <TopTools_MapIteratorOfMapOfOrientedShape.hxx>
56 #include <TopTools_MapIteratorOfMapOfShape.hxx>
57 #include <TopTools_MapOfOrientedShape.hxx>
58 #include <TopTools_MapOfShape.hxx>
59 #include <ShapeAnalysis_Edge.hxx>
60 #include <Geom2dAPI_ProjectPointOnCurve.hxx>
61
62 #include <Geom_Surface.hxx>
63
64 static Standard_Boolean IsInside(const TopoDS_Face&,
65 const TopoDS_Wire&,
66 const TopoDS_Wire&);
67
68 static Standard_Boolean IsInside(const TopoDS_Face&,
69 const TopoDS_Wire&);
70
71 static void GetDirection(const TopoDS_Edge&,
72 const TopoDS_Face&,
73 gp_Pnt2d&,
74 gp_Vec2d&,
75 Standard_Boolean isFirstEnd);
76
77 static Standard_Boolean ChoixUV(const TopoDS_Edge&,
78 const TopoDS_Face&,
79 const TopTools_IndexedMapOfShape&,
80 TopoDS_Edge&,
81 gp_Pnt2d&,
82 gp_Vec2d&);
83
84 static TopoDS_Shape ChooseDirection(const TopoDS_Shape&,
85 const TopoDS_Vertex&,
86 const TopoDS_Face&,
87 const TopTools_ListOfShape&);
88
SameUV(const gp_Pnt2d & P1,const gp_Pnt2d & P2,const BRepAdaptor_Surface & theBAS)89 inline Standard_Boolean SameUV(const gp_Pnt2d& P1, const gp_Pnt2d& P2,
90 const BRepAdaptor_Surface& theBAS)//const Standard_Real tol)
91 {
92 Standard_Boolean isSame = Standard_True;
93 if(theBAS.IsUPeriodic())
94 isSame = (fabs(P1.X() - P2.X()) < theBAS.UPeriod() *0.5);
95 if(theBAS.IsVPeriodic())
96 isSame = (isSame && (fabs(P1.Y() - P2.Y()) < theBAS.VPeriod() *0.5));
97 return isSame;
98 //return P1.SquareDistance(P2) < tol * tol; //IFV
99 }
100
101
102
103 //=======================================================================
104 //function : Init
105 //purpose :
106 //=======================================================================
107
Init(const TopoDS_Shape & S)108 void LocOpe_SplitShape::Init(const TopoDS_Shape& S)
109 {
110 myDone = Standard_False;
111 myShape = S;
112 myDblE.Clear();
113 myMap.Clear();
114 Put(myShape);
115 }
116
117
118 //=======================================================================
119 //function : CanSplit
120 //purpose :
121 //=======================================================================
122
CanSplit(const TopoDS_Edge & E) const123 Standard_Boolean LocOpe_SplitShape::CanSplit(const TopoDS_Edge& E) const
124 {
125 if (myDone) {
126 return Standard_False;
127 }
128 if (myMap.IsEmpty()) {
129 return Standard_False;
130 }
131
132 if (!myMap.IsBound(E)) {
133 return Standard_False;
134 }
135
136 // On verifie que l`edge n`appartient pas a un wire deja reconstruit
137 TopExp_Explorer exp;
138 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm(myMap);
139 for (; itm.More(); itm.Next()) {
140 if (itm.Key().ShapeType() == TopAbs_WIRE && !itm.Value().IsEmpty()) {
141 for (exp.Init(itm.Key(),TopAbs_EDGE); exp.More(); exp.Next()) {
142 if (exp.Current().IsSame(E)) {
143 return Standard_False;
144 }
145 }
146 }
147 }
148 return Standard_True;
149 }
150
151
152 //=======================================================================
153 //function : Add
154 //purpose :
155 //=======================================================================
156
Add(const TopoDS_Vertex & V,const Standard_Real P,const TopoDS_Edge & E)157 void LocOpe_SplitShape::Add(const TopoDS_Vertex& V,
158 const Standard_Real P,
159 const TopoDS_Edge& E)
160 {
161 if (!CanSplit(E)) {
162 return;
163 }
164
165 BRep_Builder B;
166 TopTools_ListOfShape& le = myMap(E);
167 if (le.IsEmpty()) {
168 le.Append(E);
169 }
170 TopTools_ListIteratorOfListOfShape itl(le);
171 Standard_Real f,l;
172 TopTools_ListOfShape aNewList;
173 for (; itl.More(); itl.Next()) {
174 const TopoDS_Edge& edg = TopoDS::Edge(itl.Value());
175 BRep_Tool::Range(edg,f,l);
176 if (P > f + Precision::PConfusion() && P < l - Precision::PConfusion()) {
177 break;
178
179 }
180 aNewList.Append(edg);
181 }
182 if (!itl.More()) {
183 return;
184 }
185 TopoDS_Edge edg = TopoDS::Edge(itl.Value());
186 le.Remove(itl);
187 if (V.Orientation() == TopAbs_FORWARD ||
188 V.Orientation() == TopAbs_REVERSED) {
189
190 edg.Orientation(TopAbs_FORWARD);
191 TopoDS_Vertex aCurV1, aCurV2;
192 TopExp::Vertices(edg, aCurV1, aCurV2);
193 Standard_Real aPar1 = BRep_Tool::Parameter(aCurV1,edg);
194
195 Standard_Real aPar2 = BRep_Tool::Parameter(aCurV2,edg);
196
197 TopoDS_Shape aLocalShape = edg.EmptyCopied();
198 TopoDS_Edge E1 = TopoDS::Edge(aLocalShape);
199 aLocalShape = edg.EmptyCopied();
200 TopoDS_Edge E2 = TopoDS::Edge(aLocalShape);
201 // TopoDS_Edge E1 = TopoDS::Edge(edg.EmptyCopied());
202 // TopoDS_Edge E2 = TopoDS::Edge(edg.EmptyCopied());
203 E1.Orientation(TopAbs_FORWARD);
204 E2.Orientation(TopAbs_FORWARD);
205 TopoDS_Vertex newVtx = V;
206 Standard_Real aTolSplitV = BRep_Tool::Tolerance(V);
207
208 aCurV1.Orientation(TopAbs_FORWARD);
209
210 B.Add(E1,aCurV1);
211 //for degenerated edges tolerance of vertices should be set to maximal value
212 //from tolerance of the vertex of the edge and tolerance of splitting vertex
213 Standard_Real aTolV1 = ( BRep_Tool::Degenerated(edg) ?
214 Max(BRep_Tool::Tolerance(aCurV1), aTolSplitV) : BRep_Tool::Tolerance(aCurV1));
215
216 B.UpdateVertex(aCurV1,aPar1,E1, aTolV1);
217 newVtx.Orientation(TopAbs_REVERSED);
218 B.Add(E1,newVtx);
219 B.UpdateVertex(newVtx,P,E1,BRep_Tool::Tolerance(V));
220 newVtx.Orientation(TopAbs_FORWARD);
221 B.Add(E2,newVtx);
222 B.UpdateVertex(newVtx,P,E2,BRep_Tool::Tolerance(V));
223
224 aCurV2.Orientation(TopAbs_REVERSED);
225 B.Add(E2,aCurV2);
226
227 //for degenerated edges tolerance of vertices should be set to maximal value
228 //from tolerance of the vertex of the edge and tolerance of splitting vertex
229 Standard_Real aTolV2 = ( BRep_Tool::Degenerated(edg) ? aTolV1 : BRep_Tool::Tolerance(aCurV2));
230 B.UpdateVertex(aCurV2,aPar2,E2,aTolV2);
231
232 aNewList.Append(E1);
233 aNewList.Append(E2);
234 for (; itl.More(); itl.Next())
235 {
236 const TopoDS_Edge& edg1 = TopoDS::Edge(itl.Value());
237 aNewList.Append(edg1);
238 }
239 myMap.UnBind(E);
240 myMap.Bind(E, aNewList);
241
242 }
243 else {
244 TopoDS_Shape aLocalShape = edg.EmptyCopied();
245 TopoDS_Edge E1 = TopoDS::Edge(aLocalShape);
246
247 TopExp_Explorer exp;
248 for (exp.Init(edg,TopAbs_VERTEX); exp.More(); exp.Next()) {
249
250 const TopoDS_Vertex& vtx = TopoDS::Vertex(exp.Current());
251 f = BRep_Tool::Parameter(vtx,edg);
252 B.Add(E1,vtx);
253 B.UpdateVertex(vtx,f,E1,BRep_Tool::Tolerance(vtx));
254 }
255 B.Add(E1,V);
256 B.UpdateVertex(V,P,E1,BRep_Tool::Tolerance(V));
257 le.Append(E1);
258 }
259 }
260
261 //=======================================================================
262 //function : Add
263 //purpose : adds the list of wires on the face <F>
264 //=======================================================================
265
Add(const TopTools_ListOfShape & Lwires,const TopoDS_Face & F)266 Standard_Boolean LocOpe_SplitShape::Add(const TopTools_ListOfShape& Lwires,
267 const TopoDS_Face& F)
268 {
269
270 if (myDone) {
271 return Standard_False;
272 }
273
274 TopTools_ListOfShape& lf = myMap(F);
275 if (lf.IsEmpty()) {
276 Rebuild(F);
277 }
278
279 // On cherche la face descendante de F qui continent le wire
280 lf = myMap(F);
281 TopTools_ListIteratorOfListOfShape itl(lf);
282 TopoDS_Vertex Vfirst,Vlast;
283
284 BRepTools::Update(F);
285
286 TopTools_ListOfShape aLInside;
287 for (; itl.More(); itl.Next())
288 {
289 const TopoDS_Face& fac = TopoDS::Face(itl.Value());
290 TopTools_ListIteratorOfListOfShape itwires(Lwires);
291 for (; itwires.More(); itwires.Next())
292 {
293 const TopoDS_Wire& aWire = TopoDS::Wire(itwires.Value());
294 if (IsInside(fac, aWire))
295 {
296 aLInside.Append(aWire);
297
298 }
299 }
300 if(aLInside.Extent())
301 break;
302 }
303 if (!aLInside.Extent() || !itl.More()) {
304 return Standard_False;
305 }
306
307 TopoDS_Face FaceRef = TopoDS::Face(itl.Value());
308 FaceRef.Orientation(TopAbs_FORWARD);
309 lf.Remove(itl);
310
311 TopTools_ListOfShape NewWires;
312
313 TopTools_DataMapOfShapeInteger SectionsTimes;
314 for (itl.Initialize(aLInside); itl.More(); itl.Next())
315 SectionsTimes.Bind(itl.Value(), 2);
316
317 TopTools_ListOfShape BreakVertices;
318 TopTools_ListOfShape BreakOnWires;
319
320 TopTools_DataMapOfShapeShape VerWireMap;
321 Standard_Integer i;
322 TopExp_Explorer ExploF, ExploW;
323 for (itl.Initialize(aLInside); itl.More(); itl.Next())
324 {
325 const TopoDS_Wire& aSection = TopoDS::Wire(itl.Value());
326 TopoDS_Vertex Ver [2];
327 TopExp::Vertices(aSection, Ver[0], Ver[1]);
328 for (i = 0; i < 2; i++)
329 {
330 if (VerWireMap.IsBound(Ver[i]))
331 continue;
332 for (ExploF.Init(FaceRef, TopAbs_WIRE); ExploF.More(); ExploF.Next())
333 {
334 const TopoDS_Shape& aWire = ExploF.Current();
335 TopoDS_Shape aVer;
336 for (ExploW.Init(aWire, TopAbs_VERTEX); ExploW.More(); ExploW.Next())
337 {
338 aVer = ExploW.Current();
339 if (aVer.IsSame(Ver[i]))
340 break;
341 }
342 if (aVer.IsSame(Ver[i]))
343 {
344 VerWireMap.Bind(aVer, aWire);
345 break;
346 }
347 }
348 }
349 }
350
351 TopTools_DataMapOfShapeListOfShape VerSecMap;
352 for (itl.Initialize(aLInside); itl.More(); itl.Next())
353 {
354 const TopoDS_Wire& aWire = TopoDS::Wire(itl.Value());
355 TopoDS_Vertex V1, V2;
356 TopExp::Vertices(aWire, V1, V2);
357 TopTools_ListOfShape LW1, LW2;
358 if (!VerSecMap.IsBound(V1))
359 VerSecMap.Bind(V1, LW1);
360 VerSecMap(V1).Append(aWire);
361 if (!VerSecMap.IsBound(V2))
362 VerSecMap.Bind(V2, LW2);
363 VerSecMap(V2).Append(aWire);
364 }
365
366 //TopTools_IndexedDataMapOfShapeShape InnerTouchingWiresOnVertex;
367
368 TopoDS_Wire outerW = BRepTools::OuterWire(FaceRef);
369 TopoDS_Wire CurWire = outerW;
370 BRepLib_MakeWire *MW;
371 MW = new BRepLib_MakeWire();
372 BRepTools_WireExplorer wexp(CurWire, FaceRef);
373 for (;;)
374 {
375 TopoDS_Vertex theStartVertex = wexp.CurrentVertex(), CurVertex;
376 TopoDS_Edge CurEdge = wexp.Current();
377 TopoDS_Edge LastEdge = CurEdge;
378 MW->Add(CurEdge);
379 TopoDS_Wire aSectionWire;
380 TopoDS_Vertex aBreakVertex;
381 wexp.Next();
382 if (!wexp.More())
383 wexp.Init(CurWire, FaceRef);
384 for (;;)
385 {
386 if (MW->Wire().Closed())
387 break;
388 CurVertex = wexp.CurrentVertex();
389 if (VerSecMap.IsBound(CurVertex))
390 {
391 TopoDS_Shape aLocalWire = ChooseDirection(LastEdge, CurVertex, FaceRef, VerSecMap(CurVertex));
392 aSectionWire = TopoDS::Wire(aLocalWire);
393 break;
394 }
395 CurEdge = wexp.Current();
396 MW->Add(CurEdge);
397 LastEdge = CurEdge;
398 wexp.Next();
399 if (!wexp.More())
400 wexp.Init(CurWire, FaceRef);
401 }
402 if (MW->Wire().Closed())
403 {
404 NewWires.Append(MW->Wire());
405 theStartVertex = TopoDS::Vertex(BreakVertices.First());
406 BreakVertices.RemoveFirst();
407 CurWire = TopoDS::Wire(BreakOnWires.First());
408 BreakOnWires.RemoveFirst();
409 wexp.Init(CurWire, FaceRef);
410 while (!wexp.CurrentVertex().IsSame(theStartVertex))
411 wexp.Next();
412 MW = new BRepLib_MakeWire();
413 continue;
414 }
415 aBreakVertex = CurVertex;
416 BreakVertices.Append(aBreakVertex);
417 BreakOnWires.Append(CurWire);
418 for (;;)
419 {
420 MW->Add(aSectionWire);
421 (SectionsTimes(aSectionWire))--;
422 if (SectionsTimes(aSectionWire) == 0)
423 SectionsTimes.UnBind(aSectionWire);
424 if (MW->Wire().Closed())
425 {
426 NewWires.Append(MW->Wire());
427 if (SectionsTimes.IsEmpty())
428 break;
429 theStartVertex = TopoDS::Vertex(BreakVertices.First());
430 BreakVertices.RemoveFirst();
431 CurWire = TopoDS::Wire(BreakOnWires.First());
432 BreakOnWires.RemoveFirst();
433 wexp.Init(CurWire, FaceRef);
434 while (!wexp.CurrentVertex().IsSame(theStartVertex))
435 wexp.Next();
436 MW = new BRepLib_MakeWire();
437 break;
438 }
439 else
440 {
441 TopoDS_Vertex V1, V2, aStartVertex;
442 TopExp::Vertices(aSectionWire, V1, V2);
443 aStartVertex = (V1.IsSame(aBreakVertex))? V2 : V1;
444 CurWire = TopoDS::Wire(VerWireMap(aStartVertex));
445
446 wexp.Init(CurWire, FaceRef);
447 while (!wexp.CurrentVertex().IsSame(aStartVertex))
448 wexp.Next();
449
450 const TopTools_ListOfShape& Lsections = VerSecMap(aStartVertex);
451 if (Lsections.Extent() == 1)
452 break;
453
454 //else: choose the way
455 TopoDS_Wire NextSectionWire =
456 TopoDS::Wire((aSectionWire.IsSame(Lsections.First()))? Lsections.Last() : Lsections.First());
457
458 Standard_Integer Times = 0;
459 TopTools_DataMapIteratorOfDataMapOfShapeShape itVW(VerWireMap);
460 for (; itVW.More(); itVW.Next())
461 if (itVW.Value().IsSame(CurWire))
462 Times++;
463 if (Times == 1) //it is inner touching wire
464 {
465 //InnerTouchingWiresOnVertex.Bind(aWire, aStartVertex);
466 }
467 else
468 {
469 //we have to choose the direction
470 TopoDS_Edge aStartEdge = wexp.Current();
471 TopTools_ListOfShape Ldirs;
472 Ldirs.Append(aStartEdge);
473 Ldirs.Append(NextSectionWire);
474 TopoDS_Shape theDirection = ChooseDirection(aSectionWire, aStartVertex, FaceRef, Ldirs);
475 if (theDirection.IsSame(aStartEdge))
476 break;
477 }
478 aSectionWire = NextSectionWire;
479 aBreakVertex = aStartVertex;
480 } //end of else (MW is not closed)
481 } //end of for (;;) (loop on section wires)
482 if (SectionsTimes.IsEmpty())
483 break;
484 } //end of global for (;;)
485
486 TopTools_ListOfShape NewFaces;
487 BRep_Builder BB;
488 for (itl.Initialize(NewWires); itl.More(); itl.Next())
489 {
490 TopoDS_Shape aLocalFace = FaceRef.EmptyCopied();
491 TopoDS_Face aNewFace = TopoDS::Face(aLocalFace);
492 aNewFace.Orientation(TopAbs_FORWARD);
493 BB.Add(aNewFace, itl.Value());
494 NewFaces.Append(aNewFace);
495 }
496
497 //Inserting holes
498 TopTools_ListOfShape Holes;
499 for (ExploF.Init(FaceRef, TopAbs_WIRE); ExploF.More(); ExploF.Next())
500 {
501 const TopoDS_Shape& aWire = ExploF.Current();
502 ExploW.Init(aWire, TopAbs_EDGE);
503 TopoDS_Shape anEdge = ExploW.Current();
504 Standard_Boolean found = Standard_False;
505 for (itl.Initialize(NewWires); itl.More(); itl.Next())
506 {
507 const TopoDS_Shape& aNewWire = itl.Value();
508 for (ExploW.Init(aNewWire, TopAbs_EDGE); ExploW.More(); ExploW.Next())
509 {
510 if (anEdge.IsSame(ExploW.Current()))
511 {
512 found = Standard_True;
513 break;
514 }
515 }
516 if (found)
517 break;
518 }
519 if (!found)
520 Holes.Append(aWire);
521 }
522 TopTools_ListIteratorOfListOfShape itlNewF;
523 for (itl.Initialize(Holes); itl.More(); itl.Next())
524 {
525 const TopoDS_Wire& aHole = TopoDS::Wire(itl.Value());
526 for (itlNewF.Initialize(NewFaces); itlNewF.More(); itlNewF.Next())
527 {
528 TopoDS_Face& aNewFace = TopoDS::Face(itlNewF.Value());
529 if (IsInside(aNewFace, aHole))
530 {
531 BB.Add(aNewFace, aHole);
532 break;
533 }
534 }
535 }
536
537 //Update "myMap"
538 lf.Append(NewFaces);
539
540 //Update of descendants of wires
541 for (ExploF.Init(F, TopAbs_WIRE); ExploF.More(); ExploF.Next())
542 {
543 TopTools_ListOfShape& ls = myMap(ExploF.Current());
544 ls.Clear();
545 }
546 ///////////////////
547
548 // JAG 10.11.95 Codage des regularites
549 for (itl.Initialize(aLInside); itl.More(); itl.Next())
550 for (ExploW.Init(itl.Value(), TopAbs_EDGE); ExploW.More(); ExploW.Next())
551 {
552 const TopoDS_Edge& edg = TopoDS::Edge(ExploW.Current());
553 if (!BRep_Tool::HasContinuity(edg,F,F)) {
554 BB.Continuity(edg,F,F,GeomAbs_CN);
555 }
556 }
557 return Standard_True;
558 }
559
560
561 //=======================================================================
562 //function : Add
563 //purpose :
564 //=======================================================================
565
Add(const TopoDS_Wire & W,const TopoDS_Face & F)566 Standard_Boolean LocOpe_SplitShape::Add(const TopoDS_Wire& W,
567 const TopoDS_Face& F)
568 {
569
570 if (myDone) {
571 return Standard_False;
572 }
573
574
575 TopExp_Explorer exp;
576 TopTools_ListOfShape& lf = myMap(F);
577 if (lf.IsEmpty()) {
578 Rebuild(F);
579 }
580 try {
581 OCC_CATCH_SIGNALS
582 if (!LocOpe::Closed(W,F)) {
583 if(!AddOpenWire(W,F))
584 return Standard_False;
585 }
586 else {
587 if(!AddClosedWire(W,F))
588 return Standard_False;
589 }
590 } catch (Standard_Failure const&) {
591 #ifdef OCCT_DEBUG
592 std::cout << "Warning: SpliShape internal problem detected, some faces may be lost. Check input edges/wires" <<std::endl;
593 #endif
594 return Standard_False;
595 }
596 // JAG 10.11.95 Codage des regularites
597 BRep_Builder B;
598 for (exp.Init(W,TopAbs_EDGE); exp.More(); exp.Next()) {
599 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
600 if (!BRep_Tool::HasContinuity(edg,F,F)) {
601 B.Continuity(edg,F,F,GeomAbs_CN);
602 }
603 }
604 return Standard_True;
605 }
606
607
608
609 //=======================================================================
610 //function : AddClosedWire
611 //purpose :
612 //=======================================================================
613
AddClosedWire(const TopoDS_Wire & W,const TopoDS_Face & F)614 Standard_Boolean LocOpe_SplitShape::AddClosedWire(const TopoDS_Wire& W,
615 const TopoDS_Face& F)
616 {
617 TopExp_Explorer exp;
618
619 // On cherche la face descendante de F qui continent le wire
620 TopTools_ListOfShape& lf = myMap(F);
621 TopTools_ListIteratorOfListOfShape itl(lf);
622 TopoDS_Wire outerW;
623 for (; itl.More(); itl.Next()) {
624 const TopoDS_Face& fac = TopoDS::Face(itl.Value());
625
626 if (IsInside(fac,W)) {
627 break;
628 }
629
630 }
631 if (!itl.More()) {
632 return Standard_False;
633 }
634
635 BRep_Builder B;
636
637 TopAbs_Orientation orWire = W.Orientation();
638 TopoDS_Shape aLocalFace = F.EmptyCopied();
639 TopoDS_Face newFace = TopoDS::Face(aLocalFace);
640 // TopoDS_Face newFace = TopoDS::Face(F.EmptyCopied());
641 newFace.Orientation(TopAbs_FORWARD);
642 B.Add(newFace,W);
643 // GProp_GProps GP;
644 // BRepGProp::SurfaceProperties (newFace,GP);
645 // if (GP.Mass() < 0) {
646 BRepTopAdaptor_FClass2d classif(newFace,Precision::PConfusion());
647 if (classif.PerformInfinitePoint() == TopAbs_IN) {
648 //le wire donne defini un trou
649 aLocalFace = F.EmptyCopied();
650 newFace = TopoDS::Face(aLocalFace);
651 // newFace = TopoDS::Face(F.EmptyCopied());
652 newFace.Orientation(TopAbs_FORWARD);
653 orWire = TopAbs::Reverse(orWire);
654 B.Add(newFace,W.Oriented(orWire));
655 }
656
657 TopoDS_Face FaceRef = TopoDS::Face(itl.Value());
658 FaceRef.Orientation(TopAbs_FORWARD);
659 lf.Remove(itl);
660
661 aLocalFace = FaceRef.EmptyCopied();
662 TopoDS_Face newRef = TopoDS::Face(aLocalFace);
663 // TopoDS_Face newRef = TopoDS::Face(FaceRef.EmptyCopied());
664 newRef.Orientation(TopAbs_FORWARD);
665
666 // On suppose que les edges du wire ont des courbes 2d.
667 // Comme on ne change pas de surface de base, pas besoin d`UpdateEdge.
668
669 for (exp.Init(FaceRef.Oriented(TopAbs_FORWARD),TopAbs_WIRE);
670 exp.More(); exp.Next()) {
671 const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
672 if (IsInside(F,wir,W)) {
673 B.Add(newFace,wir);
674 }
675 else {
676 B.Add(newRef,wir);
677 }
678 }
679 B.Add(newRef,W.Oriented(TopAbs::Reverse(orWire)));
680 lf.Append(newRef);
681 lf.Append(newFace);
682 return Standard_True;
683 }
684
685 //=======================================================================
686 //function : checkOverlapping
687 //purpose :
688 //=======================================================================
689
checkOverlapping(const TopoDS_Edge & theEdge1,const TopoDS_Edge & theEdge2,const TopoDS_Face & theFace)690 static Standard_Boolean checkOverlapping(const TopoDS_Edge& theEdge1, const TopoDS_Edge& theEdge2,
691 const TopoDS_Face& theFace)
692 {
693
694 BRepAdaptor_Surface anAdS(theFace,Standard_False );
695
696 Standard_Real MaxTol = (BRep_Tool::Tolerance(theEdge1) + BRep_Tool::Tolerance(theEdge2));
697
698 Standard_Real aMaxTol2d = Max(anAdS.UResolution(MaxTol),anAdS.VResolution(MaxTol));
699 Standard_Real aTolAng = M_PI/180.;
700 Geom2dAPI_ProjectPointOnCurve proj;
701 Standard_Real aF1, aL1,aF2, aL2;
702
703 Handle(Geom2d_Curve) aCrv1 = BRep_Tool::CurveOnSurface(theEdge1, theFace, aF1, aL1);
704 Handle(Geom2d_Curve) aCrv2 = BRep_Tool::CurveOnSurface(theEdge2, theFace, aF2, aL2);
705 Standard_Integer j =1, nbP = 4;
706 Standard_Real aStep = ( aL2 - aF2)/nbP;
707 for( ; j < nbP; j++)
708 {
709 Standard_Real par2 = aF2 + aStep * j;
710 gp_Pnt2d aP2d;
711 gp_Vec2d aV2;
712 aCrv2->D1(par2, aP2d, aV2);
713
714 proj.Init(aP2d,aCrv1, aF1, aL1);
715 //check intermediate points
716 if(!proj.NbPoints() || proj.LowerDistance() > aMaxTol2d)
717 return Standard_False;
718 Standard_Real par1 = proj.LowerDistanceParameter();
719 gp_Pnt2d aP2d1;
720 gp_Vec2d aV1;
721 aCrv1->D1(par1, aP2d1, aV1);
722
723 if( !aV1.IsParallel(aV2, aTolAng))
724 return Standard_False;
725 }
726 return Standard_True;
727
728 }
729
730 //=======================================================================
731 //function : AddOpenWire
732 //purpose :
733 //=======================================================================
734
AddOpenWire(const TopoDS_Wire & W,const TopoDS_Face & F)735 Standard_Boolean LocOpe_SplitShape::AddOpenWire(const TopoDS_Wire& W,
736 const TopoDS_Face& F)
737 {
738 // On cherche la face descendante de F qui continent le wire
739 TopTools_ListOfShape& lf = myMap(F);
740 TopTools_ListIteratorOfListOfShape itl(lf);
741 TopoDS_Vertex Vfirst,Vlast;
742
743 BRepTools::Update(F);
744
745 Standard_Real tolf, toll, tol1;
746
747 TopoDS_Shape aLocalShape = W.Oriented(TopAbs_FORWARD);
748 TopExp::Vertices(TopoDS::Wire(aLocalShape),Vfirst,Vlast);
749
750 tolf = BRep_Tool::Tolerance(Vfirst);
751 toll = BRep_Tool::Tolerance(Vlast);
752 tol1 = Max(tolf, toll);
753
754
755 TopExp_Explorer exp,exp2;
756
757 TopoDS_Wire wfirst,wlast;
758 for (; itl.More(); itl.Next()) {
759 TopoDS_Face fac = TopoDS::Face(itl.Value());
760 if (!IsInside(fac,W)) {
761 continue;
762 }
763
764 fac.Orientation(TopAbs_FORWARD);
765 Standard_Boolean ffound = Standard_False;
766 Standard_Boolean lfound = Standard_False;
767 for (exp.Init(fac,TopAbs_WIRE); exp.More(); exp.Next()) {
768 const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
769 for (exp2.Init(wir,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
770 if (!ffound && exp2.Current().IsSame(Vfirst)) {
771 ffound = Standard_True;
772 wfirst = wir;
773 }
774 else if (!lfound && exp2.Current().IsSame(Vlast)) {
775 lfound = Standard_True;
776 wlast = wir;
777 }
778 if (ffound && lfound) {
779 break;
780 }
781 }
782 if (exp2.More()) {
783 break;
784 }
785 }
786 if (exp.More()) {
787 break;
788 }
789 }
790 if (!itl.More()) {
791 return Standard_False;
792 }
793
794 TopoDS_Face FaceRef = TopoDS::Face(itl.Value());
795 FaceRef.Orientation(TopAbs_FORWARD);
796 lf.Remove(itl);
797 BRep_Builder B;
798
799 BRepAdaptor_Surface BAS(FaceRef, Standard_False);
800
801 Standard_Boolean IsPeriodic = BAS.IsUPeriodic() || BAS.IsVPeriodic();
802
803 tol1 = Max(BAS.UResolution(tol1), BAS.VResolution(tol1));
804
805 if (wfirst.IsSame(wlast)) {
806 // on cree 2 faces en remplacement de itl.Value()
807 // Essai JAG
808 TopTools_ListOfShape WiresFirst;
809 for (exp.Init(wfirst,TopAbs_EDGE); exp.More(); exp.Next()) {
810 if (BRep_Tool::IsClosed(TopoDS::Edge(exp.Current()),FaceRef)) {
811 myDblE.Add(exp.Current());
812 }
813 WiresFirst.Append(exp.Current());
814 }
815
816 TopAbs_Orientation orient;
817 TopoDS_Wire newW1,newW2;
818 B.MakeWire(newW1);
819 newW1.Orientation(TopAbs_FORWARD);
820 B.MakeWire(newW2);
821 newW2.Orientation(TopAbs_FORWARD);
822
823 Standard_Integer nbE = 0;
824 for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
825 exp.More(); exp.Next()) {
826 nbE++;
827 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
828 orient = edg.Orientation();
829 WiresFirst.Append(edg);
830 WiresFirst.Append(edg.Oriented(TopAbs::Reverse(orient)));
831 myDblE.Add(edg);
832 }
833
834 TopTools_IndexedMapOfShape PossE;
835 TopTools_MapOfOrientedShape MapE;
836 TopoDS_Vertex vdeb,vfin;
837 Standard_Integer nbPoss;
838
839 // On recherche l`edge contenant Vlast
840 TopoDS_Edge LastEdge;
841 gp_Pnt2d pfirst,plast;
842 gp_Vec2d dlast;
843 Handle(Geom2d_Curve) C2d;
844 Standard_Real f,l;
845
846 for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
847 exp.More(); exp.Next()) {
848 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
849 for (exp2.Init(edg,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
850 if (exp2.Current().IsSame(Vfirst)) {
851 break;
852 }
853 }
854 if (exp2.More()) {
855 LastEdge = edg;
856 LastEdge.Orientation(edg.Orientation());
857 break;
858 }
859 }
860
861 TopoDS_Shape aLocalFace = FaceRef.Oriented(wfirst.Orientation());
862 C2d = BRep_Tool::CurveOnSurface(LastEdge, TopoDS::Face(aLocalFace), f, l);
863
864 if (LastEdge.Orientation() == TopAbs_FORWARD) {
865 pfirst = C2d->Value(f);
866 }
867 else {
868 pfirst = C2d->Value(l);
869 }
870
871 for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
872 exp.More(); exp.Next()) {
873 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
874 if( nbE>1 && edg.IsSame(LastEdge) )
875 continue;
876 for (exp2.Init(edg,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
877 if (exp2.Current().IsSame(Vlast)) {
878 break;
879 }
880 }
881 if (exp2.More()) {
882 LastEdge = edg;
883 LastEdge.Orientation(edg.Orientation());
884 break;
885 }
886 }
887 aLocalFace = FaceRef.Oriented(wfirst.Orientation());
888 GetDirection(LastEdge, TopoDS::Face(aLocalFace),plast , dlast, Standard_False);
889
890 Standard_Boolean cond = Standard_True;
891
892 if(IsPeriodic) {
893
894 cond = !(Vfirst.IsSame(Vlast) && SameUV(pfirst,plast,BAS));
895 }
896 else {
897 cond = !(Vfirst.IsSame(Vlast));
898 }
899
900 while (cond) {
901 PossE.Clear();
902
903 // On enchaine par la fin
904 TopTools_ListIteratorOfListOfShape lexp(WiresFirst);
905 for (; lexp.More(); lexp.Next()) {
906 const TopoDS_Edge& edg = TopoDS::Edge(lexp.Value());
907
908 orient = edg.Orientation();
909 TopExp::Vertices(edg,vdeb,vfin);
910
911 if ((orient == TopAbs_FORWARD && Vlast.IsSame(vdeb)) ||
912 (orient == TopAbs_REVERSED && Vlast.IsSame(vfin)))
913 PossE.Add(edg);
914 }
915 nbPoss = PossE.Extent();
916 if (nbPoss == 0)
917 {
918 break;
919 }
920
921 TopoDS_Edge aNextEdge;
922 if (nbPoss == 1) {
923 aNextEdge = TopoDS::Edge (PossE.FindKey (1));
924 TopoDS_Shape aLocalFaceTemp = FaceRef.Oriented(wfirst.Orientation());
925 GetDirection(aNextEdge, TopoDS::Face(aLocalFaceTemp),plast , dlast, Standard_False);
926
927 }
928 else if (nbPoss > 1) {
929 // Faire choix en U,V...
930 TopoDS_Shape aLocalFaceTemp = FaceRef.Oriented(wfirst.Orientation());
931
932 if(!ChoixUV(LastEdge, TopoDS::Face(aLocalFaceTemp), PossE,
933 aNextEdge, plast, dlast))
934 return Standard_False;
935
936 }
937
938 if (nbPoss >= 1) {
939 if (aNextEdge.IsNull())
940 {
941 // loop is not closed. Split is not possible
942 return Standard_False;
943 }
944
945 if (MapE.Contains(aNextEdge))
946 break;
947 B.Add(newW1, aNextEdge);
948 MapE.Add(aNextEdge);
949 LastEdge = aNextEdge;
950
951 if (LastEdge.Orientation() == TopAbs_FORWARD) {
952 Vlast = TopExp::LastVertex(LastEdge);
953 }
954 else {
955 Vlast = TopExp::FirstVertex(LastEdge);
956 }
957
958 toll = BRep_Tool::Tolerance(Vlast);
959 tol1 = Max(tolf, toll);
960
961 }
962 //MODIFICATION PIERRE SMEYERS : si pas de possibilite, on sort avec erreur
963 else{
964 std::cout<<"erreur Spliter : pas de chainage du wire"<<std::endl;
965 return Standard_False;
966 }
967 //fin MODIF.
968
969 tol1 = Max(BAS.UResolution(tol1), BAS.VResolution(tol1));
970
971 }
972
973 Standard_Integer nbAddBound =0;
974 TopTools_ListIteratorOfListOfShape lexp(WiresFirst);
975 TopoDS_Shape anE1, anE2;
976 for (; lexp.More(); lexp.Next()) {
977 const TopoDS_Edge& edg = TopoDS::Edge(lexp.Value());
978 if (!MapE.Contains(edg)) {
979 B.Add(newW2,edg);
980 MapE.Add(edg);
981 nbAddBound++;
982 if(anE1.IsNull())
983 anE1 = edg;
984 else
985 anE2 = edg;
986
987 }
988 }
989 //check overlapping edges for second face
990 if(nbAddBound <2)
991 return Standard_False;
992 if(nbAddBound ==2 && !anE1.IsNull() && !anE2.IsNull())
993 {
994 if(checkOverlapping(TopoDS::Edge(anE1), TopoDS::Edge(anE2),FaceRef ))
995 return Standard_False;
996
997 }
998
999 nbAddBound =0;
1000
1001 TopoDS_Shape anE11, anE12;
1002 TopoDS_Iterator anItE(newW1, Standard_False);
1003 for( ; anItE.More(); anItE.Next())
1004 {
1005 if( anItE.Value().ShapeType() != TopAbs_EDGE)
1006 continue;
1007 nbAddBound++;
1008 if(anE11.IsNull())
1009 anE11 = anItE.Value();
1010 else
1011 anE12 = anItE.Value();
1012
1013 }
1014 //check overlapping edges for first face
1015 if(nbAddBound <2)
1016 return Standard_False;
1017 if(nbAddBound ==2 && !anE11.IsNull() && !anE12.IsNull())
1018 {
1019 if(checkOverlapping(TopoDS::Edge(anE11), TopoDS::Edge(anE12), FaceRef))
1020 return Standard_False;
1021
1022 }
1023
1024 TopoDS_Face newF1,newF2;
1025 aLocalFace = FaceRef.EmptyCopied();
1026 newF1 = TopoDS::Face(aLocalFace);
1027 newF1.Orientation(TopAbs_FORWARD);
1028 aLocalFace = FaceRef.EmptyCopied();
1029 newF2 = TopoDS::Face(aLocalFace);
1030 newF2.Orientation(TopAbs_FORWARD);
1031
1032 // modifs JAG 97.05.28
1033
1034 B.Add(newF1,newW1);
1035 B.Add(newF2,newW2);
1036 for (exp.Init(FaceRef.Oriented(TopAbs_FORWARD),TopAbs_WIRE); exp.More(); exp.Next()) {
1037 const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
1038 if (!wir.IsSame(wfirst)) {
1039 if (IsInside(newF1, wir)) {
1040 B.Add(newF1,wir);
1041 }
1042 else if (IsInside(newF2, wir)) {
1043 B.Add(newF2,wir);
1044 }
1045 else {
1046 // Ce wire est ni dans newF2 ni dans newF1
1047 // Peut etre faut il construire une troisieme face
1048 std::cout << "WARNING: LocOpe_SPlitShape : Ce wire est ni dans newF2 ni dans newF1" << std::endl;
1049 }
1050 }
1051 }
1052 lf.Append(newF1);
1053 lf.Append(newF2);
1054
1055 // Mise a jour des descendants des wires
1056 for (exp.Init(F,TopAbs_WIRE); exp.More(); exp.Next()) {
1057 TopTools_ListOfShape& ls = myMap(exp.Current());
1058 itl.Initialize(ls);
1059 for (; itl.More(); itl.Next()) {
1060 if (itl.Value().IsSame(wfirst)) {
1061 break;
1062 }
1063 }
1064 if (itl.More()) { // on a trouve le wire
1065 ls.Remove(itl);
1066 ls.Append(newW1);
1067 ls.Append(newW2);
1068 }
1069 }
1070 }
1071 else {
1072 // on ne cree qu`une seule face
1073 TopoDS_Wire outerW = BRepTools::OuterWire(FaceRef);
1074 TopoDS_Wire newWire;
1075 TopoDS_Face newFace;
1076 B.MakeWire(newWire);
1077 newWire.Orientation(TopAbs_FORWARD);
1078 TopAbs_Orientation orient,orRelat;
1079
1080 if (wfirst.Orientation() == wlast.Orientation()) {
1081 orRelat = TopAbs_FORWARD;
1082 }
1083 else {
1084 orRelat = TopAbs_REVERSED;
1085 }
1086
1087 if (wlast.IsSame(outerW)) {
1088 wlast = wfirst;
1089 wfirst = outerW;
1090 }
1091
1092 // Edges de wfirst
1093 for (exp.Init(wfirst.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
1094 exp.More(); exp.Next()) {
1095 B.Add(newWire,TopoDS::Edge(exp.Current()));
1096 }
1097
1098 // Edges de wlast
1099 for (exp.Init(wlast.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
1100 exp.More(); exp.Next()) {
1101 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1102 orient = TopAbs::Compose(edg.Orientation(),orRelat);
1103 B.Add(newWire,edg.Oriented(orient));
1104 }
1105
1106
1107 // Edges du wire ajoute, et dans les 2 sens
1108 for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
1109 exp.More(); exp.Next()) {
1110 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1111 orient = edg.Orientation();
1112 B.Add(newWire,edg.Oriented(orient));
1113 B.Add(newWire,edg.Oriented(TopAbs::Reverse(orient)));
1114 myDblE.Add(edg.Oriented(orient));
1115 }
1116
1117 // on refait une face
1118
1119 TopoDS_Shape aLocalFace = FaceRef.EmptyCopied();
1120 newFace = TopoDS::Face(aLocalFace);
1121 // newFace = TopoDS::Face(FaceRef.EmptyCopied());
1122 FaceRef.Orientation(TopAbs_FORWARD);
1123 for (exp.Init(FaceRef.Oriented(TopAbs_FORWARD),TopAbs_WIRE);
1124 exp.More(); exp.Next()) {
1125 const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
1126 if (wir.IsSame(wfirst)) {
1127 B.Add(newFace,newWire.Oriented(wir.Orientation()));
1128 }
1129 else if (!wir.IsSame(wlast)) {
1130 B.Add(newFace,wir);
1131 }
1132 }
1133 lf.Append(newFace);
1134
1135 // Mise a jour des descendants des wires
1136 for (exp.Init(F,TopAbs_WIRE); exp.More(); exp.Next()) {
1137 TopTools_ListOfShape& ls = myMap(exp.Current());
1138 itl.Initialize(ls);
1139 Standard_Boolean touch = Standard_False;
1140 while (itl.More()) {
1141 if (itl.Value().IsSame(wfirst) || itl.Value().IsSame(wlast)) {
1142 ls.Remove(itl);
1143 touch = Standard_True;
1144 }
1145 else {
1146 itl.Next();
1147 }
1148 }
1149 if (touch) {
1150 ls.Append(newWire);
1151 }
1152
1153 }
1154 }
1155 return Standard_True;
1156 }
1157
1158
1159 //=======================================================================
1160 //function : LeftOf
1161 //purpose :
1162 //=======================================================================
1163
LeftOf(const TopoDS_Wire & W,const TopoDS_Face & F)1164 const TopTools_ListOfShape& LocOpe_SplitShape::LeftOf(const TopoDS_Wire& W,
1165 const TopoDS_Face& F)
1166 {
1167 if (myShape.IsNull()) {
1168 throw Standard_NoSuchObject();
1169 }
1170
1171 TopExp_Explorer exp,expw,expf;
1172 exp.Init(myShape,TopAbs_FACE);
1173 for (; exp.More(); exp.Next()) {
1174 if (exp.Current().IsSame(F)) {
1175 break;
1176 }
1177 }
1178 if (!exp.More()) {
1179 throw Standard_NoSuchObject();
1180 }
1181 myLeft.Clear();
1182
1183 const TopoDS_Face& theFace = TopoDS::Face(exp.Current());
1184 TopAbs_Orientation orFace = theFace.Orientation();
1185 TopTools_ListIteratorOfListOfShape itl,itl2;
1186
1187 for (expw.Init(W,TopAbs_EDGE); expw.More(); expw.Next()) {
1188 const TopoDS_Edge& edg = TopoDS::Edge(expw.Current());
1189 for (itl.Initialize(myMap(theFace)); itl.More(); itl.Next()) {
1190 TopoDS_Face fac = TopoDS::Face(itl.Value());
1191 fac.Orientation(orFace);
1192 for (expf.Init(fac,TopAbs_EDGE); expf.More(); expf.Next()) {
1193 const TopoDS_Edge& edgbis = TopoDS::Edge(expf.Current());
1194 if (edgbis.IsSame(edg) &&
1195 edgbis.Orientation() == edg.Orientation()) {
1196 for (itl2.Initialize(myLeft); itl2.More(); itl2.Next()) {
1197 if (itl2.Value().IsSame(fac)) {
1198 break;
1199 }
1200 }
1201 if (!itl2.More()) { // la face n`est pas deja presente
1202 myLeft.Append(fac);
1203 }
1204 break;
1205 }
1206 }
1207 if (expf.More()) { // face found
1208 break;
1209 }
1210 }
1211 }
1212 return myLeft;
1213 }
1214
1215
1216 //=======================================================================
1217 //function : DescendantShapes
1218 //purpose :
1219 //=======================================================================
1220
DescendantShapes(const TopoDS_Shape & S)1221 const TopTools_ListOfShape& LocOpe_SplitShape::DescendantShapes
1222 (const TopoDS_Shape& S)
1223 {
1224 if (!myDone) {
1225 Rebuild(myShape);
1226 myDone = Standard_True;
1227 }
1228 #ifdef OCCT_DEBUG
1229 if (!myDblE.IsEmpty()) {
1230 std::cout << "Le shape comporte des faces invalides" << std::endl;
1231 }
1232 #endif
1233 return myMap(S);
1234 }
1235
1236
1237
1238 //=======================================================================
1239 //function : Put
1240 //purpose :
1241 //=======================================================================
1242
Put(const TopoDS_Shape & S)1243 void LocOpe_SplitShape::Put(const TopoDS_Shape& S)
1244 {
1245 if (!myMap.IsBound(S)) {
1246 TopTools_ListOfShape thelist;
1247 myMap.Bind(S, thelist);
1248 if (S.ShapeType() != TopAbs_VERTEX) {
1249 for(TopoDS_Iterator theIterator(S);theIterator.More();
1250 theIterator.Next()) {
1251 Put(theIterator.Value());
1252 }
1253 }
1254 else {
1255 myMap(S).Append(S);
1256 }
1257 }
1258 }
1259
updateToleraces(const TopoDS_Face & theFace,const TopTools_DataMapOfShapeListOfShape & theMap)1260 static void updateToleraces(const TopoDS_Face& theFace, const TopTools_DataMapOfShapeListOfShape& theMap)
1261 {
1262 TopExp_Explorer aExpE(theFace, TopAbs_EDGE);
1263 for (; aExpE.More(); aExpE.Next())
1264 {
1265 if (!theMap.IsBound(aExpE.Current()))
1266 continue;
1267 const TopTools_ListOfShape& lEdges = theMap(aExpE.Current());
1268 if (lEdges.Extent() <= 1)
1269 continue;
1270
1271 TopTools_ListIteratorOfListOfShape itrE(lEdges);
1272 ShapeAnalysis_Edge aSae;
1273
1274 for (; itrE.More(); itrE.Next())
1275 {
1276 TopoDS_Edge aCurE = TopoDS::Edge(itrE.Value());
1277 Standard_Real amaxdev = 0.;
1278 if (aSae.CheckSameParameter(aCurE, theFace, amaxdev))
1279 {
1280 BRep_Builder aB;
1281 aB.UpdateEdge(aCurE, amaxdev);
1282 }
1283 }
1284 }
1285
1286 }
1287 //=======================================================================
1288 //function : Rebuild
1289 //purpose :
1290 //=======================================================================
1291
Rebuild(const TopoDS_Shape & S)1292 Standard_Boolean LocOpe_SplitShape::Rebuild(const TopoDS_Shape& S)
1293
1294 {
1295 if (S.ShapeType() == TopAbs_FACE)
1296 updateToleraces(TopoDS::Face(S), myMap);
1297 TopTools_ListIteratorOfListOfShape itr(myMap(S));
1298 if (itr.More()) {
1299 if (itr.Value().IsSame(S)) {
1300 return Standard_False;
1301 }
1302 return Standard_True;
1303 }
1304 Standard_Boolean rebuild = Standard_False;
1305 TopoDS_Iterator it;
1306 for(it.Initialize(S); it.More(); it.Next()) {
1307 rebuild = Rebuild(it.Value()) || rebuild;
1308 }
1309
1310 if (rebuild) {
1311 BRep_Builder B;
1312 TopoDS_Shape result = S.EmptyCopied();
1313 TopAbs_Orientation orient;
1314 for(it.Initialize(S); it.More(); it.Next()) {
1315 orient = it.Value().Orientation();
1316 for (itr.Initialize(myMap(it.Value())); itr.More(); itr.Next()) {
1317 B.Add(result,itr.Value().Oriented(orient));
1318 }
1319 }
1320 // Assign "Closed" flag for Wires and Shells only
1321 if (result.ShapeType() == TopAbs_WIRE || result.ShapeType() == TopAbs_SHELL)
1322 result.Closed (BRep_Tool::IsClosed(result));
1323 myMap(S).Append(result);
1324 }
1325 else {
1326 myMap(S).Append(S);
1327 }
1328 return rebuild;
1329 }
1330
1331
1332
1333 //=======================================================================
1334 //function : IsInside
1335 //purpose :
1336 //=======================================================================
1337
IsInside(const TopoDS_Face & F,const TopoDS_Wire & W1,const TopoDS_Wire & W2)1338 static Standard_Boolean IsInside(const TopoDS_Face& F,
1339 const TopoDS_Wire& W1,
1340 const TopoDS_Wire& W2)
1341 {
1342 // Attention, c`est tres boeuf !!!!
1343 BRep_Builder B;
1344 TopoDS_Shape aLocalShape = F.EmptyCopied();
1345 TopoDS_Face newFace = TopoDS::Face(aLocalShape);
1346 // TopoDS_Face newFace = TopoDS::Face(F.EmptyCopied());
1347
1348 //TopAbs_Orientation orWire = W2.Orientation();
1349
1350 newFace.Orientation(TopAbs_FORWARD);
1351 B.Add(newFace,W2);
1352 // GProp_GProps GP;
1353 // BRepGProp::SurfaceProperties(newFace,GP);
1354 // if (GP.Mass() < 0) {
1355 BRepTopAdaptor_FClass2d classif(newFace,Precision::PConfusion());
1356 Standard_Boolean Reversed = Standard_False;
1357 if (classif.PerformInfinitePoint() == TopAbs_IN) {
1358 //le wire donne defini un trou
1359 // newFace = TopoDS::Face(F.EmptyCopied());
1360 // newFace.Orientation(TopAbs_FORWARD);
1361 // orWire = TopAbs::Reverse(orWire);
1362 // B.Add(newFace,W2.Oriented(orWire));
1363 Reversed = Standard_True;
1364 }
1365
1366 // Standard_Real U,V;
1367 TopExp_Explorer exp(W1,TopAbs_EDGE);
1368 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1369 TopExp_Explorer exp2(edg,TopAbs_VERTEX);
1370 const TopoDS_Vertex& vtx = TopoDS::Vertex(exp2.Current());
1371 Standard_Real prm = BRep_Tool::Parameter(vtx,edg);
1372 Standard_Real f,l;
1373 Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
1374 if(C2d.IsNull()) {
1375 #ifdef OCCT_DEBUG
1376 std::cout << "Edge is not on surface" <<std::endl;
1377 #endif
1378 return Standard_False;
1379 }
1380 gp_Pnt2d pt2d(C2d->Value(prm));
1381 // BRepClass_FaceClassifier classif(newFace,pt2d,Precision::PConfusion());
1382 // return (classif.State() == TopAbs_IN);
1383 if (!Reversed) {
1384 return (classif.Perform(pt2d) == TopAbs_IN);
1385 }
1386 else {
1387 return (classif.Perform(pt2d) == TopAbs_OUT);
1388 }
1389 }
1390
1391
1392 //=======================================================================
1393 //function : IsInside
1394 //purpose :
1395 //=======================================================================
1396
IsInside(const TopoDS_Face & F,const TopoDS_Wire & W)1397 static Standard_Boolean IsInside(const TopoDS_Face& F,
1398 const TopoDS_Wire& W)
1399 {
1400 // Attention, c`est tres boeuf !!!!
1401 TopExp_Explorer exp(W,TopAbs_EDGE);
1402 for( ; exp.More(); exp.Next()) {
1403 const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1404 // TopExp_Explorer exp2(edg,TopAbs_VERTEX);
1405 // const TopoDS_Vertex& vtx = TopoDS::Vertex(exp2.Current());
1406 // Standard_Real prm = BRep_Tool::Parameter(vtx,edg);
1407 Standard_Real f,l,prm;
1408 Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
1409 if (!Precision::IsNegativeInfinite(f) &&
1410 !Precision::IsPositiveInfinite(l)) {
1411 prm = (f+l)/2.;
1412 }
1413 else {
1414 if (Precision::IsNegativeInfinite(f) &&
1415 Precision::IsPositiveInfinite(l)){
1416 prm = 0.;
1417 }
1418 else if (Precision::IsNegativeInfinite(f)) {
1419 prm = l-1.;
1420 }
1421 else {
1422 prm = f+1.;
1423 }
1424 }
1425
1426 gp_Pnt2d pt2d(C2d->Value(prm));
1427 // BRepClass_FaceClassifier classif(F,pt2d,Precision::PConfusion());
1428 // return (classif.State() != TopAbs_OUT);
1429 BRepTopAdaptor_FClass2d classif(F,Precision::PConfusion());
1430 TopAbs_State stat = classif.Perform(pt2d);
1431 // return (classif.Perform(pt2d) != TopAbs_OUT);
1432 if(stat == TopAbs_OUT) return Standard_False;
1433
1434 if(stat == TopAbs_ON) {
1435 Standard_Integer nbPnt =10;
1436 Standard_Integer nbOut =0,nbIn =0,nbOn=0;
1437 Standard_Integer j =1;
1438 for( ; j<= nbPnt ; j++)
1439 {
1440 //check neighbouring point
1441 //prm = .66 * prm + .34 * l;
1442 prm = f + (l-f)/nbPnt*(j-1);
1443 pt2d = C2d->Value(prm);
1444 stat = classif.Perform(pt2d);
1445 if(stat == TopAbs_OUT )
1446 nbOut++;
1447 else if(stat == TopAbs_IN)
1448 nbIn++;
1449 else
1450 nbOn++;
1451 }
1452 if(nbOut > nbIn + nbOn)
1453 return Standard_False;
1454 }
1455 }
1456 return Standard_True;
1457 }
1458
1459 //=======================================================================
1460 //function : GetDirection
1461 //purpose :
1462 //=======================================================================
GetDirection(const TopoDS_Edge & theEdge,const TopoDS_Face & theFace,gp_Pnt2d & thePnt,gp_Vec2d & theDir,Standard_Boolean isFirstEnd)1463 static void GetDirection(const TopoDS_Edge& theEdge,
1464 const TopoDS_Face& theFace,
1465 gp_Pnt2d& thePnt,
1466 gp_Vec2d& theDir,
1467 Standard_Boolean isFirstEnd)
1468 {
1469 Standard_Real aFirst, aLast;
1470 Handle(Geom2d_Curve) aC2d = BRep_Tool::CurveOnSurface (theEdge, theFace, aFirst, aLast);
1471
1472 TopAbs_Orientation anOr = theEdge.Orientation();
1473 TopoDS_Vertex aVtx;
1474 Standard_Boolean takeFirst = ((anOr == TopAbs_FORWARD && isFirstEnd) ||
1475 (anOr == TopAbs_REVERSED && !isFirstEnd));
1476
1477 Standard_Real dpar = (aLast - aFirst)*0.01;
1478 gp_Pnt2d aP2d;
1479 if (takeFirst)
1480 {
1481 aC2d->D0 (aFirst, thePnt);
1482 gp_Pnt2d aNextPnt = aC2d->Value(aFirst + dpar);
1483 theDir = gp_Vec2d(thePnt, aNextPnt);
1484 }
1485
1486 else
1487 {
1488 aC2d->D0 (aLast, thePnt);
1489 gp_Pnt2d aPrevPnt = aC2d->Value(aLast - dpar);
1490 theDir = gp_Vec2d( aPrevPnt, thePnt );
1491 }
1492 if(anOr == TopAbs_REVERSED)
1493 theDir.Reverse();
1494 }
1495
1496 //=======================================================================
1497 //function : ChoixUV
1498 //purpose :
1499 //=======================================================================
1500
ChoixUV(const TopoDS_Edge & Last,const TopoDS_Face & F,const TopTools_IndexedMapOfShape & Poss,TopoDS_Edge & theResEdge,gp_Pnt2d & plst,gp_Vec2d & dlst)1501 Standard_Boolean ChoixUV(const TopoDS_Edge& Last,
1502 const TopoDS_Face& F,
1503 const TopTools_IndexedMapOfShape& Poss,
1504 TopoDS_Edge& theResEdge,
1505 gp_Pnt2d& plst,
1506 gp_Vec2d& dlst)
1507 {
1508 gp_Pnt2d p2d;
1509 gp_Vec2d v2d;
1510 gp_Pnt aPCur, aPlst;
1511
1512 BRepAdaptor_Surface surf(F,Standard_False); // no restriction
1513 surf.D0 (plst.X(), plst.Y(), aPlst);
1514
1515 gp_Dir2d ref2d(dlst);
1516
1517 Handle(Geom2d_Curve) C2d;
1518
1519
1520 Standard_Integer index = 0, imin=0;
1521 Standard_Real angmax = -M_PI, ang;
1522
1523 for (index = 1; index <= Poss.Extent(); index++) {
1524 TopoDS_Edge anEdge = TopoDS::Edge (Poss.FindKey (index));
1525
1526 GetDirection(anEdge, F, p2d, v2d, Standard_True);
1527 if(!SameUV(plst,p2d,surf))
1528 continue;
1529
1530 surf.D0 (p2d.X(), p2d.Y(), aPCur);
1531
1532 if (!Last.IsSame(anEdge)) {
1533 ang = ref2d.Angle(gp_Dir2d(v2d));
1534 }
1535 else {
1536 ang = -M_PI;
1537 }
1538
1539 if ( (ang > angmax)) {
1540 imin = index;
1541 angmax = ang;
1542 }
1543 }
1544
1545 if (imin)
1546 {
1547 theResEdge = TopoDS::Edge (Poss.FindKey (imin));
1548 GetDirection(theResEdge, F, plst, dlst, Standard_False);
1549 }
1550
1551 return imin != 0;
1552 }
1553
1554 //=======================================================================
1555 //function : ChooseDirection
1556 //purpose :
1557 //=======================================================================
1558
ChooseDirection(const TopoDS_Shape & RefDir,const TopoDS_Vertex & RefVertex,const TopoDS_Face & theFace,const TopTools_ListOfShape & Ldirs)1559 static TopoDS_Shape ChooseDirection(const TopoDS_Shape& RefDir,
1560 const TopoDS_Vertex& RefVertex,
1561 const TopoDS_Face& theFace,
1562 const TopTools_ListOfShape& Ldirs)
1563 {
1564 TopExp_Explorer Explo(RefDir, TopAbs_EDGE);
1565 TopoDS_Edge RefEdge;
1566 TopoDS_Vertex V1, V2;
1567 TopAbs_Orientation anOr = TopAbs_FORWARD;
1568 for (; Explo.More(); Explo.Next())
1569 {
1570 RefEdge = TopoDS::Edge(Explo.Current());
1571 TopExp::Vertices(RefEdge, V1, V2);
1572 if (V1.IsSame(RefVertex))
1573 {
1574 anOr = TopAbs_REVERSED;
1575 break;
1576 }
1577 else if (V2.IsSame(RefVertex))
1578 {
1579 anOr = TopAbs_FORWARD;
1580 break;
1581 }
1582 }
1583
1584 Standard_Real RefFirst, RefLast;
1585 Handle(Geom2d_Curve) RefCurve = BRep_Tool::CurveOnSurface(RefEdge, theFace, RefFirst, RefLast);
1586 gp_Pnt2d RefPnt;
1587 gp_Vec2d RefVec;
1588
1589 //Standard_Real RefPar = (RefEdge.Orientation() == TopAbs_FORWARD)? RefLast : RefFirst;
1590 Standard_Real RefPar = (anOr == TopAbs_FORWARD)? RefLast : RefFirst;
1591 RefCurve->D1(RefPar, RefPnt, RefVec);
1592 if (anOr == TopAbs_FORWARD)
1593 RefVec.Reverse();
1594
1595 Handle(Geom2d_Curve) aCurve;
1596 Standard_Real aFirst, aLast, aPar;
1597 gp_Vec2d aVec;
1598 Standard_Real MinAngle = RealLast(), anAngle;
1599 TopoDS_Shape TargetDir;
1600 TopTools_ListIteratorOfListOfShape itl(Ldirs);
1601 for (; itl.More(); itl.Next())
1602 {
1603 const TopoDS_Shape& aShape = itl.Value();
1604 TopoDS_Edge anEdge;
1605 for (Explo.Init(aShape, TopAbs_EDGE); Explo.More(); Explo.Next())
1606 {
1607 anEdge = TopoDS::Edge(Explo.Current());
1608 TopExp::Vertices(anEdge, V1, V2);
1609 if (V1.IsSame(RefVertex))
1610 {
1611 anOr = TopAbs_FORWARD;
1612 break;
1613 }
1614 else if (V2.IsSame(RefVertex))
1615 {
1616 anOr = TopAbs_REVERSED;
1617 break;
1618 }
1619 }
1620 aCurve = BRep_Tool::CurveOnSurface(anEdge, theFace, aFirst, aLast);
1621 aPar = (anOr == TopAbs_FORWARD)? aFirst : aLast;
1622 aCurve->D1(aPar, RefPnt, aVec);
1623 if (anOr == TopAbs_REVERSED)
1624 aVec.Reverse();
1625 anAngle = aVec.Angle(RefVec);
1626 if (anAngle < 0.)
1627 anAngle += 2.*M_PI;
1628
1629 if (anAngle < MinAngle)
1630 {
1631 MinAngle = anAngle;
1632 TargetDir = aShape;
1633 }
1634 }
1635
1636 return TargetDir;
1637 }
1638