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 / BOPTools / BOPTools_SolidStateFiller.cxx
CommitLineData
b311480e 1// Created on: 2001-05-28
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
22#include <BOPTools_SolidStateFiller.ixx>
23
24#include <TopoDS.hxx>
25#include <TopoDS_Shape.hxx>
26#include <TopoDS_Compound.hxx>
27#include <TopoDS_Edge.hxx>
28#include <TopoDS_Vertex.hxx>
29
30#include <TopExp.hxx>
31#include <TopExp_Explorer.hxx>
32
33#include <TopTools_IndexedMapOfShape.hxx>
34#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
35#include <TopTools_ListIteratorOfListOfShape.hxx>
36#include <TopTools_ListOfShape.hxx>
37
38#include <TopAbs_ShapeEnum.hxx>
39#include <TopAbs_State.hxx>
40
41#include <Geom_Curve.hxx>
42
43#include <BRep_Tool.hxx>
44#include <BRep_Builder.hxx>
45#include <BRepClass3d_SolidClassifier.hxx>
46
47#include <gp_Pnt.hxx>
48
49#include <IntTools_Tools.hxx>
50
51#include <BooleanOperations_StateOfShape.hxx>
52#include <BooleanOperations_ShapesDataStructure.hxx>
53#include <BooleanOperations_IndexedDataMapOfShapeInteger.hxx>
54
55#include <BOPTools_ListOfShapeEnum.hxx>
56#include <BOPTools_ListIteratorOfListOfShapeEnum.hxx>
57#include <BOPTools_IndexedDataMapOfShapeWithState.hxx>
58
59#include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
60#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
61#include <BOPTools_CommonBlock.hxx>
62#include <BOPTools_SplitShapesPool.hxx>
63#include <BOPTools_ListOfPaveBlock.hxx>
64#include <BOPTools_InterferencePool.hxx>
65#include <BOPTools_CArray1OfSSInterference.hxx>
66#include <BOPTools_CArray1OfESInterference.hxx>
67#include <BOPTools_InterferencePool.hxx>
68#include <BOPTools_CArray1OfESInterference.hxx>
69#include <BOPTools_ESInterference.hxx>
70#include <BOPTools_CArray1OfSSInterference.hxx>
71#include <BOPTools_SSInterference.hxx>
72#include <BOPTools_SequenceOfCurves.hxx>
73#include <BOPTools_Curve.hxx>
74#include <BOPTools_PaveBlock.hxx>
75#include <BOPTools_CommonBlockPool.hxx>
76#include <BOPTools_ListOfCommonBlock.hxx>
77#include <BOPTools_StateFiller.hxx>
78
79static
80 void IntersectionStates(const TopoDS_Shape& aE,
81 const TopTools_IndexedDataMapOfShapeListOfShape& aM,
82 TopTools_IndexedMapOfShape& anIntersectedShapes);
83static
84 void PropagateState(const TopoDS_Shape& aS,
85 const BooleanOperations_StateOfShape aState,
86 BooleanOperations_ShapesDataStructure* pDS,
87 const Standard_Integer iRank,
88 BOPTools_IndexedDataMapOfShapeWithState& aSWS,
89 TopTools_IndexedMapOfShape& aProcessedShapes);
90static
91 void PropagateState(const TopoDS_Shape& aF,
92 const BooleanOperations_StateOfShape aState,
93 BooleanOperations_ShapesDataStructure* pDS,
94 const Standard_Integer iRank,
95 BOPTools_IndexedDataMapOfShapeWithState& aSWS,
96 const TopTools_IndexedDataMapOfShapeListOfShape& aEFMap,
97 TopTools_IndexedMapOfShape& aProcessedShapes);
98static
99 Standard_Boolean HasConnexity(const TopoDS_Shape& aS,
100 const BOPTools_IndexedDataMapOfShapeWithState& aSWS,
101 const TopTools_IndexedDataMapOfShapeListOfShape& aMVE,
102 BooleanOperations_StateOfShape& aState);
103
104// Peter KURNEV
105// p-kurnev@opencascade.com
106
107//=======================================================================
108// function: BOPTools_SolidStateFiller::BOPTools_SolidStateFiller
109// purpose:
110//=======================================================================
111 BOPTools_SolidStateFiller::BOPTools_SolidStateFiller(const BOPTools_PaveFiller& aFiller)
112:
113 BOPTools_StateFiller(aFiller)
114{
115}
116
117//=======================================================================
118// function: Do
119// purpose:
120//=======================================================================
121 void BOPTools_SolidStateFiller::Do()
122{
123 const TopoDS_Shape& anObj=myDS->Object();
124 const TopoDS_Shape& aTool=myDS->Tool();
125 //
126 myIsDone=Standard_True;
127 //
128 TopAbs_ShapeEnum aT1, aT2;
129 aT1=anObj.ShapeType();
130 aT2=aTool.ShapeType();
131
132 if (aT1==TopAbs_FACE) {
133 aT1=TopAbs_SHELL;
134 }
135 if (aT2==TopAbs_FACE) {
136 aT2=TopAbs_SHELL;
137 }
138
139 if (aT1==TopAbs_SOLID && aT2==TopAbs_SOLID) {
140 DoNonSections(1);
141 DoNonSections(2);
142 DoSections();
143 }
144
145 else if (aT1==TopAbs_SHELL && aT2==TopAbs_SHELL) {
146 DoShellNonSections(1);
147 DoShellNonSections(2);
148 DoSections();
149 }
150
151 else if (aT1==TopAbs_SHELL && aT2==TopAbs_SOLID) {
152 DoNonSections(1);
153 DoShellNonSections(2);
154 DoSections();
155 }
156 else if (aT1==TopAbs_SOLID && aT2==TopAbs_SHELL) {
157 DoShellNonSections(1);
158 DoNonSections(2);
159 DoSections();
160 }
161 else {
162 myIsDone=!myIsDone;
163 }
164}
165
166//=======================================================================
167// function: DoNonSections
168// purpose:
169//=======================================================================
170 void BOPTools_SolidStateFiller::DoNonSections(const Standard_Integer iRankObj)
171{
172 //
173 // 0. Restore data and preparing
174
175 const TopoDS_Shape& anObj=(iRankObj==1) ? myDS->Object() : myDS->Tool();
176 const TopoDS_Shape& aTool=(iRankObj==1) ? myDS->Tool() : myDS->Object();
177
178 const BooleanOperations_IndexedDataMapOfShapeInteger& aDSMap=myDS->ShapeIndexMap(iRankObj);
179 const BOPTools_SplitShapesPool& aSplitShapesPool=myFiller->SplitShapesPool();
180 const BOPTools_CommonBlockPool& aCommonBlockPool=myFiller->CommonBlockPool();
181
182 Standard_Integer i, nE, nF, aNbPaveBlocks, aNb;
183 BooleanOperations_StateOfShape aState;
184 TopTools_IndexedMapOfShape aEM, anIntersectedShapes, aNonIntersectedShapes;
185 TopTools_IndexedDataMapOfShapeListOfShape aM, aMVE, aMEF;
186 //
187 // aM Map
188 TopExp::MapShapesAndAncestors (anObj, TopAbs_EDGE , TopAbs_WIRE , aM);
189 TopExp::MapShapesAndAncestors (anObj, TopAbs_WIRE , TopAbs_FACE , aM);
190 TopExp::MapShapesAndAncestors (anObj, TopAbs_FACE , TopAbs_SHELL, aM);
191 TopExp::MapShapesAndAncestors (anObj, TopAbs_SHELL, TopAbs_SOLID, aM);
192 //
193 // VE Map
194 TopExp::MapShapesAndAncestors (anObj, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
195 //
196 // 1. anIntersectedShapes
197 //
198 // 1.1. Check EF FF interferences with nF
199 TopExp::MapShapes(anObj, TopAbs_FACE, aEM);
200 aNb=aEM.Extent();
201 for (i=1; i<=aNb; i++) {
202 const TopoDS_Shape& aF=aEM(i);
203 nF=aDSMap.FindFromKey(aF);
204 Standard_Boolean bExists=IsFaceIntersected(nF);
205 if (bExists) {
206 anIntersectedShapes.Add(aF);
207 IntersectionStates (aF, aM, anIntersectedShapes);
208 }
209 }
210 //
211 aEM.Clear();
212 TopExp::MapShapes(anObj, TopAbs_EDGE, aEM);
213 //
214 // 1.2. Edges that have Split parts
215 aNb=aEM.Extent();
216 for (i=1; i<=aNb; i++) {
217 const TopoDS_Shape& aE=aEM(i);
218 nE=aDSMap.FindFromKey(aE);
219 const BOPTools_ListOfPaveBlock& aSplitEdges=aSplitShapesPool(myDS->RefEdge(nE));
220 aNbPaveBlocks=aSplitEdges.Extent();
221 //
222 if (!aNbPaveBlocks) {
223 continue;
224 }
225 //
226 if (aNbPaveBlocks==1) {
227 const BOPTools_ListOfCommonBlock& aCBlocks=aCommonBlockPool(myDS->RefEdge(nE));
228 if (!aCBlocks.Extent()) {
229 const BOPTools_PaveBlock& aPB=aSplitEdges.First();
230 Standard_Integer nEB=aPB.Edge();
231 if (nEB==aPB.OriginalEdge()) {
232 Standard_Boolean bHasInterference=//;
233 Standard_False; //LNX
234 Standard_Integer j, aNbSuc, nV;
235
236 aNbSuc=myDS->NumberOfSuccessors(nEB);
237 for (j=1; j<=aNbSuc; j++) {
238 nV=myDS->GetSuccessor(nE, j);
239 bHasInterference=myIntrPool->HasInterference(nV);
240 if (bHasInterference) {
241 break;
242 }
243 }
244 if (!bHasInterference) {
245 continue;
246 }
247 }
248 }
249 }
250 //
251 anIntersectedShapes.Add(aE);
252 IntersectionStates (aE, aM, anIntersectedShapes);
253 } // for (i=1; i<=aNb; i++)
254
255 //
256 // 1.3. Write Intersected state for anIntersectedShapes to the DS
257 aNb=anIntersectedShapes.Extent();
258 for (i=1; i<=aNb; i++) {
259 const TopoDS_Shape& aS=anIntersectedShapes(i);
260 nE=aDSMap.FindFromKey(aS);
261 myDS->SetState(nE, BooleanOperations_INTERSECTED);
262 }
263 //
264 // 2. aNonIntersectedShapes
265 //
266 aNb=aM.Extent();
267 for (i=1; i<=aNb; i++) {
268 const TopoDS_Shape& aS=aM.FindKey(i);
269 if (!anIntersectedShapes.Contains(aS)) {
270 aNonIntersectedShapes.Add(aS);
271 }
272 }
273 //
274 // 2.1. Processing of Non-intersected shapes
275 BRep_Builder BB;
276 TopoDS_Compound aCompound;
277 BB.MakeCompound(aCompound);
278 aNb=aNonIntersectedShapes.Extent();
279 for (i=1; i<=aNb; i++) {
280 const TopoDS_Shape& aS=aNonIntersectedShapes(i);
281 BB.Add(aCompound, aS);
282 }
283
284 TopExp::MapShapesAndAncestors (aCompound, TopAbs_EDGE, TopAbs_FACE, aMEF);
285 //
286 TopTools_IndexedMapOfShape aProcessedShapes;
287 BOPTools_IndexedDataMapOfShapeWithState aSWS;
288 Standard_Boolean bHasConnexity;
289 //
290 BOPTools_ListOfShapeEnum aEnumList;
291 aEnumList.Append(TopAbs_SHELL);
292 aEnumList.Append(TopAbs_FACE);
293 aEnumList.Append(TopAbs_WIRE);
294 aEnumList.Append(TopAbs_EDGE);
295
296 BOPTools_ListIteratorOfListOfShapeEnum anIt(aEnumList);
297 for (; anIt.More(); anIt.Next()) {
298 TopAbs_ShapeEnum anEnum=anIt.Value();
299 aEM.Clear();
300 TopExp::MapShapes(aCompound, anEnum, aEM);
301 aNb=aEM.Extent();
302 for (i=1; i<=aNb; i++) {
303 const TopoDS_Shape& aS=aEM(i);
304 //
305 // DEBUG
306 //nE=aDSMap.FindFromKey(aS);
307 //
308 if (!aProcessedShapes.Contains(aS)) {
309 bHasConnexity=HasConnexity(aS, aSWS, aMVE, aState);
310 if (!bHasConnexity) {
311 aState=BOPTools_StateFiller::ClassifyShapeByRef (aS, aTool);
312 }
313 aSWS.Add(aS, aState);
314 aProcessedShapes.Add(aS);
315 if (anEnum==TopAbs_FACE) {
316 PropagateState(aS, aState, myDS, iRankObj, aSWS, aMEF, aProcessedShapes);
317 }
318 else {
319 PropagateState(aS, aState, myDS, iRankObj, aSWS, aProcessedShapes);
320 }
321 }
322 }
323 }
324 //
325 // 2.2. Write Stats for Non-intersected Shapes to the DS
326 aNb=aSWS.Extent();
327 for (i=1; i<=aNb; i++) {
328 const TopoDS_Shape& aS=aSWS.FindKey(i);
329 aState=aSWS.FindFromIndex(i);
330 nE=aDSMap.FindFromKey(aS);
331 myDS->SetState(nE, aState);
332 }
333
334 //---------------------------------------------------
335 //
336 // 3. Intersected Edges' Processing
337 //
338 //---------------------------------------------------
339 Standard_Integer nSp, aNBVertices, nV1, nV2;
340 BooleanOperations_StateOfShape aStV1, aStV2;
341
342 aNb=anIntersectedShapes.Extent();
343 for (i=1; i<=aNb; i++) {
344 const TopoDS_Shape& aS=anIntersectedShapes(i);
345 if (aS.ShapeType()==TopAbs_EDGE) {
346 nE=aDSMap.FindFromKey(aS);
347 //
348 // 3.1. On Parts Processing
349 const BOPTools_ListOfCommonBlock& aLCB=aCommonBlockPool(myDS->RefEdge(nE));
350 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
351 for (; anItCB.More(); anItCB.Next()) {
352 const BOPTools_CommonBlock& aCB=anItCB.Value();
353 BOPTools_CommonBlock* pCB=(BOPTools_CommonBlock*) &aCB;
354 BOPTools_PaveBlock& aPB=pCB->PaveBlock1(nE);
355 nSp=aPB.Edge();
356 myDS->SetState(nSp, BooleanOperations_ON);
357 }
358 //
359 // 3.2. IN, OUT Parts Processing
360 const BOPTools_ListOfPaveBlock& aSplits=aSplitShapesPool(myDS->RefEdge(nE));
361 BOPTools_ListIteratorOfListOfPaveBlock anItPB(aSplits);
362 for (; anItPB.More(); anItPB.Next()) {
363 const BOPTools_PaveBlock& aPB=anItPB.Value();
364 nSp=aPB.Edge();
365 const TopoDS_Shape& aSplit=myDS->Shape(nSp);
366
367 aState=myDS->GetState(nSp);
368 if (aState==BooleanOperations_UNKNOWN|| aState==BooleanOperations_INTERSECTED){
369 aNBVertices=myDS->NumberOfSuccessors(nE);
370 if (aNBVertices==2) {
371 nV1=myDS->GetSuccessor(nSp, 1);
372 aStV1=myDS->GetState(nV1);
373 nV2=myDS->GetSuccessor(nSp, 2);
374 aStV2=myDS->GetState(nV2);
375 if ((aStV1==BooleanOperations_IN || aStV1==BooleanOperations_OUT)
376 && (aStV2==BooleanOperations_ON)) {
377 myDS->SetState(nSp, aStV1);
378 }
379 else if ((aStV2==BooleanOperations_IN || aStV2==BooleanOperations_OUT)
380 && (aStV1==BooleanOperations_ON)) {
381 myDS->SetState(nSp, aStV2);
382 }
383 else {
384 aState=BOPTools_StateFiller::ClassifyShapeByRef(aSplit, aTool);
385 myDS->SetState(nSp, aState);
386 if (aStV1==BooleanOperations_UNKNOWN) {
387 myDS->SetState(nV1, aState);
388 }
389 if (aStV2==BooleanOperations_UNKNOWN) {
390 myDS->SetState(nV2, aState);
391 }
392 }
393 }// if (aNBVertices==2)
394 else {
395 aState=BOPTools_StateFiller::ClassifyShapeByRef(aSplit, aTool);
396 myDS->SetState(nSp, aState);
397 }
398
399 }// if (aState==BooleanOperations_UNKNOWN || BooleanOperations_INTERSECTED)
400 }//for (; anItPB.More(); anItPB.Next())
401 }// if (aS.ShapeType()==TopAbs_EDGE)
402 }// next "Intersected" Edge
403}
404//
405//=======================================================================
406// function: DoShellNonSections
407// purpose:
408//=======================================================================
409 void BOPTools_SolidStateFiller::DoShellNonSections(const Standard_Integer iRankObj)
410{
411
412 const TopoDS_Shape& anObj=(iRankObj==1) ? myDS->Object() : myDS->Tool();
413 //
414 // 0. Restore data and preparing
415 const BooleanOperations_IndexedDataMapOfShapeInteger& aDSMap=myDS->ShapeIndexMap(iRankObj);
416
417 const BOPTools_SplitShapesPool& aSplitShapesPool=myFiller->SplitShapesPool();
418 const BOPTools_CommonBlockPool& aCommonBlockPool=myFiller->CommonBlockPool();
419
420 Standard_Integer i, nE, aNbPaveBlocks, aNb, nF1, nF2, iRank, nFx;
421 BooleanOperations_StateOfShape aState;
422 TopTools_IndexedMapOfShape aEM, anIntersectedShapes, aNonIntersectedShapes;
423 TopTools_IndexedDataMapOfShapeListOfShape aM;
424 //
425 // aM Map
426 TopExp::MapShapesAndAncestors (anObj, TopAbs_EDGE , TopAbs_WIRE , aM);
427 TopExp::MapShapesAndAncestors (anObj, TopAbs_WIRE , TopAbs_FACE , aM);
428 TopExp::MapShapesAndAncestors (anObj, TopAbs_FACE , TopAbs_SHELL, aM);
429 TopExp::MapShapesAndAncestors (anObj, TopAbs_SHELL, TopAbs_SOLID, aM);
430 //
431 // 1. anIntersectedShapes
432 //
433 // 1.1. Check EF FF interferences with nF
434 const BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
435
436 aNb=aFFs.Extent();
437 for (i=1; i<=aNb; i++) {
438 const BOPTools_SSInterference& aFF=aFFs(i);
439 // nF1
440 nF1=aFF.Index1();
441 nF2=aFF.Index2();
442
443 iRank=myDS->Rank(nF1);
444 nFx=(iRank==myDS->Rank(nF1)) ? nF1 : nF2;
445
446 const TopoDS_Shape& aFx=myDS->Shape(nFx);
447 anIntersectedShapes.Add(aFx);
448 IntersectionStates (aFx, aM, anIntersectedShapes);
449 }
450
451 //
452 TopExp::MapShapes(anObj, TopAbs_EDGE, aEM);
453 //
454 // 1.2. Edges that have Split parts
455 aNb=aEM.Extent();
456 for (i=1; i<=aNb; i++) {
457 const TopoDS_Shape& aE=aEM(i);
458 nE=aDSMap.FindFromKey(aE);
459 const BOPTools_ListOfPaveBlock& aSplitEdges=aSplitShapesPool(myDS->RefEdge(nE));
460 aNbPaveBlocks=aSplitEdges.Extent();
461 //
462 if (!aNbPaveBlocks) {
463 continue;
464 }
465 //
466 if (aNbPaveBlocks==1) {
467 const BOPTools_ListOfCommonBlock& aCBlocks=aCommonBlockPool(myDS->RefEdge(nE));
468 if (!aCBlocks.Extent()) {
469 const BOPTools_PaveBlock& aPB=aSplitEdges.First();
470 Standard_Integer nEB=aPB.Edge();
471 if (nEB==aPB.OriginalEdge()) {
472 Standard_Boolean bHasInterference=//; LNX
473 Standard_False;//LNX
474 Standard_Integer j, aNbSuc, nV;
475
476 aNbSuc=myDS->NumberOfSuccessors(nEB);
477 for (j=1; j<=aNbSuc; j++) {
478 nV=myDS->GetSuccessor(nE, j);
479 bHasInterference=myIntrPool->HasInterference(nV);
480 if (bHasInterference) {
481 break;
482 }
483 }
484 if (!bHasInterference) {
485 continue;
486 }
487 }
488 }
489 }
490 //
491 anIntersectedShapes.Add(aE);
492 IntersectionStates (aE, aM, anIntersectedShapes);
493 } // for (i=1; i<=aNb; i++)
494 //
495 // 1.3. Write Intersected state for anIntersectedShapes to the DS
496 aNb=anIntersectedShapes.Extent();
497 for (i=1; i<=aNb; i++) {
498 const TopoDS_Shape& aS=anIntersectedShapes(i);
499 if (aDSMap.Contains(aS)) {
500 nE=aDSMap.FindFromKey(aS);
501 myDS->SetState(nE, BooleanOperations_INTERSECTED);
502 }
503 }
504 //
505 // 2. aNonIntersectedShapes
506 //
507 aNb=aM.Extent();
508 for (i=1; i<=aNb; i++) {
509 const TopoDS_Shape& aS=aM.FindKey(i);
510 if (!anIntersectedShapes.Contains(aS)) {
511 aNonIntersectedShapes.Add(aS);
512 }
513 }
514 //
515 // 2.1. Write Stats for Non-intersected Shapes to the DS
516 aNb=aNonIntersectedShapes.Extent();
517 for (i=1; i<=aNb; i++) {
518 const TopoDS_Shape& aS=aNonIntersectedShapes(i);
519 nE=aDSMap.FindFromKey(aS);
520 myDS->SetState(nE, BooleanOperations_OUT);
521 }
522 //---------------------------------------------------
523 //
524 // 3. Intersected Edges' Processing
525 //
526 //---------------------------------------------------
527 Standard_Integer nSp;
528
529
530 aNb=anIntersectedShapes.Extent();
531 for (i=1; i<=aNb; i++) {
532 const TopoDS_Shape& aS=anIntersectedShapes(i);
533 if (aS.ShapeType()==TopAbs_EDGE) {
534 nE=aDSMap.FindFromKey(aS);
535 //
536 // 3.1. On Parts Processing
537 const BOPTools_ListOfCommonBlock& aLCB=aCommonBlockPool(myDS->RefEdge(nE));
538 BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
539 for (; anItCB.More(); anItCB.Next()) {
540 const BOPTools_CommonBlock& aCB=anItCB.Value();
541 BOPTools_CommonBlock* pCB=(BOPTools_CommonBlock*) &aCB;
542 BOPTools_PaveBlock& aPB=pCB->PaveBlock1(nE);
543 nSp=aPB.Edge();
544 myDS->SetState(nSp, BooleanOperations_ON);
545 }
546 //
547 // 3.2. IN, OUT Parts Processing
548 const BOPTools_ListOfPaveBlock& aSplits=aSplitShapesPool(myDS->RefEdge(nE));
549 BOPTools_ListIteratorOfListOfPaveBlock anItPB(aSplits);
550 for (; anItPB.More(); anItPB.Next()) {
551 const BOPTools_PaveBlock& aPB=anItPB.Value();
552 nSp=aPB.Edge();
553 //const TopoDS_Shape& aSplit=myDS->Shape(nSp);//LNX
554
555 aState=myDS->GetState(nSp);
556 if (aState==BooleanOperations_UNKNOWN|| aState==BooleanOperations_INTERSECTED){
557 myDS->SetState(nSp, BooleanOperations_OUT);
558
559 }// if (aState==BooleanOperations_UNKNOWN || BooleanOperations_INTERSECTED)
560 }//for (; anItPB.More(); anItPB.Next())
561 }// if (aS.ShapeType()==TopAbs_EDGE)
562 }// next "Intersected" Edge
563}
564//
565//=======================================================================
566// function: DoSections
567// purpose:
568//=======================================================================
569 void BOPTools_SolidStateFiller::DoSections()
570{
571 Standard_Integer i, j, aNb, aNbCurves, n1, n2, nE;
572
573 BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
574
575 aNb=aFFs.Extent();
576 for (i=1; i<=aNb; i++) {
577 BOPTools_SSInterference& aFF=aFFs(i);
578 n1=aFF.Index1();
579 n2=aFF.Index2();
580 BOPTools_SequenceOfCurves& aSC=aFF.Curves();
581 aNbCurves=aSC.Length();
582 for (j=1; j<=aNbCurves; j++) {
583 const BOPTools_Curve& aBC=aSC(j);
584 const BOPTools_ListOfPaveBlock& aLPB=aBC.NewPaveBlocks();
585 BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
586 for (; anIt.More(); anIt.Next()) {
587 const BOPTools_PaveBlock& aPB=anIt.Value();
588 nE=aPB.Edge();
589 myDS->SetState(nE, BooleanOperations_ON);
590 }
591 }
592 }
593}
594
595//=======================================================================
596// function: IsFaceIntersected
597// purpose:
598//=======================================================================
599 Standard_Boolean BOPTools_SolidStateFiller::IsFaceIntersected(const Standard_Integer nF)
600{
601 Standard_Boolean bFlag=Standard_False;
602 Standard_Integer i, aNb, n1, n2;
603
604 const BOPTools_CArray1OfESInterference& aEFs=myIntrPool->ESInterferences();
605 aNb=aEFs.Extent();
606 for (i=1; i<=aNb; i++) {
607 const BOPTools_ESInterference& aEF=aEFs(i);
608 n1=aEF.Index1();
609 n2=aEF.Index2();
610 if (n1==nF || n2==nF) {
611 return !bFlag;
612 }
613 }
614
615 const BOPTools_CArray1OfSSInterference& aFFs=myIntrPool->SSInterferences();
616 aNb=aFFs.Extent();
617 for (i=1; i<=aNb; i++) {
618 const BOPTools_SSInterference& aFF=aFFs(i);
619 n1=aFF.Index1();
620 n2=aFF.Index2();
621 if (n1==nF || n2==nF) {
622 return !bFlag;
623 }
624 }
625 return bFlag;
626}
627
628
629
630
631
632//=======================================================================
633// function: PropagateState [for faces]
634// purpose:
635//=======================================================================
636 void PropagateState(const TopoDS_Shape& aF,
637 const BooleanOperations_StateOfShape aState,
638 BooleanOperations_ShapesDataStructure* pDS,
639 const Standard_Integer iRank,
640 BOPTools_IndexedDataMapOfShapeWithState& aSWS,
641 const TopTools_IndexedDataMapOfShapeListOfShape& aEFMap,
642 TopTools_IndexedMapOfShape& aProcessedShapes)
643{
644 // PropagateState for Sub-Shapes
645 PropagateState (aF, aState, pDS, iRank, aSWS, aProcessedShapes);
646 // PropagateState for connected Faces;
647 TopTools_IndexedMapOfShape anEdgeMap;
648 TopExp::MapShapes(aF, TopAbs_EDGE, anEdgeMap);
649
650 Standard_Integer i, aNbE;
651 aNbE=anEdgeMap.Extent();
652
653 for (i=1; i<=aNbE; i++) {
654 const TopoDS_Shape& aE=anEdgeMap(i);
655 //
656 const TopTools_ListOfShape& aFacesList=aEFMap.FindFromKey(aE);
657 //
658 TopTools_ListIteratorOfListOfShape anIt(aFacesList);
659 for (; anIt.More(); anIt.Next()) {
660 const TopoDS_Shape& aFi=anIt.Value();
661 if (!aProcessedShapes.Contains(aFi)) {
662 if (!aFi.IsSame(aF)) {
663 aSWS.Add(aFi, aState);
664 aProcessedShapes.Add(aFi);
665 PropagateState(aFi, aState, pDS, iRank, aSWS, aEFMap, aProcessedShapes);
666 }
667 }
668 }
669 }
670}
671
672//=======================================================================
673// function: PropagateState
674// purpose:
675//=======================================================================
676void PropagateState(const TopoDS_Shape& aSS,
677 const BooleanOperations_StateOfShape aState,
678 BooleanOperations_ShapesDataStructure* pDS,
679 const Standard_Integer iRank,
680 BOPTools_IndexedDataMapOfShapeWithState& aSWS,
681 TopTools_IndexedMapOfShape& aProcessedShapes)
682{
683 TopAbs_ShapeEnum aSubType;
684
685 aSubType=BOPTools_StateFiller::SubType(aSS);
686
687 if (aSubType==TopAbs_SHAPE) {
688 return;
689 }
690
691 const BooleanOperations_IndexedDataMapOfShapeInteger& aDSMap= pDS->ShapeIndexMap(iRank);
692
693 TopTools_IndexedMapOfShape aSubMap;
694 TopExp::MapShapes(aSS, aSubType, aSubMap);
695
696 Standard_Integer i, aNb, nV;
697 aNb=aSubMap.Extent();
698 for (i=1; i<=aNb; i++) {
699 const TopoDS_Shape& aS=aSubMap(i);
700 if (!aProcessedShapes.Contains(aS)) {
701 if (aSubType==TopAbs_VERTEX) {
702 nV=aDSMap.FindFromKey(aS);
703 BooleanOperations_StateOfShape aSt=pDS->GetState(nV);
704 if (aSt!=BooleanOperations_UNKNOWN){
705 aProcessedShapes.Add(aS);
706 continue;
707 }
708 }
709 aSWS.Add(aS, aState);
710 aProcessedShapes.Add(aS);
711 PropagateState (aS, aState, pDS, iRank, aSWS, aProcessedShapes);
712 }
713 }
714}
715//=======================================================================
716// function: IntersectionStates
717// purpose:
718//=======================================================================
719void IntersectionStates(const TopoDS_Shape& aE,
720 const TopTools_IndexedDataMapOfShapeListOfShape& aM,
721 TopTools_IndexedMapOfShape& anIntersectedShapes)
722{
723 if (aM.Contains(aE)) {
724 const TopTools_ListOfShape& anAncesstors=aM.FindFromKey(aE);
725 TopTools_ListIteratorOfListOfShape anIt(anAncesstors);
726 for (; anIt.More(); anIt.Next()) {
727 const TopoDS_Shape& anAnc=anIt.Value();
728 anIntersectedShapes.Add(anAnc);
729 IntersectionStates(anAnc, aM, anIntersectedShapes);
730 }
731 }
732}
733//=======================================================================
734// function: HasConnexity
735// purpose:
736//=======================================================================
737 Standard_Boolean HasConnexity(const TopoDS_Shape& aS,
738 const BOPTools_IndexedDataMapOfShapeWithState& aSWS,
739 const TopTools_IndexedDataMapOfShapeListOfShape& aMVE,
740 BooleanOperations_StateOfShape& aState)
741{
742 TopAbs_ShapeEnum aType;
743 BooleanOperations_StateOfShape aSt;
744 aType=aS.ShapeType();
745 if (aType!=TopAbs_EDGE) {
746 Standard_Integer i, aNb;
747 TopTools_IndexedMapOfShape aME;
748 TopExp::MapShapes(aS, TopAbs_EDGE, aME);
749 aNb=aME.Extent();
750 for (i=1; i<=aNb; i++) {
751 const TopoDS_Shape& aE=aME(i);
752 if (aSWS.Contains(aE)){
753 aSt=aSWS.FindFromKey(aE);
754 aState=aSt;
755 return Standard_True;
756 }
757 }
758 }
759 else {
760 TopExp_Explorer anExp (aS, TopAbs_VERTEX);
761 for (; anExp.More(); anExp.Next()) {
762 const TopoDS_Shape& aV=anExp.Current();
763 if (aMVE.Contains(aV)) {
764 const TopTools_ListOfShape& anEdgesList=aMVE.FindFromKey(aV);
765 TopTools_ListIteratorOfListOfShape anIt(anEdgesList);
766 for (; anIt.More(); anIt.Next()) {
767 const TopoDS_Shape& aEx=anIt.Value();
768 if (aSWS.Contains(aEx)) {
769 aSt=aSWS.FindFromKey(aEx);
770 aState=aSt;
771 return Standard_True;
772 }
773 }
774 }
775 }
776 }
777
778 aState=BooleanOperations_UNKNOWN;
779 return Standard_False;
780}
781
782/*
783//=======================================================================
784// function: ConvertState
785// purpose:
786//=======================================================================
787BooleanOperations_StateOfShape
788 BOPTools_SolidStateFiller::ConvertState(const TopAbs_State aSt)
789{
790 BooleanOperations_StateOfShape aState;
791 switch (aSt) {
792 case TopAbs_IN:
793 aState=BooleanOperations_IN;
794 break;
795 case TopAbs_OUT:
796 aState=BooleanOperations_OUT;
797 break;
798 case TopAbs_ON:
799 aState=BooleanOperations_ON;
800 break;
801 case TopAbs_UNKNOWN:
802 aState=BooleanOperations_UNKNOWN;
803 break;
804 default:
805 aState=BooleanOperations_UNKNOWN;
806 break;
807 }
808 return aState;
809}
810
811//=======================================================================
812// function: ConvertState
813// purpose:
814//=======================================================================
815TopAbs_State
816 BOPTools_SolidStateFiller::ConvertState(const BooleanOperations_StateOfShape aSt)
817{
818 TopAbs_State aState;
819
820 switch (aSt) {
821 case BooleanOperations_IN:
822 aState=TopAbs_IN;
823 break;
824 case BooleanOperations_OUT:
825 aState=TopAbs_OUT;
826 break;
827 case BooleanOperations_ON:
828 aState=TopAbs_ON;
829 break;
830 case BooleanOperations_UNKNOWN:
831 aState=TopAbs_UNKNOWN;
832 break;
833 default:
834 aState=TopAbs_UNKNOWN;
835 break;
836 }
837 return aState;
838}
839//=======================================================================
840// function: ClassifyShapeByRef
841// purpose:
842//=======================================================================
843 BooleanOperations_StateOfShape
844 BOPTools_SolidStateFiller::ClassifyShapeByRef (const TopoDS_Shape& aS,
845 const TopoDS_Shape& aRef)
846{
847 TopAbs_ShapeEnum aType;
848 aType=aS.ShapeType();
849
850 TopoDS_Edge aE;
851 if (aType!=TopAbs_EDGE) {
852 TopTools_IndexedMapOfShape aME;
853 TopExp::MapShapes(aS, TopAbs_EDGE, aME);
854 aE=TopoDS::Edge(aME(1));
855 }
856 else {
857 aE=TopoDS::Edge(aS);
858 }
859
860 TopAbs_State aSt=BOPTools_SolidStateFiller::ClassifyEdgeToSolidByOnePoint(aE, aRef);
861 BooleanOperations_StateOfShape aState=BOPTools_SolidStateFiller::ConvertState(aSt) ;
862
863 return aState;
864}
865
866//=======================================================================
867// function: ClassifyEdgeToSolidByOnePoint
868// purpose:
869//=======================================================================
870TopAbs_State
871 BOPTools_SolidStateFiller::ClassifyEdgeToSolidByOnePoint(const TopoDS_Edge& E,
872 const TopoDS_Shape& Ref)
873{
874 Standard_Real f2 = 0., l2 = 0., par = 0.;
875
876 Handle(Geom_Curve) C3D = BRep_Tool::Curve(E, f2, l2);
877 gp_Pnt aP3d;
878
879
880
881 if(C3D.IsNull()) {
882 //it means that we are in degenerated edge
883 const TopoDS_Vertex& fv = TopExp::FirstVertex(E);
884 if(fv.IsNull()){
885 return TopAbs_UNKNOWN;
886 }
887 aP3d = BRep_Tool::Pnt(fv);
888 }
889 else {//usual case
890 par=IntTools_Tools::IntermediatePoint(f2, l2);
891 C3D -> D0(par, aP3d);
892 }
893
894 BRepClass3d_SolidClassifier SC(Ref);
895 SC.Perform(aP3d, 1e-7);
896
897 TopAbs_State aState=SC.State();
898
899 return aState;
900}
901//=======================================================================
902// function: SubType
903// purpose:
904//=======================================================================
905 TopAbs_ShapeEnum BOPTools_SolidStateFiller::SubType(const TopoDS_Shape& aS)
906{
907 TopAbs_ShapeEnum aSourceType, aReturnType;
908 aSourceType=aS.ShapeType();
909
910 switch (aSourceType) {
911 case TopAbs_SOLID:
912 aReturnType=TopAbs_SHELL;
913 break;
914 case TopAbs_SHELL:
915 aReturnType=TopAbs_FACE;
916 break;
917 case TopAbs_FACE:
918 aReturnType=TopAbs_WIRE;
919 break;
920 case TopAbs_WIRE:
921 aReturnType=TopAbs_EDGE;
922 break;
923 case TopAbs_EDGE:
924 aReturnType=TopAbs_VERTEX;
925 break;
926 default:
927 aReturnType=TopAbs_SHAPE;
928 break;
929 }
930 return aReturnType;
931}
932*/
Open CASCADE Technology repository