projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Adding of testing cases from subgroups 937 940 and 941 of CHL group
[occt.git] / src / BOP / BOP_ShellSolid_2.cxx
CommitLineData
b311480e 1// Created on: 2001-11-02
2// Created by: Peter KURNEV
3// Copyright (c) 2001-2012 OPEN CASCADE SAS
4//
5// The content of this file is subject to the Open CASCADE Technology Public
6// License Version 6.5 (the "License"). You may not use the content of this file
7// except in compliance with the License. Please obtain a copy of the License
8// at http://www.opencascade.org and read it completely before using this file.
9//
10// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12//
13// The Original Code and all software distributed under the License is
14// distributed on an "AS IS" basis, without warranty of any kind, and the
15// Initial Developer hereby disclaims all such warranties, including without
16// limitation, any warranties of merchantability, fitness for a particular
17// purpose or non-infringement. Please see the License for the specific terms
18// and conditions governing the rights and limitations under the License.
19
7fd59977 20
21#include <BOP_ShellSolid.ixx>
22
23#include <TColStd_ListOfInteger.hxx>
24#include <TColStd_ListIteratorOfListOfInteger.hxx>
25
26#include <TopAbs_State.hxx>
27#include <TopAbs_Orientation.hxx>
28
29#include <TopExp_Explorer.hxx>
30#include <TopTools_IndexedMapOfShape.hxx>
31#include <BRep_Tool.hxx>
32#include <TopoDS_Shape.hxx>
33#include <TopoDS_Edge.hxx>
34#include <TopoDS_Face.hxx>
35#include <TopoDS.hxx>
36
37#include <BooleanOperations_ShapesDataStructure.hxx>
38#include <BooleanOperations_IndexedDataMapOfShapeInteger.hxx>
39
40#include <IntTools_Context.hxx>
41
42#include <BOPTools_InterferencePool.hxx>
43#include <BOPTools_CArray1OfSSInterference.hxx>
44#include <BOPTools_SSInterference.hxx>
45#include <BOPTools_SequenceOfCurves.hxx>
46#include <BOPTools_Curve.hxx>
47#include <BOPTools_ListOfPaveBlock.hxx>
48#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
49#include <BOPTools_PaveBlock.hxx>
50
51#include <BOPTools_Tools3D.hxx>
52#include <BOPTools_PaveFiller.hxx>
53#include <BOPTools_CommonBlockPool.hxx>
54#include <BOPTools_InterferencePool.hxx>
55#include <BOPTools_CArray1OfSSInterference.hxx>
56
57#include <BOPTools_SSInterference.hxx>
58#include <BOPTools_ListOfCommonBlock.hxx>
59#include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
60#include <BOPTools_CommonBlock.hxx>
61
62#include <BOP_BuilderTools.hxx>
63#include <BOP_SDFWESFiller.hxx>
64
65
66static
67 void AddPartsEF (const TopoDS_Edge& aSSin,
68 const TopoDS_Edge& aEF2,
69 const TopoDS_Face& aF2,
70 const TopoDS_Face& myFace,
71 const Standard_Integer iRankF1,
72 const BOP_Operation myOperation,
73 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF,
74 BOP_WireEdgeSet& aWES);
75static
76 void AddPartEF1INF2 (TopoDS_Edge& aSS,
77 const TopoDS_Face& myFace,
78 const TopoDS_Face& aF2,
79 const Standard_Integer iRankF1,
80 const BOP_Operation myOperation,
81 BOP_WireEdgeSet& aWES);
82static
83 void BothInternals (TopoDS_Edge& aSS,
84 const TopoDS_Face& myFace,
85 const TopoDS_Face& aF2,
86 const Standard_Integer iRankF1,
87 const BOP_Operation myOperation,
88 BOP_WireEdgeSet& aWES);
89static
90 void FirstInternal(TopoDS_Edge& aSS,
91 const TopoDS_Face& myFace,
92 const TopoDS_Face& aF2,
93 const TopoDS_Edge& anEF2,
94 TopoDS_Edge& aSSx,
95 const Standard_Integer iRankF1,
96 const BOP_Operation myOperation,
97 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF,
98 BOP_WireEdgeSet& aWES,
4f189102 99 const Handle(IntTools_Context)& aContext);
7fd59977 100
101static
102 void SecondInternal(TopoDS_Edge& aSS,
103 const TopoDS_Face& aF1,
104 const TopoDS_Face& aF2,
105 const TopoDS_Edge& anEF1,
106 TopoDS_Edge& aSSx,
107 const TopAbs_Orientation anOrEF1,
108 const Standard_Integer iRankF1,
109 const BOP_Operation myOperation,
110 BOP_WireEdgeSet& aWES,
4f189102 111 const Handle(IntTools_Context)& aContext);
7fd59977 112
113
114//=======================================================================
115//
116// the WES components for a solid
117//
118//=======================================================================
119// function: AddSectionPartsSo
120// purpose:
121//=======================================================================
122 void BOP_ShellSolid::AddSectionPartsSo (const Standard_Integer nF1,
123 const Standard_Integer iFF,
124 BOP_WireEdgeSet& aWES)
125{
126 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
127
128 BOPTools_InterferencePool* pIntrPool=
129 (BOPTools_InterferencePool*)&myDSFiller->InterfPool();
130
131 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
132 //
133 Standard_Integer i, aNbCurves, nF2, nE, iRankF1;
134 Standard_Boolean bIsTouchCase;
135 //
136 iRankF1=aDS.Rank(nF1);
137 //
138 BOPTools_SSInterference& aFF=aFFs(iFF);
139 nF2=aFF.OppositeIndex(nF1);
140 //
141 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
142 //
143 BOPTools_SequenceOfCurves& aSC=aFF.Curves();
144 aNbCurves=aSC.Length();
145 for (i=1; i<=aNbCurves; i++) {
146 const BOPTools_Curve& aBC=aSC(i);
147 const BOPTools_ListOfPaveBlock& aLPB=aBC.NewPaveBlocks();
148 BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
149 for (; anIt.More(); anIt.Next()) {
150 const BOPTools_PaveBlock& aPB=anIt.Value();
151 nE=aPB.Edge();
152 const TopoDS_Edge& aE=TopoDS::Edge(aDS.Shape(nE));
153
154 TopoDS_Edge aES=aE;
155 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aES, myFace, aF2);
156 if (bIsTouchCase) {
157 aWES.AddStartElement (aES);
158 aES.Reverse();
159 aWES.AddStartElement (aES);
160 }
161 else {
162 BOP_BuilderTools::OrientSectionEdgeOnF1
163 (myFace, aF2, iRankF1, myOperation, aES);
164 aWES.AddStartElement (aES);
165 }
166 }
167 }
168}
169//=======================================================================
170// function: AddSplitPartsON3DSo
171// purpose:
172//=======================================================================
173 void BOP_ShellSolid::AddSplitPartsON3DSo(const Standard_Integer nF1,
174 const Standard_Integer iFF,
175 BOP_WireEdgeSet& aWES)
176{
177 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
178 const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
179
180 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPaveFiller;
181 BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
182
183 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
184 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
185 //
4f189102 186 const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
7fd59977 187 //
188 Standard_Boolean bIsToKeep;
189 Standard_Integer nEF1, nF2, nF2x, nSpF1, iRankF1;
190 TopAbs_Orientation anOrEF1;
191 TopExp_Explorer anExp;
192 //
193 BOPTools_SSInterference& aFF=aFFs(iFF);
194 nF2=aFF.OppositeIndex(nF1);
195
196 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
197 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
198
199 iRankF1=aDS.Rank(nF1);
200 //
201 //
202 anExp.Init(myFace, TopAbs_EDGE);
203 for (; anExp.More(); anExp.Next()) {
204 const TopoDS_Edge& anEF1=TopoDS::Edge(anExp.Current());
205 anOrEF1=anEF1.Orientation();
206
207 nEF1=aDS.ShapeIndex(anEF1, iRankF1);
208
209 BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nEF1));
210
211 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
212 for (; anItCB.More(); anItCB.Next()) {
213 BOPTools_CommonBlock& aCB=anItCB.Value();
214
215 BOPTools_PaveBlock& aPBEF1=aCB.PaveBlock1(nEF1);
216 //
217 nF2x=aCB.Face();
218
219 if (nF2x==nF2) {
220 // Splits that are ON (IN 2D) for other Face (aF2)
221 nSpF1=aPBEF1.Edge();
222 const TopoDS_Shape& aSplit=aDS.Shape(nSpF1);
223 TopoDS_Edge aSS=TopoDS::Edge(aSplit);
224 //
225 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
226 // Internal edges treatment
227 {
228 if (anOrEF1==TopAbs_INTERNAL) {
229 AddPartEF1INF2(aSS, myFace, aF2, iRankF1, myOperation, aWES);
230 continue;
231 }
232 }
233 //
234 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
235 //
236 aSS.Orientation(anOrEF1);
237 //
238 TopAbs_State aState1=
239 BOPTools_Tools3D::GetStatePartIN2D(aSS, anEF1, aF1, aF2, aContext);
240 //
241 bIsToKeep=
242 BOP_BuilderTools::IsPartIN2DToKeep(aState1, iRankF1, myOperation);
243 //
244 if (bIsToKeep) {
245 aWES.AddStartElement (aSS);
246 }
247 }
248 }
249 }
250}
251//=======================================================================
252// function: AddSplitPartsONSo
253// purpose:
254//=======================================================================
255 void BOP_ShellSolid::AddSplitPartsONSo(const Standard_Integer nF1,
256 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFObj,
257 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFTool,
258 BOP_WireEdgeSet& aWES)
259{
260 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
261 const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
262
263 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPaveFiller;
264 BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
265 //
4f189102 266 const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
7fd59977 267 //
268 Standard_Integer nEF1, nF2, nSpF1, nSpF2, nEF2, nSpTaken, iRankF1;
269 TopAbs_Orientation anOrEF1, anOrEF2;
270 TopExp_Explorer anExp;
271 TopTools_IndexedMapOfShape aM;
272 //
273 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
274 iRankF1=aDS.Rank(nF1);
275 //
276 //
277 anExp.Init(myFace, TopAbs_EDGE);
278 for (; anExp.More(); anExp.Next()) {
279 const TopoDS_Edge& anEF1=TopoDS::Edge(anExp.Current());
280 anOrEF1=anEF1.Orientation();
281
282 nEF1=aDS.ShapeIndex(anEF1, iRankF1);
283
284 BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nEF1));
285
286 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
287 for (; anItCB.More(); anItCB.Next()) {
288 BOPTools_CommonBlock& aCB=anItCB.Value();
289
290 BOPTools_PaveBlock& aPBEF1=aCB.PaveBlock1(nEF1);
291 BOPTools_PaveBlock& aPBEF2=aCB.PaveBlock2(nEF1);
292 nF2=aCB.Face();
293 if (nF2) {
294 // Splits that are ON (IN 2D) for other Face (aF2)
295 Standard_Boolean bIsToKeep;
296
297 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
298
299 nSpF1=aPBEF1.Edge();
300 const TopoDS_Shape& aSplit=aDS.Shape(nSpF1);
301 TopoDS_Edge aSS=TopoDS::Edge(aSplit);
302 //
303 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
304 // Internal edges treatment
305 {
306 if (anOrEF1==TopAbs_INTERNAL) {
307 AddPartEF1INF2(aSS, myFace, aF2, iRankF1, myOperation, aWES);
308 continue;
309 }
310 }
311 //
312 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
313 //
314 aSS.Orientation(anOrEF1);
315 //
316 TopAbs_State aState1=
317 BOPTools_Tools3D::GetStatePartIN2D(aSS, anEF1, aF1, aF2, aContext);
318
319 bIsToKeep=
320 BOP_BuilderTools::IsPartIN2DToKeep(aState1, iRankF1, myOperation);
321 //
322 if (bIsToKeep) {
323 aWES.AddStartElement (aSS);
324 }
325 //
326 }
327 else {// else x
328 // Splits that are ON other Edge from other Face
329 nSpF1=aPBEF1.Edge();
330 nSpF2=aPBEF2.Edge();
331 nEF2=aPBEF2.OriginalEdge();
332 //
333 // Pave Block from which new edge will be taken
334 const BOPTools_PaveBlock& aPB=aCB.PaveBlock1();
335 nSpTaken=aPB.Edge();
336 //
337 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
338 // Internal edges treatment
339 {
340 Standard_Boolean bInternal1, bInternal2;
341
342 const TopoDS_Edge& anEF2=TopoDS::Edge(aDS.Shape(nEF2));
343 anOrEF2=anEF2.Orientation();
344
345 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF=
346 (iRankF1==1) ? aMEFTool : aMEFObj;
347 const TopTools_ListOfShape& aLF2=aMEF.FindFromKey(anEF2);
348 const TopoDS_Face& aF2=TopoDS::Face(aLF2.First());
349 //
350 bInternal1=(anOrEF1==TopAbs_INTERNAL);
351 bInternal2=(anOrEF2==TopAbs_INTERNAL);
352 //
353 if (bInternal1 || bInternal2) {
354 Standard_Integer nSpNotTaken;
355 //
356 nSpNotTaken=(nSpF1==nSpTaken) ? nSpF2 : nSpF1;
357 //
358 TopoDS_Edge aSS =TopoDS::Edge(aDS.Shape(nSpTaken));
359 TopoDS_Edge aSSx=TopoDS::Edge(aDS.Shape(nSpNotTaken));
360
361 // a. Both parts are interlal edges
362 if (bInternal1 && bInternal2) {
363 BothInternals(aSS, myFace, aF2, iRankF1, myOperation, aWES);
364 }
365
366 // b. The first is internal , the second is not
367 else if (bInternal1 && !bInternal2) {
368 FirstInternal(aSS, myFace, aF2, anEF2, aSSx,
369 iRankF1, myOperation, aMEF, aWES, aContext);
370 }
371
372 // c. The first is no1 internal , the second is internal
373 else if (!bInternal1 && bInternal2) {
374 SecondInternal (aSS, aF1, aF2, anEF1, aSSx,
375 anOrEF1, iRankF1, myOperation, aWES, aContext);
376 }
377 continue;
378 }
379 }
380 //
381 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
382 //
383 Standard_Boolean bIsON2DToKeep, bIsON2DToKeepSimm=Standard_False;
384 {
385 const TopoDS_Edge& anEFx=TopoDS::Edge(aDS.Shape(nEF2));
386 TopoDS_Edge aSpFx=TopoDS::Edge(aDS.Shape(nSpF2));
387 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFx=
388 (iRankF1==1) ? aMEFTool : aMEFObj;
389 //
390 // anEF1
391 TopAbs_State aST1;
392 BOPTools_Tools3D::GetPlanes(aSpFx, anEFx, aMEFx, anEF1, aF1, aST1, aContext);
393 bIsON2DToKeep=
394 BOP_BuilderTools::IsPartOn2dToKeep(aST1, iRankF1, myOperation);
395
396 if (BRep_Tool::IsClosed(anEF1, aF1)) {
397 TopoDS_Edge anEF1Seam;
398 BOPTools_Tools3D::GetSeam (aF1, anEF1, anEF1Seam);
399 //
400 if (!anEF1Seam.IsNull()) {
401 TopAbs_State aSTSeam;
402
403 BOPTools_Tools3D::GetPlanes(aSpFx, anEFx, aMEFx, anEF1Seam, aF1, aSTSeam, aContext);
404 bIsON2DToKeepSimm=
405 BOP_BuilderTools::IsPartOn2dToKeep(aSTSeam, iRankF1, myOperation);
406 }
407 bIsON2DToKeep=bIsON2DToKeep || bIsON2DToKeepSimm;
408 }
409 }
410 //
411
412 if (nSpTaken==nSpF1) {
413 // Common Edge is from nEF1
414 const TopoDS_Shape& aSp1=aDS.Shape(nSpF1);
415 TopoDS_Edge aSS=TopoDS::Edge(aSp1);
416 aSS.Orientation(anOrEF1);
417 //
418 if (bIsON2DToKeep) {
419 aWES.AddStartElement (aSS);
420 }
421 }
422 else /*if (nSpTaken==nSpF2)*/ {
423 // Common Edge is from nEF2
424
425 const TopoDS_Shape& aSp1=aDS.Shape(nSpF1);
426 TopoDS_Edge aSpF1=TopoDS::Edge(aSp1);
427 aSpF1.Orientation(anOrEF1);
428
429 const TopoDS_Shape& aSp2=aDS.Shape(nSpF2);
430 TopoDS_Edge aSpF2=TopoDS::Edge(aSp2);
431
432 Standard_Boolean bToReverse=
433 BOPTools_Tools3D::IsSplitToReverse1 (aSpF1, aSpF2, aContext);
434 if (bToReverse) {
435 aSpF2.Reverse();
436 }
437 //
438 if (BRep_Tool::IsClosed(aSpF1, myFace)) {
439 if (aM.Contains(aSpF2)){
440 continue;
441 }
442 aM.Add(aSpF2);
443 //
444 if (bIsON2DToKeep) {
445 if (!BRep_Tool::IsClosed(aSpF2, myFace)) {
446 // modified by NIZHNY-MKK Mon Feb 17 15:12:22 2003.BEGIN
447 // BOPTools_Tools3D::DoSplitSEAMOnFace (aSpF2, myFace);
448 Standard_Boolean bIsReversed = Standard_False;
449
450 if(!BOPTools_Tools3D::DoSplitSEAMOnFace(aSpF2, aSpF1, myFace, bIsReversed))
451 BOPTools_Tools3D::DoSplitSEAMOnFace (aSpF2, myFace);
452 // modified by NIZHNY-MKK Mon Feb 17 15:12:25 2003.END
453 }
454
455 aWES.AddStartElement (aSpF2);
456 aSpF2.Reverse();
457 aWES.AddStartElement (aSpF2);
458 }
459 continue;
460 }
461 //
462 if (bIsON2DToKeep) {
463 aWES.AddStartElement (aSpF2);
464 }
465 }
466 }// else x
467 }// for (; anItCB.More(); anItCB.Next())
468 }// for (; anExp.More(); anExp.Next())
469}
470//=======================================================================
471// function: AddPartsEFSo
472// purpose:
473//=======================================================================
474 void BOP_ShellSolid::AddPartsEFSo (const Standard_Integer nF1,
475 const Standard_Integer iFF,
476 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFObj,
477 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFTool,
478 TopTools_IndexedMapOfShape& anEMap,
479 BOP_WireEdgeSet& aWES)
480{
481 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
482 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
483 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
484
485 const BOPTools_PaveFiller& aPF=myDSFiller->PaveFiller();
486 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPF;
487 BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
488 //
489 Standard_Integer iRankF1, iRankF2, nF2, nSpEF2, nEF2, nFace;
490 Standard_Boolean bIsKeepTwice, bIsAdjExists, bIsTouchCase;
491 TopExp_Explorer anExp2, anExp1;
492 //
493 BOPTools_SSInterference& aFF=aFFs(iFF);
494 nF2=aFF.OppositeIndex(nF1);
495
496
497 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
498 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
499
500 iRankF1=aDS.Rank(nF1);
501 iRankF2=aDS.Rank(nF2);
502
503 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF=(iRankF2==1) ? aMEFObj : aMEFTool;
504 //
505 // EF2\F1 Processing
506 anExp2.Init (aF2, TopAbs_EDGE);
507 for (; anExp2.More(); anExp2.Next()) {
508 const TopoDS_Edge& aEF2= TopoDS::Edge(anExp2.Current());
509
510 nEF2=aDS.ShapeIndex(aEF2, iRankF2);
511
512 BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nEF2));
513
514 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
515 for (; anItCB.More(); anItCB.Next()) {
516 BOPTools_CommonBlock& aCB=anItCB.Value();
517 nFace=aCB.Face();
518 if (nFace==nF1) {
519 BOPTools_PaveBlock& aPB=aCB.PaveBlock1(nEF2);
520
521 nSpEF2=aPB.Edge();
522 const TopoDS_Shape& aSpEF2=aDS.Shape(nSpEF2);
523
524 if (anEMap.Contains(aSpEF2)) {
525 continue;// next CB
526 }
527 anEMap.Add(aSpEF2);
528
529 TopoDS_Edge aSS=TopoDS::Edge(aSpEF2);
530 //
531 TopoDS_Face aF2Adj;
532 bIsAdjExists=BOPTools_Tools3D::GetAdjacentFace(aF2, aEF2, aMEF, aF2Adj);
533
534 if (bIsAdjExists) {
535 bIsKeepTwice=BOPTools_Tools3D::IsKeepTwice(aF1, aF2, aF2Adj, aSS);
536 if (bIsKeepTwice) {
537 aWES.AddStartElement(aSS);
538 aSS.Reverse();
539 aWES.AddStartElement(aSS);
540 }
541 else {
542 aSS.Orientation(TopAbs_FORWARD);
543 BOP_BuilderTools::OrientSectionEdgeOnF1
544 (myFace, aF2, iRankF1, myOperation, aSS);
545
546 aWES.AddStartElement(aSS);
547 }
548 }
549 else {
550 // No Adjacents
551 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2);
552 if (bIsTouchCase) {
553 aWES.AddStartElement(aSS);
554 aSS.Reverse();
555 aWES.AddStartElement(aSS);
556 }
557 else {
558 aSS.Orientation(TopAbs_FORWARD);
559 BOP_BuilderTools::OrientSectionEdgeOnF1
560 (myFace, aF2, iRankF1, myOperation, aSS);
561
562 aWES.AddStartElement(aSS);
563 }
564 }
565 //continue;
566 }
567
568 } // next CB on nEF2
569 }
570}
571//=======================================================================
572// function: AddINON2DPartsSo
573// purpose:
574//=======================================================================
575 void BOP_ShellSolid::AddINON2DPartsSo(const Standard_Integer iFF,
576 const Standard_Integer nF1,
577 const Standard_Integer nF2,
578 BOP_WireEdgeSet& aWES)
579{
580 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
581 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
582 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
583 //
584 Standard_Integer iSenseFlag, iRankF1;
585 //
586 iRankF1=aDS.Rank(nF1);
587 //
588 BOPTools_SSInterference& aFF=aFFs(iFF);
589 //
590 iSenseFlag=aFF.SenseFlag();
591 //
592 BOP_SDFWESFiller aWESFiller;
593 aWESFiller.SetDSFiller(*myDSFiller);
594 aWESFiller.SetFaces(nF1, nF2);
595 aWESFiller.SetStatesMap(aFF.StatesMap());
596 aWESFiller.SetSenseFlag(iSenseFlag);
597
598 if (iSenseFlag==1) {
599 switch (myOperation) {
600
601 case BOP_FUSE:
602 if (iRankF1==1) {
603 aWESFiller.SetOperation(BOP_CUT);
604 aWESFiller.Do(aWES);
605 aWESFiller.SetOperation(BOP_COMMON);
606 aWESFiller.Do(aWES);
607 }
608 else {
609 aWESFiller.SetOperation(BOP_CUT);
610 aWESFiller.Do(aWES);
611 }
612 break;
613
614 case BOP_COMMON:
615 if (iRankF1==1) {
616 aWESFiller.SetOperation(BOP_COMMON);
617 aWESFiller.Do(aWES);
618 }
619 break;
620
621 case BOP_CUT:
622 if (iRankF1==1) {
623 aWESFiller.SetOperation(BOP_CUT);
624 aWESFiller.Do(aWES);
625 }
626 break;
627
628 case BOP_CUT21:
629 if (iRankF1==2) {
630 aWESFiller.SetOperation(BOP_CUT);
631 aWESFiller.Do(aWES);
632 }
633 break;
634
635 default:
636 break;
637 }
638 }
639
640 else if (iSenseFlag==-1) { // iSenseFlag<0
641 switch (myOperation) {
642
643 case BOP_FUSE:
644 aWESFiller.SetOperation(BOP_CUT);
645 aWESFiller.Do(aWES);
646 break;
647
648 case BOP_COMMON:
649 break;
650
651 case BOP_CUT:
652 if (iRankF1==1) {
653 aWESFiller.SetOperation(BOP_CUT);
654 aWESFiller.Do(aWES);
655 aWESFiller.SetOperation(BOP_COMMON);
656 aWESFiller.Do(aWES);
657 }
658 break;
659
660 case BOP_CUT21:
661 if (iRankF1==2) {
662 aWESFiller.SetOperation(BOP_CUT);
663 aWESFiller.Do(aWES);
664 aWESFiller.SetOperation(BOP_COMMON);
665 aWESFiller.Do(aWES);
666 }
667 default:
668 break;
669 }
670 }
671}
672//=======================================================================
673// function: AddPartsEFSDSo
674// purpose:
675//=======================================================================
676 void BOP_ShellSolid::AddPartsEFSDSo (const Standard_Integer nF1,
677 const Standard_Integer iFF,
678 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFObj,
679 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFTool,
680 BOP_WireEdgeSet& aWES)
681{
682 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
683
684 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
685 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
686
687 const BOPTools_PaveFiller& aPF=myDSFiller->PaveFiller();
688 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPF;
689 //
690 Standard_Integer iRankF1, iRankF2, nF2, bid=0, nSpEF2, nEF2, iSenseFlag;
691 Standard_Boolean bIsAdjExists, bKeptTwice;
692 TopExp_Explorer anExp2, anExp1;
693 //
694 BOPTools_SSInterference& aFF=aFFs(iFF);
695 nF2=aFF.OppositeIndex(nF1);
696 iSenseFlag=aFF.SenseFlag();
697
698 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
699 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
700
701 iRankF1=aDS.Rank(nF1);
702 iRankF2=aDS.Rank(nF2);
703
704 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF=(iRankF2==1) ? aMEFObj : aMEFTool;
705 //
706 BOPTools_ListOfPaveBlock aLPB;
707 BOPTools_ListIteratorOfListOfPaveBlock anIt;
708
709 pPaveFiller->SplitsInFace(bid, nF2, nF1, aLPB);
710 //
711 anIt.Initialize(aLPB);
712 for (; anIt.More(); anIt.Next()) {
713 const BOPTools_PaveBlock& aPBF2=anIt.Value();
714 nEF2=aPBF2.OriginalEdge();
715 nSpEF2=aPBF2.Edge();
716 const TopoDS_Edge& aEF2=TopoDS::Edge(aDS.Shape(nEF2));
717 const TopoDS_Edge& aSpEF2=TopoDS::Edge(aDS.Shape(nSpEF2));
718 //
719 bKeptTwice=aWES.KeptTwice(aSpEF2);
720
721 TopoDS_Face aF2Adj;
722 bIsAdjExists=BOPTools_Tools3D::GetAdjacentFace(aF2, aEF2, aMEF, aF2Adj);
723
724 TopAbs_State aSt;
725
726 if (bIsAdjExists) {
727 BOPTools_Tools3D::GetPointState(aSpEF2, aEF2, aF2Adj, aF1, aSt);
728 TopoDS_Edge aSS=aSpEF2;
729 aSS.Orientation(TopAbs_FORWARD);
730 Standard_Boolean bIsTouchCase;
731
732 if (iSenseFlag==-1) {
733 if (aSt==TopAbs_IN) {
734 if (myOperation!=BOP_FUSE) {
735 if (bKeptTwice) {
736 aWES.RemoveEdgeFromWES(aSpEF2);
737 TopoDS_Edge aSpEF2R=TopoDS::Edge(aSpEF2.Reversed());
738 aWES.RemoveEdgeFromWES(aSpEF2R);
739 }
740
741 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2Adj);
742 if (bIsTouchCase) {
743 //
744 aWES.AddStartElement(aSS);
745 aSS.Reverse();
746 aWES.AddStartElement(aSS);
747 //
748 }
749 else {
750 BOP_BuilderTools::OrientSectionEdgeOnF1
751 (myFace, aF2Adj, iRankF1, myOperation, aSS);
752 aWES.AddStartElement(aSS);
753 }
754 }
755 else {//myOperation==BOP_FUSE && aSt==TopAbs_IN
756 aWES.RemoveEdgeFromWES(aSpEF2);
757 TopoDS_Edge aSpEF2R=TopoDS::Edge(aSpEF2.Reversed());
758 aWES.RemoveEdgeFromWES(aSpEF2R);
759 }
760 }
761
762 }
763 else {// if (iSenseFlag==1)
764 if (aSt==TopAbs_OUT) {
765 if (myOperation!=BOP_FUSE) {
766 if (bKeptTwice) {
767 aWES.RemoveEdgeFromWES(aSpEF2);
768 TopoDS_Edge aSpEF2R=TopoDS::Edge(aSpEF2.Reversed());
769 aWES.RemoveEdgeFromWES(aSpEF2R);
770 }
771 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2Adj);
772 if (bIsTouchCase) {
773 //
774 aWES.AddStartElement(aSS);
775 aSS.Reverse();
776 aWES.AddStartElement(aSS);
777 //
778 }
779 else {
780 BOP_BuilderTools::OrientSectionEdgeOnF1
781 (myFace, aF2Adj, iRankF1, myOperation, aSS);
782 aWES.AddStartElement(aSS);
783 }
784 //
785 if ((myOperation==BOP_CUT && iRankF1==1)||
786 (myOperation==BOP_CUT21 && iRankF1==2)) {
787 aWES.RemoveEdgeFromWES(aSpEF2);
788 TopoDS_Edge aSpEF2R=TopoDS::Edge(aSpEF2.Reversed());
789 aWES.RemoveEdgeFromWES(aSpEF2R);
790 }
791 }
792 else {//myOperation!=BOP_FUSE at aSt==TopAbs_OUT
793 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2Adj);
794 if (!bIsTouchCase) {
795 aWES.RemoveEdgeFromWES(aSpEF2);
796 TopoDS_Edge aSpEF2R=TopoDS::Edge(aSpEF2.Reversed());
797 aWES.RemoveEdgeFromWES(aSpEF2R);
798
799 BOP_BuilderTools::OrientSectionEdgeOnF1
800 (myFace, aF2Adj, iRankF1, myOperation, aSS);
801 aWES.AddStartElement(aSS);
802 }
803 }
804 }
805 }
806 }
807 }
808}
809//=======================================================================
810// function: AddPartsEFNonSDSo
811// purpose:
812//=======================================================================
813 void BOP_ShellSolid::AddPartsEFNonSDSo (const Standard_Integer nF1,
814 const Standard_Integer iFF,
815 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFObj,
816 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFTool,
817 const TColStd_IndexedMapOfInteger& aFFIndicesMap,
818 TopTools_IndexedMapOfShape& anEMap,
819 BOP_WireEdgeSet& aWES)
820{
821 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
822 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
823 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
824
825 const BOPTools_PaveFiller& aPF=myDSFiller->PaveFiller();
826 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPF;
827 BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
828 //
829 Standard_Integer iRankF1, iRankF2, nF2, nSpEF2, nEF2, nFace;
830 Standard_Boolean bIsKeepTwice, bIsAdjExists, bIsTouchCase;
831 TopExp_Explorer anExp2, anExp1;
832 //
833 BOPTools_SSInterference& aFF=aFFs(iFF);
834 nF2=aFF.OppositeIndex(nF1);
835
836 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
837 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
838
839 iRankF1=aDS.Rank(nF1);
840 iRankF2=aDS.Rank(nF2);
841
842 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF=(iRankF2==1) ? aMEFObj : aMEFTool;
843 //
844 // EF2\F1 Processing
845 anExp2.Init (aF2, TopAbs_EDGE);
846 for (; anExp2.More(); anExp2.Next()) {
847 const TopoDS_Edge& aEF2= TopoDS::Edge(anExp2.Current());
848
849 nEF2=aDS.ShapeIndex(aEF2, iRankF2);
850
851 BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nEF2));
852
853 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
854 for (; anItCB.More(); anItCB.Next()) {
855 BOPTools_CommonBlock& aCB=anItCB.Value();
856 nFace=aCB.Face();
857
858 if (nFace==nF1) {
859 BOPTools_PaveBlock& aPB=aCB.PaveBlock1(nEF2);
860
861 nSpEF2=aPB.Edge();
862 const TopoDS_Shape& aSpEF2=aDS.Shape(nSpEF2);
863
864 if (anEMap.Contains(aSpEF2)) {
865 continue;// next CB
866 }
867 anEMap.Add(aSpEF2);
868
869 TopoDS_Edge aSS=TopoDS::Edge(aSpEF2);
870 //
871 TopoDS_Face aF2Adj;
872 bIsAdjExists=BOPTools_Tools3D::GetAdjacentFace(aF2, aEF2, aMEF, aF2Adj);
873
874 if (bIsAdjExists) {
875 //
876
877 Standard_Integer nF2Adj;
878
879 nF2Adj=aDS.ShapeIndex(aF2Adj, iRankF2);
880
881 Standard_Boolean bIsSameDomainFaceWithF1;
882
883 bIsSameDomainFaceWithF1=
884 BOP_BuilderTools::IsSameDomainFaceWithF1(nF1, nF2Adj, aFFIndicesMap, aFFs);
885
886 if (bIsSameDomainFaceWithF1) {
887 continue;
888 }
889 //
890 bIsKeepTwice=BOPTools_Tools3D::IsKeepTwice(aF1, aF2, aF2Adj, aSS);
891 if (bIsKeepTwice) {
892 aWES.AddStartElement(aSS);
893 aSS.Reverse();
894 aWES.AddStartElement(aSS);
895 }
896 else {
897 aSS.Orientation(TopAbs_FORWARD);
898 BOP_BuilderTools::OrientSectionEdgeOnF1
899 (myFace, aF2, iRankF1, myOperation, aSS);
900
901 aWES.AddStartElement(aSS);
902 }
903 }
904 else {
905 // No Adjacents
906 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2);
907 if (bIsTouchCase) {
908 aWES.AddStartElement(aSS);
909 aSS.Reverse();
910 aWES.AddStartElement(aSS);
911 }
912 else {
913 aSS.Orientation(TopAbs_FORWARD);
914 BOP_BuilderTools::OrientSectionEdgeOnF1
915 (myFace, aF2, iRankF1, myOperation, aSS);
916
917 aWES.AddStartElement(aSS);
918 }
919 }
920 } //if (nFace==nF1) {
921 } // next CB on nEF2
922 }
923}
924
925//
926//=======================================================================
927// function: AddPartsEENonSDSo
928// purpose:
929//=======================================================================
930 void BOP_ShellSolid::AddPartsEENonSDSo (const Standard_Integer nF1,
931 const Standard_Integer iFF,
932 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFObj,
933 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFTool,
934 const TColStd_IndexedMapOfInteger& aFFIndicesMap,
935 TopTools_IndexedMapOfShape& anEMap,
936 BOP_WireEdgeSet& aWES)
937{
938 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
939 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
940 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
941
942 const BOPTools_PaveFiller& aPF=myDSFiller->PaveFiller();
943 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPF;
944 BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
945 //
4f189102 946 const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
7fd59977 947 //
948 Standard_Integer nEF1, nF2, nSpF1, nSpF2, nEF2, nSpTaken, iRankF1, nF2x, iRankF2;
949 TopAbs_Orientation anOrEF1, anOrEF2;
950 TopExp_Explorer anExp;
951 TopTools_IndexedMapOfShape aM;
952 TColStd_ListOfInteger aSplitsOnF1;
953 TColStd_ListIteratorOfListOfInteger anIt;
954 TColStd_IndexedMapOfInteger aMSplitsOnF1;
955 //
956 // nF1
957 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
958 iRankF1=aDS.Rank(nF1);
959 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFx=(iRankF1==1) ? aMEFTool : aMEFObj;
960 //
961 // nF2
962 BOPTools_SSInterference& aFF=aFFs(iFF);
963 nF2=aFF.OppositeIndex(nF1);
964
965 iRankF2=aDS.Rank(nF2);
966
967 const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
968 //
969 pPaveFiller->SplitsOnFace(0, nF1, nF2, aSplitsOnF1);
970 anIt.Initialize(aSplitsOnF1);
971 for (; anIt.More(); anIt.Next()) {
972 nSpF1=anIt.Value();
973 aMSplitsOnF1.Add(nSpF1);
974 }
975 //
976 anExp.Init(myFace, TopAbs_EDGE);
977 for (; anExp.More(); anExp.Next()) {
978 const TopoDS_Edge& anEF1=TopoDS::Edge(anExp.Current());
979 anOrEF1=anEF1.Orientation();
980
981 nEF1=aDS.ShapeIndex(anEF1, iRankF1);
982
983 BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nEF1));
984
985 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
986 for (; anItCB.More(); anItCB.Next()) {
987 BOPTools_CommonBlock& aCB=anItCB.Value();
988
989 BOPTools_PaveBlock& aPBEF1=aCB.PaveBlock1(nEF1);
990 BOPTools_PaveBlock& aPBEF2=aCB.PaveBlock2(nEF1);
991
992 nF2x=aCB.Face();
993 if (nF2x) {
994 continue;
995 }
996 // Splits that are ON other Edge from other Face
997 nSpF1=aPBEF1.Edge();
998 //
999 if (!aMSplitsOnF1.Contains(nSpF1)) {
1000 continue;// next CB
1001 }
1002 //
1003 nSpF2=aPBEF2.Edge();
1004 nEF2=aPBEF2.OriginalEdge();
1005 //
1006 const TopoDS_Edge& aEF2=TopoDS::Edge(aDS.Shape(nEF2));
1007 TopoDS_Face aF2Adj;
1008
1009 Standard_Boolean bIsAdjExists;
1010 bIsAdjExists=BOPTools_Tools3D::GetAdjacentFace(aF2, aEF2, aMEFx, aF2Adj);
1011
1012 if (bIsAdjExists) {
1013 Standard_Boolean bIsSameDomainFaceWithF1;
1014 Standard_Integer nF2Adj;
1015
1016 nF2Adj=aDS.ShapeIndex(aF2Adj, iRankF2);
1017
1018 bIsSameDomainFaceWithF1=
1019 BOP_BuilderTools::IsSameDomainFaceWithF1(nF1, nF2Adj, aFFIndicesMap, aFFs);
1020
1021 if (bIsSameDomainFaceWithF1) {
1022 continue;
1023 }
1024 }
1025 //
1026 const TopoDS_Shape& aSp1=aDS.Shape(nSpF1);
1027 const TopoDS_Shape& aSp2=aDS.Shape(nSpF2);
1028
1029 //
1030 if (anEMap.Contains(aSp1)) {
1031 continue;// next CB
1032 }
1033 anEMap.Add(aSp1);
1034 //
1035 if (anEMap.Contains(aSp2)) {
1036 continue;// next CB
1037 }
1038 anEMap.Add(aSp2);
1039 //
1040
1041 // Pave Block from which new edge will be taken
1042 const BOPTools_PaveBlock& aPB=aCB.PaveBlock1();
1043 nSpTaken=aPB.Edge();
1044 //
1045 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
1046 // Internal edges treatment
1047 {
1048 Standard_Boolean bInternal1, bInternal2;
1049
1050 const TopoDS_Edge& anEF2=TopoDS::Edge(aDS.Shape(nEF2));
1051 anOrEF2=anEF2.Orientation();
1052
1053 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF=
1054 (iRankF1==1) ? aMEFTool : aMEFObj;
1055
1056 bInternal1=(anOrEF1==TopAbs_INTERNAL);
1057 bInternal2=(anOrEF2==TopAbs_INTERNAL);
1058
1059 if (bInternal1 || bInternal2) {
1060 Standard_Integer nSpNotTaken;
1061 //
1062 nSpNotTaken=(nSpF1==nSpTaken) ? nSpF2 : nSpF1;
1063
1064 TopoDS_Edge aSS =TopoDS::Edge(aDS.Shape(nSpTaken));
1065 TopoDS_Edge aSSx=TopoDS::Edge(aDS.Shape(nSpNotTaken));
1066 // a. Both parts are interlal edges
1067 if (bInternal1 && bInternal2) {
1068 BothInternals(aSS, myFace, aF2, iRankF1, myOperation, aWES);
1069 }
1070 // b. The first is internal, the second is not
1071 else if (bInternal1 && !bInternal2) {
1072 FirstInternal(aSS, myFace, aF2, anEF2, aSSx,
1073 iRankF1, myOperation, aMEF, aWES, aContext);
1074 }
1075
1076 // c. The first is no1 internal , the second is internal
1077 else if (!bInternal1 && bInternal2) {
1078 SecondInternal (aSS, aF1, aF2, anEF1, aSSx,
1079 anOrEF1, iRankF1, myOperation, aWES, aContext);
1080 }
1081 continue;
1082 }
1083 }
1084 //
1085 //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
1086 //
1087 Standard_Boolean bIsON2DToKeep, bIsON2DToKeepSimm=Standard_False;
1088 {
1089 const TopoDS_Edge& anEFx=TopoDS::Edge(aDS.Shape(nEF2));
1090 TopoDS_Edge aSpFx=TopoDS::Edge(aDS.Shape(nSpF2));
1091 //
1092 // anEF1
1093 TopAbs_State aST1;
1094 BOPTools_Tools3D::GetPlanes(aSpFx, anEFx, aMEFx, anEF1, aF1, aST1, aContext);
1095 bIsON2DToKeep=
1096 BOP_BuilderTools::IsPartOn2dToKeep(aST1, iRankF1, myOperation);
1097
1098 if (BRep_Tool::IsClosed(anEF1, aF1)) {
1099 TopoDS_Edge anEF1Seam;
1100 BOPTools_Tools3D::GetSeam (aF1, anEF1, anEF1Seam);
1101 //
1102 if (!anEF1Seam.IsNull()) {
1103 TopAbs_State aSTSeam;
1104
1105 BOPTools_Tools3D::GetPlanes(aSpFx, anEFx, aMEFx, anEF1Seam, aF1, aSTSeam, aContext);
1106 bIsON2DToKeepSimm=
1107 BOP_BuilderTools::IsPartOn2dToKeep(aSTSeam, iRankF1, myOperation);
1108 }
1109 bIsON2DToKeep=bIsON2DToKeep || bIsON2DToKeepSimm;
1110 }
1111 }
1112 //
1113
1114 if (nSpTaken==nSpF1) {
1115 // Common Edge is from nEF1
1116
1117 TopoDS_Edge aSS=TopoDS::Edge(aSp1);
1118 aSS.Orientation(anOrEF1);
1119 //
1120 if (bIsON2DToKeep) {
1121 aWES.AddStartElement (aSS);
1122 }
1123 }
1124 else /*if (nSpTaken==nSpF2)*/ {
1125 // Common Edge is from nEF2
1126 TopoDS_Edge aSpF1=TopoDS::Edge(aSp1);
1127 aSpF1.Orientation(anOrEF1);
1128
1129 TopoDS_Edge aSpF2=TopoDS::Edge(aSp2);
1130
1131 Standard_Boolean bToReverse= BOPTools_Tools3D::IsSplitToReverse1 (aSpF1, aSpF2, aContext);
1132 if (bToReverse) {
1133 aSpF2.Reverse();
1134 }
1135 //
1136 if (BRep_Tool::IsClosed(aSpF1, myFace)) {
1137 if (aM.Contains(aSpF2)){
1138 continue;
1139 }
1140 aM.Add(aSpF2);
1141 //
1142 if (bIsON2DToKeep) {
1143 if (!BRep_Tool::IsClosed(aSpF2, myFace)) {
1144 BOPTools_Tools3D::DoSplitSEAMOnFace (aSpF2, myFace);
1145 }
1146
1147 aWES.AddStartElement (aSpF2);
1148 aSpF2.Reverse();
1149 aWES.AddStartElement (aSpF2);
1150 }
1151 continue;
1152 }
1153 //
1154 if (bIsON2DToKeep) {
1155 aWES.AddStartElement (aSpF2);
1156 }
1157
1158 }// else /*if (nSpTaken==nSpF2)*/ {
1159 }// for (; anItCB.More(); anItCB.Next())
1160 }// for (; anExp.More(); anExp.Next())
1161}
1162
1163//=======================================================================
1164// function: AddPartsEF
1165// purpose:
1166//=======================================================================
1167void AddPartsEF (const TopoDS_Edge& aSSin,
1168 const TopoDS_Edge& aEF2,
1169 const TopoDS_Face& aF2,
1170 const TopoDS_Face& myFace,
1171 const Standard_Integer iRankF1,
1172 const BOP_Operation myOperation,
1173 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF,
1174 BOP_WireEdgeSet& aWES)
1175{
1176 Standard_Boolean bIsKeepTwice, bIsAdjExists, bIsTouchCase;
1177 TopoDS_Face aF2Adj;
1178 TopoDS_Edge aSS=aSSin;
1179 //
1180 bIsAdjExists=BOPTools_Tools3D::GetAdjacentFace(aF2, aEF2, aMEF, aF2Adj);
1181 //
1182 if (bIsAdjExists) {
1183 bIsKeepTwice=BOPTools_Tools3D::IsKeepTwice(myFace, aF2, aF2Adj, aSS);
1184 if (bIsKeepTwice) {
1185 aWES.AddStartElement(aSS);
1186 aSS.Reverse();
1187 aWES.AddStartElement(aSS);
1188 }
1189 else {
1190 aSS.Orientation(TopAbs_FORWARD);
1191 BOP_BuilderTools::OrientSectionEdgeOnF1 (myFace, aF2, iRankF1, myOperation, aSS);
1192 aWES.AddStartElement(aSS);
1193 }
1194 }
1195 else {
1196 // No Adjacents
1197 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2);
1198 //
1199 if (bIsTouchCase) {
1200 aWES.AddStartElement(aSS);
1201 aSS.Reverse();
1202 aWES.AddStartElement(aSS);
1203 }
1204 else {
1205 aSS.Orientation(TopAbs_FORWARD);
1206 BOP_BuilderTools::OrientSectionEdgeOnF1 (myFace, aF2, iRankF1, myOperation, aSS);
1207 aWES.AddStartElement(aSS);
1208 }
1209 }
1210}
1211
1212//=======================================================================
1213// function: AddPartEF1INF2
1214// purpose:
1215//=======================================================================
1216void AddPartEF1INF2 (TopoDS_Edge& aSS,
1217 const TopoDS_Face& myFace,
1218 const TopoDS_Face& aF2,
1219 const Standard_Integer iRankF1,
1220 const BOP_Operation myOperation,
1221 BOP_WireEdgeSet& aWES)
1222{
1223 Standard_Boolean bIsTouchCase;
1224
1225 aSS.Orientation(TopAbs_FORWARD);
1226
1227 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2);
1228
1229 if (bIsTouchCase) {
1230 aWES.AddStartElement (aSS);
1231 aSS.Reverse();
1232 aWES.AddStartElement (aSS);
1233 }
1234 else {
1235 BOP_BuilderTools::OrientSectionEdgeOnF1(myFace, aF2, iRankF1, myOperation, aSS);
1236 aWES.AddStartElement (aSS);
1237 }
1238}
1239//=======================================================================
1240// function: BothInternals
1241// purpose:
1242//=======================================================================
1243void BothInternals (TopoDS_Edge& aSS,
1244 const TopoDS_Face& myFace,
1245 const TopoDS_Face& aF2,
1246 const Standard_Integer iRankF1,
1247 const BOP_Operation myOperation,
1248 BOP_WireEdgeSet& aWES)
1249{
1250 Standard_Boolean bIsTouchCase;
1251 //
1252 aSS.Orientation(TopAbs_FORWARD);
1253 //
1254 bIsTouchCase=BOPTools_Tools3D::IsTouchCase(aSS, myFace, aF2);
1255 //
1256 if (bIsTouchCase) {
1257 aWES.AddStartElement (aSS);
1258 aSS.Reverse();
1259 aWES.AddStartElement (aSS);
1260 }
1261 else {
1262 BOP_BuilderTools::OrientSectionEdgeOnF1(myFace, aF2, iRankF1, myOperation, aSS);
1263 aWES.AddStartElement (aSS);
1264 }
1265}
1266//=======================================================================
1267// function: FirstInternal
1268// purpose:
1269//=======================================================================
1270void FirstInternal(TopoDS_Edge& aSS,
1271 const TopoDS_Face& myFace,
1272 const TopoDS_Face& aF2,
1273 const TopoDS_Edge& anEF2,
1274 TopoDS_Edge& aSSx,
1275 const Standard_Integer iRankF1,
1276 const BOP_Operation myOperation,
1277 const TopTools_IndexedDataMapOfShapeListOfShape& aMEF,
1278 BOP_WireEdgeSet& aWES,
4f189102 1279 const Handle(IntTools_Context)& aContext)
7fd59977 1280{
1281 Standard_Boolean bToReverse;
1282 TopAbs_Orientation anOrEF2;
1283 TopoDS_Edge aEF2;
1284
1285 BOPTools_Tools3D::OrientEdgeOnFace (anEF2, aF2, aEF2);
1286 anOrEF2=aEF2.Orientation();
1287
1288 if (aSS.Orientation()==TopAbs_INTERNAL) {
1289 aSS.Orientation(TopAbs_FORWARD);
1290 aSSx.Orientation(anOrEF2);
1291 bToReverse=BOPTools_Tools3D::IsSplitToReverse1 (aSSx, aSS, aContext);
1292 if(bToReverse){
1293 aSS.Reverse();
1294 }
1295 }
1296 else {
1297 aSS.Orientation(anOrEF2);
1298 }
1299
1300 AddPartsEF(aSS, aEF2, aF2, myFace, iRankF1, myOperation, aMEF, aWES);
1301}
1302
1303//=======================================================================
1304// function: SecondInternal
1305// purpose:
1306//=======================================================================
1307void SecondInternal(TopoDS_Edge& aSS,
1308 const TopoDS_Face& aF1,
1309 const TopoDS_Face& aF2,
1310 const TopoDS_Edge& anEF1,
1311 TopoDS_Edge& aSSx,
1312 const TopAbs_Orientation anOrEF1,
1313 const Standard_Integer iRankF1,
1314 const BOP_Operation myOperation,
1315 BOP_WireEdgeSet& aWES,
4f189102 1316 const Handle(IntTools_Context)& aContext)
7fd59977 1317{
1318 Standard_Boolean bToReverse, bIsToKeep;
1319 if (aSS.Orientation()==TopAbs_INTERNAL) {
1320 aSS.Orientation(TopAbs_FORWARD);
1321 aSSx.Orientation(anOrEF1);
1322 bToReverse=BOPTools_Tools3D::IsSplitToReverse1 (aSSx, aSS, aContext);
1323 if(bToReverse){
1324 aSS.Reverse();
1325 }
1326 }
1327 else {
1328 aSS.Orientation(anOrEF1);
1329 }
1330 //
1331 TopAbs_State aState1=
1332 BOPTools_Tools3D::GetStatePartIN2D(aSS, anEF1, aF1, aF2, aContext);
1333 //
1334 bIsToKeep=
1335 BOP_BuilderTools::IsPartIN2DToKeep(aState1, iRankF1, myOperation);
1336 //
1337 if (bIsToKeep) {
1338 aWES.AddStartElement (aSS);
1339 }
1340}
1341
1342//=======================================================================
1343// function: AddPartsEESDSo
1344// purpose:
1345//=======================================================================
1346 void BOP_ShellSolid::AddPartsEESDSo (const Standard_Integer nF1,
1347 const Standard_Integer iFF,
1348 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFObj,
1349 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFTool,
1350 BOP_WireEdgeSet& aWES)
1351{
1352 if (myOperation==BOP_FUSE) {
1353 return;
1354 }
1355 //
1356 const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
1357 BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
1358 BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
1359
1360 const BOPTools_PaveFiller& aPF=myDSFiller->PaveFiller();
1361 BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*)&aPF;
1362 BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
1363 //
4f189102 1364 const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
7fd59977 1365 //
1366 Standard_Integer nEF1, nF2, nSpF1, nSpF2, nEF2, nSpTaken, iRankF1, nF2x, iRankF2, iSenseFlag;
1367 TopAbs_Orientation anOrEF1;
1368 TopExp_Explorer anExp;
1369 TopTools_IndexedMapOfShape aM;
1370 TColStd_ListOfInteger aSplitsOnF1;
1371 TColStd_ListIteratorOfListOfInteger anIt;
1372 TColStd_IndexedMapOfInteger aMSplitsOnF1;
1373 //
1374 // nF1
1375 const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
1376 iRankF1=aDS.Rank(nF1);
1377 const TopTools_IndexedDataMapOfShapeListOfShape& aMEFx=(iRankF1==1) ? aMEFTool : aMEFObj;
1378 //
1379 // nF2
1380 BOPTools_SSInterference& aFF=aFFs(iFF);
1381 nF2=aFF.OppositeIndex(nF1);
1382 iSenseFlag=aFF.SenseFlag();
1383 //
1384 if (iSenseFlag==1) {
1385 return ;
1386 }
1387 //
1388 iRankF2=aDS.Rank(nF2);
1389 //
1390 pPaveFiller->SplitsOnFace(0, nF1, nF2, aSplitsOnF1);
1391 //
1392 anIt.Initialize(aSplitsOnF1);
1393 for (; anIt.More(); anIt.Next()) {
1394 nSpF1=anIt.Value();
1395 aMSplitsOnF1.Add(nSpF1);
1396 }
1397 //
1398 anExp.Init(myFace, TopAbs_EDGE);
1399 for (; anExp.More(); anExp.Next()) {
1400 const TopoDS_Edge& anEF1=TopoDS::Edge(anExp.Current());
1401 anOrEF1=anEF1.Orientation();
1402
1403 nEF1=aDS.ShapeIndex(anEF1, iRankF1);
1404
1405 BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nEF1));
1406
1407 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
1408 for (; anItCB.More(); anItCB.Next()) {
1409 BOPTools_CommonBlock& aCB=anItCB.Value();
1410
1411 BOPTools_PaveBlock& aPBEF1=aCB.PaveBlock1(nEF1);
1412 BOPTools_PaveBlock& aPBEF2=aCB.PaveBlock2(nEF1);
1413
1414 nF2x=aCB.Face();
1415 if (nF2x) {
1416 continue;
1417 }
1418 // Splits that are ON other Edge from other Face
1419 nSpF1=aPBEF1.Edge();
1420 //
1421 if (!aMSplitsOnF1.Contains(nSpF1)) {
1422 continue;// next CB
1423 }
1424 //
1425 nSpF2=aPBEF2.Edge();
1426 nEF2=aPBEF2.OriginalEdge();
1427 //
1428 const TopoDS_Shape& aSp1=aDS.Shape(nSpF1);
1429 const TopoDS_Shape& aSp2=aDS.Shape(nSpF2);
1430 // Pave Block from which new edge will be taken
1431 const BOPTools_PaveBlock& aPB=aCB.PaveBlock1();
1432 nSpTaken=aPB.Edge();
1433 //
1434 Standard_Boolean bIsON2DToKeep;
1435 {
1436 const TopoDS_Edge& anEFx=TopoDS::Edge(aDS.Shape(nEF2));
1437 TopoDS_Edge aSpFx=TopoDS::Edge(aDS.Shape(nSpF2));
1438 //
1439 // anEF1
1440 TopAbs_State aST1;
1441 BOPTools_Tools3D::GetPlanes(aSpFx, anEFx, aMEFx, anEF1, aF1, aST1, aContext);
1442
1443 bIsON2DToKeep=BOP_BuilderTools::IsPartOn2dToKeep(aST1, iRankF1, myOperation);
1444 if (bIsON2DToKeep) {
1445 bIsON2DToKeep=!bIsON2DToKeep;
1446 if (aST1==TopAbs_IN) {
1447 if (
1448 (iRankF1==2 && (myOperation==BOP_COMMON || myOperation==BOP_CUT)) ||
1449 (iRankF1==1 && (myOperation==BOP_COMMON || myOperation==BOP_CUT21))
1450 ){
1451 bIsON2DToKeep=!bIsON2DToKeep;
1452 }
1453 }
1454 }
1455 }
1456 if (bIsON2DToKeep) {
1457 //
1458 if (nSpTaken==nSpF1) {
1459 // Common Edge is from nEF1
1460 TopoDS_Edge aSS=TopoDS::Edge(aSp1);
1461 aSS.Orientation(anOrEF1);
1462 //
1463 aWES.AddStartElement (aSS);
1464 }
1465 else /*if (nSpTaken==nSpF2)*/ {
1466 // Common Edge is from nEF2
1467 TopoDS_Edge aSpF1=TopoDS::Edge(aSp1);
1468 aSpF1.Orientation(anOrEF1);
1469
1470 TopoDS_Edge aSpF2=TopoDS::Edge(aSp2);
1471
1472 Standard_Boolean bToReverse= BOPTools_Tools3D::IsSplitToReverse1 (aSpF1, aSpF2, aContext);
1473 if (bToReverse) {
1474 aSpF2.Reverse();
1475 }
1476 //
1477 if (BRep_Tool::IsClosed(aSpF1, myFace)) {
1478 if (aM.Contains(aSpF2)){
1479 continue;
1480 }
1481 aM.Add(aSpF2);
1482 //
1483
1484 if (!BRep_Tool::IsClosed(aSpF2, myFace)) {
1485 BOPTools_Tools3D::DoSplitSEAMOnFace (aSpF2, myFace);
1486 }
1487
1488 aWES.AddStartElement (aSpF2);
1489 aSpF2.Reverse();
1490 aWES.AddStartElement (aSpF2);
1491
1492 continue;
1493 }
1494 //
1495 aWES.AddStartElement (aSpF2);
1496 }// else /*if (nSpTaken==nSpF2)*/ {
1497 }// if (bIsON2DToKeep)
1498 }// for (; anItCB.More(); anItCB.Next())
1499 }// for (; anExp.More(); anExp.Next())
1500}
Open CASCADE Technology repository