0023904: Multiple warning on Windows x86_64 target concerning WinAPI usage
[occt.git] / src / BOPDS / BOPDS_DS.cxx
CommitLineData
4e57c75e 1// Created by: Peter KURNEV
2// Copyright (c) 1999-2012 OPEN CASCADE SAS
3//
4// The content of this file is subject to the Open CASCADE Technology Public
5// License Version 6.5 (the "License"). You may not use the content of this file
6// except in compliance with the License. Please obtain a copy of the License
7// at http://www.opencascade.org and read it completely before using this file.
8//
9// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11//
12// The Original Code and all software distributed under the License is
13// distributed on an "AS IS" basis, without warranty of any kind, and the
14// Initial Developer hereby disclaims all such warranties, including without
15// limitation, any warranties of merchantability, fitness for a particular
16// purpose or non-infringement. Please see the License for the specific terms
17// and conditions governing the rights and limitations under the License.
18
19
20#include <BOPDS_DS.ixx>
21//
22#include <NCollection_IncAllocator.hxx>
23#include <NCollection_BaseAllocator.hxx>
24
25#include <gp_Pnt.hxx>
26#include <Bnd_Box.hxx>
27//
28#include <TopoDS_Shape.hxx>
29#include <TopoDS_Iterator.hxx>
30#include <TopoDS_Vertex.hxx>
31#include <TopoDS_Edge.hxx>
32#include <TopoDS_Face.hxx>
33#include <BRep_Tool.hxx>
34//
35#include <BRepBndLib.hxx>
36//
37#include <BOPCol_MapOfInteger.hxx>
38#include <BOPCol_ListOfInteger.hxx>
39#include <BOPCol_DataMapOfShapeInteger.hxx>
40//
41#include <BOPDS_IndexRange.hxx>
42#include <BOPDS_ShapeInfo.hxx>
43#include <BOPDS_PassKey.hxx>
44#include <BOPDS_DataMapOfPassKeyListOfPaveBlock.hxx>
45#include <BOPDS_PassKey.hxx>
46
47#include <Geom_Curve.hxx>
48#include <BRep_Builder.hxx>
49#include <Precision.hxx>
50#include <IntTools_Tools.hxx>
51#include <BOPTools_AlgoTools.hxx>
52#include <GeomAPI_ProjectPointOnCurve.hxx>
53#include <BOPDS_MapOfPave.hxx>
54
55//
56static
57 inline void ResetShape(const TopoDS_Shape& aS);
58
59static
60 inline void ResetShapes(const TopoDS_Shape& aS);
61
62static
63 void TotalShapes(const TopoDS_Shape& aS,
64 Standard_Integer& aNbS);
65
66static
67 Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
68 const TopoDS_Edge& aE);
69static
70 void SortShell(const int n, BOPDS_Pave *a);
71
72//=======================================================================
73//function :
74//purpose :
75//=======================================================================
76 BOPDS_DS::BOPDS_DS()
77:
78 myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
79 myArguments(myAllocator),
80 myRanges(myAllocator),
81 myLines(myAllocator),
82 myMapShapeIndex(100, myAllocator),
83 myPaveBlocksPool(myAllocator),
84 myFaceInfoPool(myAllocator),
85 myShapesSD(100, myAllocator),
86 myInterfTB(100, myAllocator),
87 myInterfVV(myAllocator),
88 myInterfVE(myAllocator),
89 myInterfVF(myAllocator),
90 myInterfEE(myAllocator),
91 myInterfEF(myAllocator),
92 myInterfFF(myAllocator)
93{
94 myNbShapes=0;
95 myNbSourceShapes=0;
96}
97//=======================================================================
98//function :
99//purpose :
100//=======================================================================
101 BOPDS_DS::BOPDS_DS(const Handle(NCollection_BaseAllocator)& theAllocator)
102:
103 myAllocator(theAllocator),
104 myArguments(myAllocator),
105 myRanges(myAllocator),
106 myLines(myAllocator),
107 myMapShapeIndex(100, myAllocator),
108 myPaveBlocksPool(myAllocator),
109 myFaceInfoPool(myAllocator),
110 myShapesSD(100, myAllocator),
111 myInterfTB(100, myAllocator),
112 myInterfVV(myAllocator),
113 myInterfVE(myAllocator),
114 myInterfVF(myAllocator),
115 myInterfEE(myAllocator),
116 myInterfEF(myAllocator),
117 myInterfFF(myAllocator)
118{
119 myNbShapes=0;
120 myNbSourceShapes=0;
121}
122//=======================================================================
123//function : ~
124//purpose :
125//=======================================================================
126 BOPDS_DS::~BOPDS_DS()
127{
128 Clear();
129}
130//=======================================================================
131//function : Clear
132//purpose :
133//=======================================================================
134 void BOPDS_DS::Clear()
135{
136 myNbShapes=0;
137 myNbSourceShapes=0;
138 //
139 myArguments.Clear();
140 myRanges.Clear();
141 myLines.Clear();
142 myMapShapeIndex.Clear();
143 myPaveBlocksPool.Clear();
144 myFaceInfoPool.Clear();
145 myShapesSD.Clear();
146 myInterfTB.Clear();
147 myInterfVV.Clear();
148 myInterfVE.Clear();
149 myInterfVF.Clear();
150 myInterfEE.Clear();
151 myInterfEF.Clear();
152 myInterfFF.Clear();
153}
154//=======================================================================
155//function : SetArguments
156//purpose :
157//=======================================================================
158 void BOPDS_DS::SetArguments(const BOPCol_ListOfShape& theLS)
159{
160 myArguments=theLS;
161}
162//=======================================================================
163//function : Arguments
164//purpose :
165//=======================================================================
166 const BOPCol_ListOfShape& BOPDS_DS::Arguments()const
167{
168 return myArguments;
169}
170//=======================================================================
171//function : Allocator
172//purpose :
173//=======================================================================
174 const Handle(NCollection_BaseAllocator)& BOPDS_DS::Allocator()const
175{
176 return myAllocator;
177}
178
179//=======================================================================
180//function : NbShapes
181//purpose :
182//=======================================================================
183 Standard_Integer BOPDS_DS::NbShapes()const
184{
185 return myLines.Size();
186}
187//=======================================================================
188//function : NbSourceShapes
189//purpose :
190//=======================================================================
191 Standard_Integer BOPDS_DS::NbSourceShapes()const
192{
193 return myNbSourceShapes;
194}
195//=======================================================================
196//function : NbRanges
197//purpose :
198//=======================================================================
199 Standard_Integer BOPDS_DS::NbRanges()const
200{
201 return myRanges.Size();
202}
203//=======================================================================
204//function : Range
205//purpose :
206//=======================================================================
207 const BOPDS_IndexRange& BOPDS_DS::Range(const Standard_Integer theI)const
208{
209 return myRanges(theI);
210}
211//=======================================================================
212//function : Rank
213//purpose :
214//=======================================================================
215 Standard_Integer BOPDS_DS::Rank(const Standard_Integer theI)const
216{
217 Standard_Integer i, aNb, iErr;
218 //
219 iErr=-1;
220 aNb=NbRanges();
221 for(i=0; i<aNb; ++i) {
222 const BOPDS_IndexRange& aR=Range(i);
223 if (aR.Contains(theI)) {
224 return i;
225 }
226 }
227 return iErr;
228}
229//=======================================================================
230//function : IsNewShape
231//purpose :
232//=======================================================================
233 Standard_Boolean BOPDS_DS::IsNewShape(const Standard_Integer theI)const
234{
235 return theI>=NbSourceShapes();
236}
237//=======================================================================
238//function : Append
239//purpose :
240//=======================================================================
241 Standard_Integer BOPDS_DS::Append(const BOPDS_ShapeInfo& theSI)
242{
243 Standard_Integer iX;
244 //
245 iX=myLines.Append()-1;
246 myLines(iX)=theSI;
247 return iX;
248}
249//=======================================================================
250//function : Append
251//purpose :
252//=======================================================================
253 Standard_Integer BOPDS_DS::Append(const TopoDS_Shape& theS)
254{
255 Standard_Integer iX;
256 //
257 iX=myLines.Append()-1;
258 myLines(iX).SetShape(theS);
259 return iX;
260}
261//=======================================================================
262//function : ShapeInfo
263//purpose :
264//=======================================================================
265 const BOPDS_ShapeInfo& BOPDS_DS::ShapeInfo(const Standard_Integer theI)const
266{
267 return myLines(theI);
268}
269//=======================================================================
270//function : ChangeShapeInfo
271//purpose :
272//=======================================================================
273 BOPDS_ShapeInfo& BOPDS_DS::ChangeShapeInfo(const Standard_Integer theI)
274{
275 BOPDS_ShapeInfo *pSI;
276 //
277 const BOPDS_ShapeInfo& aSI=ShapeInfo(theI);
278 pSI=(BOPDS_ShapeInfo *)&aSI;
279 return *pSI;
280}
281//=======================================================================
282//function : Shape
283//purpose :
284//=======================================================================
285 const TopoDS_Shape& BOPDS_DS::Shape(const Standard_Integer theI)const
286{
287 const TopoDS_Shape& aS=ShapeInfo(theI).Shape();
288 return aS;
289}
290//=======================================================================
291//function : Index
292//purpose :
293//=======================================================================
294 Standard_Integer BOPDS_DS::Index(const TopoDS_Shape& theS)const
295{
296 Standard_Integer iRet;
297 //
298 iRet=-1;
299 if (myMapShapeIndex.IsBound(theS)) {
300 iRet=myMapShapeIndex.Find(theS);
301 }
302 return iRet;
303}
304
305//=======================================================================
306//function : Init
307//purpose :
308//=======================================================================
309 void BOPDS_DS::Init()
310{
311 Standard_Integer i1, i2, j, aI, aNb, aNbS, aNbE, aNbSx, nV, nW, nE, aNbF;
312 Standard_Real aTol;
313 TopAbs_ShapeEnum aTS;
314 BOPCol_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
315 BOPCol_ListIteratorOfListOfShape aIt;
316 BOPDS_IndexRange aR;
317 Handle(NCollection_IncAllocator) aAllocator;
318 //
319 // 1 Append Source Shapes
320 aNb=myArguments.Extent();
321 if (!aNb) {
322 return;
323 }
324 //
325 myRanges.SetStartSize(aNb);
326 myRanges.Init();
327 //
328 aIt.Initialize(myArguments);
329 for (; aIt.More(); aIt.Next()) {
330 const TopoDS_Shape& aSx=aIt.Value();
331 ResetShapes(aSx);
332 }
333 //
334 aNbS=0;
335 aIt.Initialize(myArguments);
336 for (; aIt.More(); aIt.Next()) {
337 const TopoDS_Shape& aSx=aIt.Value();
338 //
339 aNbSx=0;
340 TotalShapes(aSx, aNbSx);
341 aNbS=aNbS+aNbSx;
342 }
343 //
344 myLines.SetStartSize(2*aNbS);
345 myLines.SetIncrement(aNbS);
346 myLines.Init();
347 //
348 //-----------------------------------------------------scope_1 f
349 aAllocator=new NCollection_IncAllocator();
350 //
351 BOPCol_DataMapOfShapeInteger& aMSI=myMapShapeIndex;
352 //
353 i1=0;
354 i2=0;
355 aIt.Initialize(myArguments);
356 for (; aIt.More(); aIt.Next()) {
357 const TopoDS_Shape& aS=aIt.Value();
358 aI=Append(aS);
359 aMSI.Bind(aS, aI);
360 //
361 InitShape(aI, aS, aAllocator, aMSI);
362 //
363 i2=NbShapes()-1;
364 aR.SetIndices(i1, i2);
365 myRanges.Append(aR);
366 i1=i2+1;
367 }
368 //
369 //aMSI.Clear();
370 //
371 myNbSourceShapes=NbShapes();
372 //
373 // 2 Bounding Boxes
374 //
375 // 2.1 Vertex
376 for (j=0; j<myNbSourceShapes; ++j) {
377 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
378 //
379 const TopoDS_Shape& aS=aSI.Shape();
380 ResetShape(aS);
381 //
382 aTS=aSI.ShapeType();
383 //
384 if (aTS==TopAbs_VERTEX) {
385 Bnd_Box& aBox=aSI.ChangeBox();
386 const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aS);
387 const gp_Pnt& aP=BRep_Tool::Pnt(aV);
388 aTol=BRep_Tool::Tolerance(aV);
389 aBox.SetGap(aTol);
390 aBox.Add(aP);
391 }
392 }
393 // 2.2 Edge
394 aNbE=0;
395 for (j=0; j<myNbSourceShapes; ++j) {
396 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
397 //
398 aTS=aSI.ShapeType();
399 if (aTS==TopAbs_EDGE) {
400 const TopoDS_Shape& aS=aSI.Shape();
401 const TopoDS_Edge& aE=*((TopoDS_Edge*)&aS);
402 aTol=BRep_Tool::Tolerance(aE);
403 //
404 if (!BRep_Tool::Degenerated(aE)) {
405 Standard_Boolean bInf1, bInf2;
406 Standard_Integer aIx;
407 Standard_Real aT1, aT2;
408 gp_Pnt aPx;
409 Handle(Geom_Curve) aC3D;
410 TopoDS_Vertex aVx;
411 TopoDS_Edge aEx;
412 BRep_Builder aBB;
413 BOPDS_ShapeInfo aSIx;
414 //
415 BOPCol_ListOfInteger& aLI=aSI.ChangeSubShapes();
416 //
417 aEx=aE;
418 aEx.Orientation(TopAbs_FORWARD);
419 //
420 aC3D=BRep_Tool::Curve (aEx, aT1, aT2);
421 bInf1=Precision::IsNegativeInfinite(aT1);
422 bInf2=Precision::IsPositiveInfinite(aT2);
423 //
424 if (bInf1) {
425 aC3D->D0(aT1, aPx);
426 aBB.MakeVertex(aVx, aPx, aTol);
427 aVx.Orientation(TopAbs_FORWARD);
428 //
429 aSIx.SetShape(aVx);
430 aSIx.SetShapeType(TopAbs_VERTEX);
431 aSIx.SetFlag(1); //infinite flag
432 //
433 aIx=Append(aSIx);
434 aLI.Append(aIx);
435 }
436 if (bInf2) {
437 aC3D->D0(aT2, aPx);
438 aBB.MakeVertex(aVx, aPx, aTol);
439 aVx.Orientation(TopAbs_REVERSED);
440 //
441 aSIx.SetShape(aVx);
442 aSIx.SetShapeType(TopAbs_VERTEX);
443 aSIx.SetFlag(1);//infinite flag
444 //
445 aIx=Append(aSIx);
446 aLI.Append(aIx);
447 }
448 }
449 else {
450 aSI.SetFlag(j);
451 }
452 //
453 Bnd_Box& aBox=aSI.ChangeBox();
454 BRepBndLib::Add(aE, aBox);
455 //
456 const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
457 aIt1.Initialize(aLV);
458 for (; aIt1.More(); aIt1.Next()) {
459 nV=aIt1.Value();
460 BOPDS_ShapeInfo& aSIV=ChangeShapeInfo(nV);
461 Bnd_Box& aBx=aSIV.ChangeBox();
462 aBox.Add(aBx);
463 }
464 ++aNbE;
465 }
466 }
467 // 2.3 Face
468 BOPCol_MapOfInteger aMI(100, aAllocator);
469 BOPCol_MapIteratorOfMapOfInteger aItMI;
470 //
471 aNbF=0;
472 for (j=0; j<myNbSourceShapes; ++j) {
473 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
474 //
475 aTS=aSI.ShapeType();
476 if (aTS==TopAbs_FACE) {
477 const TopoDS_Shape& aS=aSI.Shape();
478 const TopoDS_Face& aF=*((TopoDS_Face*)&aS);
479 aTol=BRep_Tool::Tolerance(aF);
480 //
481 Bnd_Box& aBox=aSI.ChangeBox();
482 BRepBndLib::Add(aS, aBox);
483 //
484 BOPCol_ListOfInteger& aLW=aSI.ChangeSubShapes();
485 aIt1.Initialize(aLW);
486 for (; aIt1.More(); aIt1.Next()) {
487 nW=aIt1.Value();
488 BOPDS_ShapeInfo& aSIW=ChangeShapeInfo(nW);
489 //
490 const BOPCol_ListOfInteger& aLE=aSIW.SubShapes();
491 aIt2.Initialize(aLE);
492 for (; aIt2.More(); aIt2.Next()) {
493 nE=aIt2.Value();
494 BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
495 Bnd_Box& aBx=aSIE.ChangeBox();
496 aBox.Add(aBx);
497 aMI.Add(nE);
498 //
499 const TopoDS_Edge& aE=*(TopoDS_Edge*)(&aSIE.Shape());
500 if (BRep_Tool::Degenerated(aE)) {
501 aSIE.SetFlag(j);
502 }
503 //
504 const BOPCol_ListOfInteger& aLV=aSIE.SubShapes();
505 aIt3.Initialize(aLV);
506 for (; aIt3.More(); aIt3.Next()) {
507 nV=aIt3.Value();
508 aMI.Add(nV);
509 }
510 }
511 }//for (; aIt1.More(); aIt1.Next()) {
512 //
513 //
514 // For a Face: change wires for BRep sub-shapes
515 aLW.Clear();
516 aItMI.Initialize(aMI);
517 for (; aItMI.More(); aItMI.Next()) {
518 nV=aItMI.Value();
519 aLW.Append(nV);
520 }
521 aMI.Clear();
522 ++aNbF;
523 }//if (aTS==TopAbs_FACE) {
524 }//for (j=0; j<myNbSourceShapes; ++j) {
525 //
526 aMI.Clear();
527 aAllocator.Nullify();
528 //-----------------------------------------------------scope_1 t
529 //
530 // 3 myPaveBlocksPool
531 myPaveBlocksPool.SetStartSize(aNbE);
532 myPaveBlocksPool.SetIncrement(aNbE);
533 myPaveBlocksPool.Init();
534 //
535 // 4. myFaceInfoPool
536 myFaceInfoPool.SetStartSize(aNbF);
537 myFaceInfoPool.SetIncrement(aNbF);
538 myFaceInfoPool.Init();
539 //
540}
541//=======================================================================
542//function : InitShape
543//purpose :
544//=======================================================================
545 void BOPDS_DS::InitShape(const Standard_Integer aI,
546 const TopoDS_Shape& aS,
547 Handle(NCollection_BaseAllocator)& theAllocator,
548 BOPCol_DataMapOfShapeInteger& aMSI)
549{
550 Standard_Integer aIx;
551 TopoDS_Iterator aIt;
552 BOPCol_ListIteratorOfListOfInteger aIt1;
553 //
554 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(aI);
555 aSI.SetShapeType(aS.ShapeType());
556 BOPCol_ListOfInteger& aLI=aSI.ChangeSubShapes();
557 //
558 BOPCol_MapOfInteger aM(100, theAllocator);
559 //
560 aIt1.Initialize(aLI);
561 for (; aIt1.More(); aIt1.Next()) {
562 aM.Add(aIt1.Value());
563 }
564 //
565 aIt.Initialize(aS);
566 for (; aIt.More(); aIt.Next()) {
567 const TopoDS_Shape& aSx=aIt.Value();
568 if (aMSI.IsBound(aSx)) {
569 aIx=aMSI.Find(aSx);
570 }
571 else {
572 aIx=Append(aSx);
573 aMSI.Bind(aSx, aIx);
574 }
575 //
576 InitShape(aIx, aSx, theAllocator, aMSI);
577 //
578 if (aM.Add(aIx)) {
579 aLI.Append(aIx);
580 }
581 }
582}
583
584//=======================================================================
585//function : HasInterf
586//purpose :
587//=======================================================================
588 Standard_Boolean BOPDS_DS::HasInterf(const Standard_Integer theI) const
589{
590 Standard_Integer n1, n2;
591 Standard_Boolean bRet;
592 BOPDS_MapIteratorMapOfPassKey aIt;
593 //
594 bRet = Standard_False;
595 //
596 aIt.Initialize(myInterfTB);
597 for (; aIt.More(); aIt.Next()) {
598 const BOPDS_PassKey& aPK = aIt.Value();
599 aPK.Ids(n1, n2);
600 if (n1 == theI || n2 == theI) {
601 bRet = Standard_True;
602 break;
603 }
604 }
605 //
606 return bRet;
607}
608
609//=======================================================================
610//function : HasInterfShapeSubShapes
611//purpose :
612//=======================================================================
613 Standard_Boolean BOPDS_DS::HasInterfShapeSubShapes(const Standard_Integer theI1,
614 const Standard_Integer theI2)const
615{
616 Standard_Boolean bRet;
617 Standard_Integer n2;
618 BOPCol_ListIteratorOfListOfInteger aIt;
619 bRet = Standard_False;
620 //
621 const BOPDS_ShapeInfo& aSI=ShapeInfo(theI2);
622 const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
623 aIt.Initialize(aLI);
624 for (; aIt.More(); aIt.Next()) {
625 n2=aIt.Value();
626 bRet=HasInterf(theI1, n2);
627 if(bRet) {
628 break;
629 }
630 }
631 return bRet;
632}
633
634//=======================================================================
635//function : HasInterfSubShapes
636//purpose :
637//=======================================================================
638 Standard_Boolean BOPDS_DS::HasInterfSubShapes(const Standard_Integer theI1,
639 const Standard_Integer theI2)const
640{
641 Standard_Boolean bRet;
642 Standard_Integer n1;
643 BOPCol_ListIteratorOfListOfInteger aIt;
644 bRet = Standard_False;
645 //
646 const BOPDS_ShapeInfo& aSI=ShapeInfo(theI1);
647 const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
648 aIt.Initialize(aLI);
649 for (; aIt.More(); aIt.Next()) {
650 n1=aIt.Value();
651 bRet=HasInterfShapeSubShapes(n1, theI2);
652 if(bRet) {
653 break;
654 }
655 }
656 return bRet;
657}
658//
659// PaveBlocks
660//=======================================================================
661//function : PaveBlocksPool
662//purpose :
663//=======================================================================
664 const BOPDS_VectorOfListOfPaveBlock& BOPDS_DS::PaveBlocksPool()const
665{
666 return myPaveBlocksPool;
667}
668//=======================================================================
669//function : ChangePaveBlocksPool
670//purpose :
671//=======================================================================
672 BOPDS_VectorOfListOfPaveBlock& BOPDS_DS::ChangePaveBlocksPool()
673{
674 return myPaveBlocksPool;
675}
676//=======================================================================
677//function : HasPaveBlocks
678//purpose :
679//=======================================================================
680 Standard_Boolean BOPDS_DS::HasPaveBlocks(const Standard_Integer theI)const
681{
682 return ShapeInfo(theI).HasReference();
683}
684//=======================================================================
685//function : PaveBlocks
686//purpose :
687//=======================================================================
688 const BOPDS_ListOfPaveBlock& BOPDS_DS::PaveBlocks(const Standard_Integer theI)const
689{
690 static BOPDS_ListOfPaveBlock sLPB;
691 Standard_Integer aRef;
692 //
693 if (HasPaveBlocks(theI)) {
694 aRef=ShapeInfo(theI).Reference();
695 const BOPDS_ListOfPaveBlock& aLPB=myPaveBlocksPool(aRef);
696 return aLPB;
697 }
698 return sLPB;
699}
700//=======================================================================
701//function : ChangePaveBlocks
702//purpose :
703//=======================================================================
704 BOPDS_ListOfPaveBlock& BOPDS_DS::ChangePaveBlocks(const Standard_Integer theI)
705{
706 Standard_Boolean bHasReference;
707 Standard_Integer aRef;
4e57c75e 708 //
709 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
710 bHasReference=aSI.HasReference();
711 if (!bHasReference) {
712 InitPaveBlocks(theI);
713 }
714 //
715 aRef=aSI.Reference();
323c04de 716 return myPaveBlocksPool(aRef);
4e57c75e 717}
718//=======================================================================
719//function : InitPaveBlocks
720//purpose :
721//=======================================================================
722 void BOPDS_DS::InitPaveBlocks(const Standard_Integer theI)
723{
724 Standard_Integer nV, iRef, aNbV, nVSD, i;
725 Standard_Real aT;
726 TopoDS_Vertex aV;
727 BOPCol_ListIteratorOfListOfInteger aIt;
728 BOPDS_Pave aPave;
729 Handle(BOPDS_PaveBlock) aPB;
730 //
731 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
732 const TopoDS_Edge& aE=*(TopoDS_Edge*)(&aSI.Shape());
733 //
734 const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
735 aNbV=aLV.Extent();
736 if (!aNbV) {
737 return;
738 }
739 //
740 aPB=new BOPDS_PaveBlock;
741 aPB->SetOriginalEdge(theI);
742 //
743 aIt.Initialize(aLV);
744 for (i=0; aIt.More(); aIt.Next(), ++i) {
745 nV=aIt.Value();
746 //
747 const BOPDS_ShapeInfo& aSIV=ShapeInfo(nV);
748 aV=*(TopoDS_Vertex*)(&aSIV.Shape());
749 if (aSIV.HasFlag()) {
750 aT=ComputeParameter(aV, aE);
751 }
752 else {
753 aT=BRep_Tool::Parameter(aV, aE);
754 }
755 //
756 if (HasShapeSD(nV, nVSD)) {
757 nV=nVSD;
758 }
759 aPave.SetIndex(nV);
760 aPave.SetParameter(aT);
761 aPB->AppendExtPave(aPave);
762 }
763 //
764 if (aNbV==1) {
765 aV.Reverse();
766 aT=BRep_Tool::Parameter(aV, aE);
767 aPave.SetIndex(nV);
768 aPave.SetParameter(aT);
769 aPB->AppendExtPave1(aPave);
770 }
771 //
323c04de 772 iRef = myPaveBlocksPool.Append() - 1;
4e57c75e 773 BOPDS_ListOfPaveBlock &aLPB=myPaveBlocksPool(iRef);
774 //
775 aPB->Update(aLPB, Standard_False);
4e57c75e 776 aSI.SetReference(iRef);
777}
778//=======================================================================
779//function : UpdatePaveBlocks
780//purpose :
781//=======================================================================
782 void BOPDS_DS::UpdatePaveBlocks()
783{
784 Standard_Boolean bIsToUpdate;
785 Standard_Integer i, aNbPBP;
786 BOPDS_ListOfPaveBlock aLPBN(myAllocator);
787 BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBN;
788 //
789 BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
790 //
791 aNbPBP=aPBP.Size();
792 for (i=0; i<aNbPBP; ++i) {
793 BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
794 //
795 aItPB.Initialize(aLPB);
796 for (; aItPB.More(); aItPB.Next()) {
797 Handle(BOPDS_PaveBlock)& aPB=aItPB.ChangeValue();
798 //
799 bIsToUpdate=aPB->IsToUpdate();
800 if (bIsToUpdate){
801 aLPBN.Clear();
802 aPB->Update(aLPBN);
803
804 aItPBN.Initialize(aLPBN);
805 for (; aItPBN.More(); aItPBN.Next()) {
806 Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
807 aLPB.Append(aPBN);
808 }
809 aLPB.Remove(aItPB);
810 }
811 }// for (; aItPB.More(); aItPB.Next()) {
812 }// for (i=0; i<aNbPBP; ++i) {
813}
814//=======================================================================
815//function : UpdatePaveBlock
816//purpose :
817//=======================================================================
818 void BOPDS_DS::UpdatePaveBlock(const Handle(BOPDS_PaveBlock)& thePB)
819{
820 if (!thePB->IsToUpdate()){
821 return;
822 }
823 //
824 Standard_Integer nE, iRef;
825 BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBN;
826 BOPDS_ListOfPaveBlock aLPBN(myAllocator);
827 Handle(BOPDS_PaveBlock) aPB;
828 //
829 BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
830 //
831 nE=thePB->OriginalEdge();
832 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(nE);
833 iRef=aSI.Reference();
834 BOPDS_ListOfPaveBlock& aLPB=aPBP(iRef);
835 //
836 aItPB.Initialize(aLPB);
837 for (; aItPB.More(); aItPB.Next()) {
838 aPB=aItPB.ChangeValue();
839 if (aPB==thePB) {
840 aPB->Update(aLPBN);
841 //
842 aItPBN.Initialize(aLPBN);
843 for (; aItPBN.More(); aItPBN.Next()) {
844 Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
845 aLPB.Append(aPBN);
846 }
847 aLPB.Remove(aItPB);
848 break;
849 }
850 }
851}
852//=======================================================================
853//function : UpdateCommonBlock
854//purpose :
855//=======================================================================
856 void BOPDS_DS::UpdateCommonBlock(const Handle(BOPDS_CommonBlock)& theCB)
857{
858 Standard_Integer nE, iRef, n1, n2;
859 BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBCB, aItPBN;
860 BOPDS_DataMapIteratorOfDataMapOfPassKeyListOfPaveBlock aItMPKLPB;
861 BOPDS_ListOfPaveBlock aLPBN;
862 BOPDS_DataMapOfPassKeyListOfPaveBlock aMPKLPB;
863 Handle(BOPDS_PaveBlock) aPB;
864 Handle(BOPDS_CommonBlock) aCBx;
865 BOPDS_PassKey aPK;
866 //
867 const BOPDS_ListOfPaveBlock& aLPBCB=theCB->PaveBlocks();
868 if (!aLPBCB.First()->IsToUpdate()){
869 return;
870 }
871 //
872 const BOPCol_ListOfInteger& aLF=theCB->Faces();
873 //
874 BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
875 //
876 aItPBCB.Initialize(aLPBCB);
877 for (; aItPBCB.More(); aItPBCB.Next()) {
878 const Handle(BOPDS_PaveBlock)& aPBCB=aItPBCB.ChangeValue();
879 //
880 nE=aPBCB->OriginalEdge();
881 iRef=ChangeShapeInfo(nE).Reference();
882 BOPDS_ListOfPaveBlock& aLPB=aPBP(iRef);
883 //
884 aItPB.Initialize(aLPB);
885 for (; aItPB.More(); aItPB.Next()) {
886 aPB=aItPB.ChangeValue();
887 if (aPB==aPBCB) {
888 //
889 aLPBN.Clear();
890 aPB->Update(aLPBN);
891 //
892 aItPBN.Initialize(aLPBN);
893 for (; aItPBN.More(); aItPBN.Next()) {
894 Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
895 aLPB.Append(aPBN);
896 //
897 aPBN->Indices(n1, n2);
898 aPK.SetIds(n1, n2);
899 if (aMPKLPB.IsBound(aPK)) {
900 BOPDS_ListOfPaveBlock& aLPBx=aMPKLPB.ChangeFind(aPK);
901 aLPBx.Append(aPBN);
902 }
903 else {
904 BOPDS_ListOfPaveBlock aLPBx;
905 aLPBx.Append(aPBN);
906 aMPKLPB.Bind(aPK, aLPBx);
907 }
908 }
909 aLPB.Remove(aItPB);
910 break;
911 }
912 }
913 }
914 //
915 aItMPKLPB.Initialize(aMPKLPB);
916 for (; aItMPKLPB.More(); aItMPKLPB.Next()) {
917 BOPDS_ListOfPaveBlock& aLPBx=aItMPKLPB.ChangeValue();
918 //
919 while (aLPBx.Extent()) {
920 Standard_Boolean bCoinside;
921 Standard_Real aTol, aTolMax(0.);
922 BOPDS_ListOfPaveBlock aLPBxN;
923 //
924 aItPB.Initialize(aLPBx);
925 for(; aItPB.More(); ) {
926 const Handle(BOPDS_PaveBlock)& aPBx=aItPB.Value();
927 if (aLPBxN.Extent()) {
928 const Handle(BOPDS_PaveBlock)& aPBCx = aLPBxN.First();
929 bCoinside = CheckCoincidence(aPBx, aPBCx);
930 if (bCoinside) {
931 nE = aPBx->OriginalEdge();
932 const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
933 aTol = BRep_Tool::Tolerance(aE);
934 //
935 //pave block with the max tolerance of the original edge
936 //must be the first in the common block
937 if (aTolMax < aTol) {
938 aTolMax = aTol;
939 aLPBxN.Prepend(aPBx);
940 } else {
941 aLPBxN.Append(aPBx);
942 }
943 aLPBx.Remove(aItPB);
944 continue;
945 }//if (bCoinside) {
946 }//if (aLPBxN.Extent()) {
947 else {
948 nE = aPBx->OriginalEdge();
949 const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
950 aTolMax = BRep_Tool::Tolerance(aE);
951 //
952 aLPBxN.Append(aPBx);
953 aLPBx.Remove(aItPB);
954 continue;
955 }
956 aItPB.Next();
957 }//for(; aItPB.More(); ) {
958 //
959 aCBx=new BOPDS_CommonBlock;
960 aCBx->AddPaveBlocks(aLPBxN);
961 aCBx->AddFaces(aLF);
962 //
963 aItPB.Initialize(aLPBxN);
964 for (; aItPB.More(); aItPB.Next()) {
965 aPB=aItPB.ChangeValue();
966 aPB->SetCommonBlock(aCBx);
967 }
968 }
969 }
970}
971//
972// FaceInfo
973//
974
975//=======================================================================
976//function : FaceInfoPool
977//purpose :
978//=======================================================================
979 const BOPDS_VectorOfFaceInfo& BOPDS_DS::FaceInfoPool()const
980{
981 return myFaceInfoPool;
982}
983//=======================================================================
984//function : HasFaceInfo
985//purpose :
986//=======================================================================
987 Standard_Boolean BOPDS_DS::HasFaceInfo(const Standard_Integer theI)const
988{
989 return ShapeInfo(theI).HasReference();
990}
991//=======================================================================
992//function : FaceInfo
993//purpose :
994//=======================================================================
995 const BOPDS_FaceInfo& BOPDS_DS::FaceInfo(const Standard_Integer theI)const
996{
997 static BOPDS_FaceInfo sFI;
998 Standard_Integer aRef;
999 //
1000 if (HasFaceInfo(theI)) {
1001 aRef=ShapeInfo(theI).Reference();
1002 const BOPDS_FaceInfo& aFI=myFaceInfoPool(aRef);
1003 return aFI;
1004 }
1005 return sFI;
1006}
1007//=======================================================================
1008//function : ChangeFaceInfo
1009//purpose :
1010//=======================================================================
1011 BOPDS_FaceInfo& BOPDS_DS::ChangeFaceInfo(const Standard_Integer theI)
1012{
1013 Standard_Boolean bHasReference;
1014 Standard_Integer aRef;
1015 BOPDS_FaceInfo* pFI;
1016 //
1017 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1018 bHasReference=aSI.HasReference();
1019 if (!bHasReference) {
1020 InitFaceInfo(theI);
1021 }
1022 //
1023 aRef=aSI.Reference();
1024 const BOPDS_FaceInfo& aFI=myFaceInfoPool(aRef);
1025 pFI=(BOPDS_FaceInfo*)&aFI;
1026 return *pFI;
1027}
1028//=======================================================================
1029//function : InitFaceInfo
1030//purpose :
1031//=======================================================================
1032 void BOPDS_DS::InitFaceInfo(const Standard_Integer theI)
1033{
1034 Standard_Integer iRef;
1035 //
1036 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1037 iRef=myFaceInfoPool.Append()-1;
1038 BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
1039 aSI.SetReference(iRef);
1040 //
1041 aFI.SetIndex(theI);
1042 UpdateFaceInfoIn(theI);
1043 UpdateFaceInfoOn(theI);
1044}
1045//=======================================================================
1046//function : UpdateFaceInfoIn
1047//purpose :
1048//=======================================================================
1049 void BOPDS_DS::UpdateFaceInfoIn(const Standard_Integer theI)
1050{
1051 Standard_Integer iRef;
1052 //
1053 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1054 if (aSI.HasReference()) {
1055 iRef=aSI.Reference();
1056 BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
1057 //
1058 BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.ChangePaveBlocksIn();
1059 BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
1060 aMPBIn.Clear();
1061 aMVIn.Clear();
1062 FaceInfoIn(theI, aMPBIn, aMVIn);
1063 }
1064}
1065//=======================================================================
1066//function : UpdateFaceInfoOn
1067//purpose :
1068//=======================================================================
1069 void BOPDS_DS::UpdateFaceInfoOn(const Standard_Integer theI)
1070{
1071 Standard_Integer iRef;
1072 //
1073 BOPDS_ShapeInfo& aSI=ChangeShapeInfo(theI);
1074 if (aSI.HasReference()) {
1075 iRef=aSI.Reference();
1076 BOPDS_FaceInfo &aFI=myFaceInfoPool(iRef);
1077 //
1078 BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.ChangePaveBlocksOn();
1079 BOPCol_MapOfInteger& aMVOn=aFI.ChangeVerticesOn();
1080 aMPBOn.Clear();
1081 aMVOn.Clear();
1082 FaceInfoOn(theI, aMPBOn, aMVOn);
1083 }
1084}
1085//=======================================================================
1086//function : FaceInfoOn
1087//purpose :
1088//=======================================================================
1089 void BOPDS_DS::FaceInfoOn(const Standard_Integer theF,
1090 BOPDS_IndexedMapOfPaveBlock& theMPB,
1091 BOPCol_MapOfInteger& theMI)
1092{
1093 Standard_Integer nS, nSD, nV1, nV2;
1094 BOPCol_ListIteratorOfListOfInteger aIt;
1095 BOPDS_ListIteratorOfListOfPaveBlock aItPB;
1096 //
1097 const BOPDS_ShapeInfo& aSI=ShapeInfo(theF);
1098 const BOPCol_ListOfInteger& aLI=aSI.SubShapes();
1099 aIt.Initialize(aLI);
1100 for (; aIt.More(); aIt.Next()) {
1101 nS=aIt.Value();
1102 const BOPDS_ShapeInfo& aSIE=ShapeInfo(nS);
1103 if (aSIE.ShapeType()==TopAbs_EDGE) {
1104 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nS);
1105 aItPB.Initialize(aLPB);
1106 for (; aItPB.More(); aItPB.Next()) {
1107 const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
1108 aPB->Indices(nV1, nV2);
1109 theMI.Add(nV1);
1110 theMI.Add(nV2);
1111 if (aPB->IsCommonBlock()) {
1112 const Handle(BOPDS_CommonBlock)& aCB=aPB->CommonBlock();
1113 const Handle(BOPDS_PaveBlock)& aPB1=aCB->PaveBlock1();
1114 theMPB.Add(aPB1);
1115 }
1116 else {
1117 theMPB.Add(aPB);
1118 }
1119 }
1120 }//if (aSIE.ShapeType()==TopAbs_EDGE)
1121 else {
1122 // nE is TopAbs_VERTEX
1123 if (HasShapeSD(nS, nSD)) {
1124 nS=nSD;
1125 }
1126 theMI.Add(nS);
1127 }
1128 }
1129}
1130//=======================================================================
1131//function : FaceInfoIn
1132//purpose :
1133//=======================================================================
1134 void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
1135 BOPDS_IndexedMapOfPaveBlock& theMPB,
1136 BOPCol_MapOfInteger& theMI)
1137{
1138 Standard_Integer i, aNbVF, aNbEF, nV, nE;
1139 BOPDS_ListIteratorOfListOfPaveBlock aItPB;
1140 //
1141 BOPDS_VectorOfInterfVF& aVFs=InterfVF();
1142 aNbVF=aVFs.Extent();
1143 for (i=0; i<aNbVF; ++i) {
1144 BOPDS_InterfVF& aVF=aVFs(i);
1145 if(aVF.Contains(theF)) {
1146 nV=aVF.OppositeIndex(theF);
1147 theMI.Add(nV);
1148 }
1149 }
1150 //
1151 BOPDS_VectorOfInterfEF& aEFs=InterfEF();
1152 aNbEF=aEFs.Extent();
1153 for (i=0; i<aNbEF; ++i) {
1154 BOPDS_InterfEF& aEF=aEFs(i);
1155 if(aEF.Contains(theF)) {
1156 if(aEF.HasIndexNew(nV)) {
1157 theMI.Add(nV);
1158 }
1159 else {
1160 nE=aEF.OppositeIndex(theF);
1161 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nE);
1162 aItPB.Initialize(aLPB);
1163 for (; aItPB.More(); aItPB.Next()) {
1164 const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
1165 if (aPB->IsCommonBlock()) {
1166 const Handle(BOPDS_CommonBlock)& aCB=aPB->CommonBlock();
1167 if (aCB->Contains(theF)) {
1168 const Handle(BOPDS_PaveBlock)& aPB1=aCB->PaveBlock1();
1169 theMPB.Add(aPB1);
1170 }
1171 }
1172 }// for (; aItPB.More(); aItPB.Next()) {
1173 }// else {
1174 }// if(aEF.Contains(theF)) {
1175 }// for (i=0; i<aNbEF; ++i) {
1176}
1177
1178//=======================================================================
1179//function : RefineFaceInfoOn
1180//purpose :
1181//=======================================================================
1182 void BOPDS_DS::RefineFaceInfoOn()
1183{
1184 Standard_Integer i, aNb, nF, aNbPB, j;
1185 BOPDS_IndexedMapOfPaveBlock aMPB;
1186 //
1187 aNb=myFaceInfoPool.Extent();
1188 for (i=0; i<aNb; ++i) {
1189 BOPDS_FaceInfo &aFI=myFaceInfoPool(i);
1190 nF=aFI.Index();
1191 UpdateFaceInfoOn(nF);
1192 BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.ChangePaveBlocksOn();
1193 //
1194 aMPB.Clear();
1195 aMPB.Assign(aMPBOn);
1196 aMPBOn.Clear();
1197 //
1198 aNbPB=aMPB.Extent();
1199 for (j=1; j<=aNbPB; ++j) {
1200 const Handle(BOPDS_PaveBlock)& aPB=aMPB(j);
1201 if (aPB->HasEdge()) {
1202 aMPBOn.Add(aPB);
1203 }
1204 }
1205 }
1206}
1207//=======================================================================
1208//function : AloneVertices
1209//purpose :
1210//=======================================================================
1211 void BOPDS_DS::AloneVertices(const Standard_Integer theI,
1212 BOPCol_ListOfInteger& theLI)const
1213{
1214 if (HasFaceInfo(theI)) {
1215 //
1216 Standard_Integer i, nV1, nV2, nV;
1217 BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
1218 BOPCol_MapIteratorOfMapOfInteger aItMI;
1219 //
1220 BOPCol_MapOfInteger aMI(100, myAllocator);
1221 //
1222 const BOPDS_FaceInfo& aFI=FaceInfo(theI);
1223 //
1224 for (i=0; i<2; ++i) {
1225 const BOPDS_IndexedMapOfPaveBlock& aMPB=(!i) ? aFI.PaveBlocksIn() : aFI.PaveBlocksSc();
1226 aItMPB.Initialize(aMPB);
1227 for (; aItMPB.More(); aItMPB.Next()) {
1228 const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
1229 aPB->Indices(nV1, nV2);
1230 aMI.Add(nV1);
1231 aMI.Add(nV2);
1232 }
1233 }
1234 //
1235 for (i=0; i<2; ++i) {
1236 const BOPCol_MapOfInteger& aMIV=(!i) ? aFI.VerticesIn() : aFI.VerticesSc();
1237 aItMI.Initialize(aMIV);
1238 for (; aItMI.More(); aItMI.Next()) {
1239 nV=aItMI.Value();
1240 if (nV>0) {
1241 if (aMI.Add(nV)) {
1242 theLI.Append(nV);
1243 }
1244 }
1245 }
1246 }
1247 }
1248}
1249
1250//=======================================================================
1251//function : VerticesOnIn
1252//purpose :
1253//=======================================================================
1254 void BOPDS_DS::VerticesOnIn(const Standard_Integer nF1,
1255 const Standard_Integer nF2,
1256 BOPCol_MapOfInteger& aMI,
1257 BOPDS_MapOfPaveBlock& aMPB)const
1258{
1259 Standard_Integer nV, nV1, nV2;
1260 BOPCol_MapIteratorOfMapOfInteger aIt;
1261 BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
1262 //
1263 const BOPDS_FaceInfo& aFI1=FaceInfo(nF1);
1264 const BOPDS_FaceInfo& aFI2=FaceInfo(nF2);
1265 //
1266 const BOPDS_IndexedMapOfPaveBlock& aMPBOn1=aFI1.PaveBlocksOn();
1267 aItMPB.Initialize(aMPBOn1);
1268 for (; aItMPB.More(); aItMPB.Next()) {
1269 const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
1270 aMPB.Add(aPB);
1271 aPB->Indices(nV1, nV2);
1272 aMI.Add(nV1);
1273 aMI.Add(nV2);
1274 }
1275 //
1276 const BOPDS_IndexedMapOfPaveBlock& aMPBIn1=aFI1.PaveBlocksIn();
1277 aItMPB.Initialize(aMPBIn1);
1278 for (; aItMPB.More(); aItMPB.Next()) {
1279 const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
1280 aMPB.Add(aPB);
1281 aPB->Indices(nV1, nV2);
1282 aMI.Add(nV1);
1283 aMI.Add(nV2);
1284 }
1285 //
1286 const BOPDS_IndexedMapOfPaveBlock& aMPBOn2=aFI2.PaveBlocksOn();
1287 aItMPB.Initialize(aMPBOn2);
1288 for (; aItMPB.More(); aItMPB.Next()) {
1289 const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
1290 aMPB.Add(aPB);
1291 aPB->Indices(nV1, nV2);
1292 aMI.Add(nV1);
1293 aMI.Add(nV2);
1294 }
1295 //
1296 const BOPDS_IndexedMapOfPaveBlock& aMPBIn2=aFI2.PaveBlocksIn();
1297 aItMPB.Initialize(aMPBIn2);
1298 for (; aItMPB.More(); aItMPB.Next()) {
1299 const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
1300 aMPB.Add(aPB);
1301 aPB->Indices(nV1, nV2);
1302 aMI.Add(nV1);
1303 aMI.Add(nV2);
1304 }
1305 //
1306 const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
1307 aIt.Initialize(aMVOn1);
1308 for (; aIt.More(); aIt.Next()) {
1309 nV=aIt.Value();
1310 aMI.Add(nV);
1311 }
1312 //
1313 const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
1314 aIt.Initialize(aMVOn1);
1315 for (; aIt.More(); aIt.Next()) {
1316 nV=aIt.Value();
1317 aMI.Add(nV);
1318 }
1319 //
1320 const BOPCol_MapOfInteger& aMVOn2=aFI2.VerticesOn();
1321 aIt.Initialize(aMVOn2);
1322 for (; aIt.More(); aIt.Next()) {
1323 nV=aIt.Value();
1324 aMI.Add(nV);
1325 }
1326 //
1327 const BOPCol_MapOfInteger& aMVIn2=aFI2.VerticesIn();
1328 aIt.Initialize(aMVOn1);
1329 for (; aIt.More(); aIt.Next()) {
1330 nV=aIt.Value();
1331 aMI.Add(nV);
1332 }
1333}
1334//=======================================================================
1335//function : SharedEdges
1336//purpose :
1337//=======================================================================
1338 void BOPDS_DS::SharedEdges(const Standard_Integer nF1,
1339 const Standard_Integer nF2,
1340 BOPCol_ListOfInteger& theLI,
1341 const Handle(NCollection_BaseAllocator)& aAllocator)
1342{
1343 Standard_Integer nE, nSp;
1344 BOPCol_ListIteratorOfListOfInteger aItLI;
1345 BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
1346 BOPCol_MapOfInteger aMI(100, aAllocator);
1347 //
1348 const BOPDS_ShapeInfo& aSI1=ShapeInfo(nF1);
1349 const BOPCol_ListOfInteger& aLI1=aSI1.SubShapes();
1350 aItLI.Initialize(aLI1);
1351 for (; aItLI.More(); aItLI.Next()) {
1352 nE=aItLI.Value();
1353 const BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
1354 if(aSIE.ShapeType()==TopAbs_EDGE) {
1355 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nE);
1356 if (aLPB.IsEmpty()) {
1357 aMI.Add(nE);
1358 }
1359 else {
1360 aItLPB.Initialize(aLPB);
1361 for (; aItLPB.More(); aItLPB.Next()) {
323c04de 1362 const Handle(BOPDS_PaveBlock) aPB=aItLPB.Value()->RealPaveBlock();
4e57c75e 1363 nSp=aPB->Edge();
1364 aMI.Add(nSp);
1365 }
1366 }
1367 }
1368 }
1369 //
1370 const BOPDS_ShapeInfo& aSI2=ShapeInfo(nF2);
1371 const BOPCol_ListOfInteger& aLI2=aSI2.SubShapes();
1372 aItLI.Initialize(aLI2);
1373 for (; aItLI.More(); aItLI.Next()) {
1374 nE=aItLI.Value();
1375 const BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
1376 if(aSIE.ShapeType()==TopAbs_EDGE) {
1377 const BOPDS_ListOfPaveBlock& aLPB=PaveBlocks(nE);
1378 if (aLPB.IsEmpty()) {
1379 if (aMI.Contains(nE)) {
1380 theLI.Append(nE);
1381 }
1382 }
1383 else {
1384 aItLPB.Initialize(aLPB);
1385 for (; aItLPB.More(); aItLPB.Next()) {
323c04de 1386 const Handle(BOPDS_PaveBlock) aPB=aItLPB.Value()->RealPaveBlock();
4e57c75e 1387 nSp=aPB->Edge();
1388 if (aMI.Contains(nSp)) {
1389 theLI.Append(nSp);
1390 }
1391 }
1392 }
1393 }
1394 }
1395}
1396
1397//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1398//
1399// same domain shapes
1400//
1401//=======================================================================
1402//function : ShapesSD
1403//purpose :
1404//=======================================================================
1405 BOPCol_DataMapOfIntegerInteger& BOPDS_DS::ShapesSD()
1406{
1407 return myShapesSD;
1408}
1409//=======================================================================
1410//function : AddShapeSD
1411//purpose :
1412//=======================================================================
1413 void BOPDS_DS::AddShapeSD(const Standard_Integer theIndex,
1414 const Standard_Integer theIndexSD)
1415{
1416 myShapesSD.Bind(theIndex, theIndexSD);
1417}
1418//=======================================================================
1419//function : HasShapeSD
1420//purpose :
1421//=======================================================================
1422 Standard_Boolean BOPDS_DS::HasShapeSD(const Standard_Integer theIndex,
1423 Standard_Integer& theIndexSD)const
1424{
1425 Standard_Boolean bRet;
1426 //
1427 bRet=myShapesSD.IsBound(theIndex);
1428 if (bRet) {
1429 theIndexSD=myShapesSD.Find(theIndex);
1430 }
1431 return bRet;
1432}
1433//=======================================================================
1434//function : Dump
1435//purpose :
1436//=======================================================================
1437 void BOPDS_DS::Dump()const
1438{
1439 Standard_Integer i, aNb, aNbSS;
1440 //
1441 printf(" *** DS ***\n");
1442 aNb=NbRanges();
1443 printf(" Ranges:%d\n", aNb);
1444 for (i=0; i<aNb; ++i) {
1445 const BOPDS_IndexRange& aR=Range(i);
1446 aR.Dump();
1447 printf("\n");
1448 }
1449 //
1450 aNbSS=NbSourceShapes();
1451 printf(" Shapes:%d\n", aNbSS);
1452 aNb=NbShapes();
1453 for (i=0; i<aNb; ++i) {
1454 const BOPDS_ShapeInfo& aSI=ShapeInfo(i);
1455 printf(" %d :", i);
1456 aSI.Dump();
1457 printf("\n");
1458 if (i==aNbSS-1) {
1459 printf(" ****** adds\n");
1460 }
1461 }
1462 printf(" ******\n");
1463}
1464
1465//=======================================================================
1466// function: CheckCoincidence
1467// purpose:
1468//=======================================================================
1469 Standard_Boolean BOPDS_DS::CheckCoincidence(const Handle(BOPDS_PaveBlock)& aPB1,
1470 const Handle(BOPDS_PaveBlock)& aPB2)
1471{
1472 Standard_Boolean bRet;
1473 Standard_Integer nE1, nE2, aNbPoints;
1474 Standard_Real aT11, aT12, aT21, aT22, aT1m, aD, aTol, aT2x;
1475 gp_Pnt aP1m;
1476 //
1477 bRet=Standard_False;
1478 //
1479 aPB1->Range(aT11, aT12);
1480 aT1m=IntTools_Tools::IntermediatePoint (aT11, aT12);
1481 nE1=aPB1->OriginalEdge();
1482 const TopoDS_Edge& aE1=(*(TopoDS_Edge*)(&Shape(nE1)));
1483 BOPTools_AlgoTools::PointOnEdge(aE1, aT1m, aP1m);
1484 //
1485 aPB2->Range(aT21, aT22);
1486 nE2=aPB2->OriginalEdge();
1487 const TopoDS_Edge& aE2=(*(TopoDS_Edge*)(&Shape(nE2)));
1488 //
1489 Standard_Real f, l;
1490 Handle(Geom_Curve)aC2 = BRep_Tool::Curve (aE2, f, l);
1491 GeomAPI_ProjectPointOnCurve aPPC;
1492 aPPC.Init(aC2, f, l);
1493 aPPC.Perform(aP1m);
1494 aNbPoints=aPPC.NbPoints();
1495 if (aNbPoints) {
1496 aD=aPPC.LowerDistance();
1497 //
1498 aTol=BRep_Tool::Tolerance(aE1);
1499 aTol=aTol+BRep_Tool::Tolerance(aE2);
1500 if (aD<aTol) {
1501 aT2x=aPPC.LowerDistanceParameter();
1502 if (aT2x>aT21 && aT2x<aT22) {
1503 return !bRet;
1504 }
1505 }
1506 }
1507 return bRet;
1508}
1509
1510//=======================================================================
1511// function: SortPaveBlocks
1512// purpose:
1513//=======================================================================
1514 void BOPDS_DS::SortPaveBlocks(const Handle(BOPDS_CommonBlock)& aCB)
1515{
1516 Standard_Integer theI;
1517 Standard_Boolean bToSort;
1518 bToSort = IsToSort(aCB, theI);
1519 if (!bToSort) {
1520 return;
1521 }
1522
1523 Standard_Integer i(0);
1524 const BOPDS_ListOfPaveBlock& aLPB = aCB->PaveBlocks();
1525 BOPDS_ListOfPaveBlock aLPBN = aLPB;
1526
1527 Handle(BOPDS_PaveBlock) aPB;
1528 BOPDS_ListIteratorOfListOfPaveBlock aIt;
1529 //
1530 aIt.Initialize(aLPBN);
1531 for (aIt.Next(); aIt.More(); ) {
1532 i++;
1533 if(i == theI) {
1534 aPB = aIt.Value();
1535 aLPBN.Remove(aIt);
1536 aLPBN.Prepend(aPB);
1537 break;
1538 }
1539 aIt.Next();
1540 }
1541 //
1542 aCB->AddPaveBlocks(aLPBN);
1543}
1544
1545//=======================================================================
1546// function: IsToSort
1547// purpose:
1548//=======================================================================
1549 Standard_Boolean BOPDS_DS::IsToSort(const Handle(BOPDS_CommonBlock)& aCB,
1550 Standard_Integer& theI)
1551{
1552 Standard_Boolean bRet;
1553 bRet = Standard_False;
1554 const BOPDS_ListOfPaveBlock& aLPB = aCB->PaveBlocks();
1555 if (aLPB.Extent()==1) {
1556 return bRet;
1557 }
1558
1559 Standard_Integer nE;
1560 Standard_Real aTolMax, aTol;
1561 Handle(BOPDS_PaveBlock) aPB;
1562 TopoDS_Edge aE;
1563 BOPDS_ListIteratorOfListOfPaveBlock aIt;
1564 //
1565 aPB = aLPB.First();
1566 nE = aPB->OriginalEdge();
1567 aE = (*(TopoDS_Edge *)(&Shape(nE)));
1568 aTolMax = BRep_Tool::Tolerance(aE);
1569 //
1570 theI = 0;
1571 aIt.Initialize(aLPB);
1572 for (aIt.Next(); aIt.More(); aIt.Next()) {
1573 theI++;
1574 aPB = aIt.Value();
1575 nE = aPB->OriginalEdge();
1576 aE = (*(TopoDS_Edge *)(&Shape(nE)));
1577 aTol = BRep_Tool::Tolerance(aE);
1578 if (aTolMax < aTol) {
1579 aTolMax = aTol;
1580 bRet = Standard_True;
1581 }
1582 }
1583
1584 return bRet;
1585}
1586
1587//=======================================================================
1588// function: IsSubShape
1589// purpose:
1590//=======================================================================
1591 Standard_Boolean BOPDS_DS::IsSubShape(const Standard_Integer theI1,
1592 const Standard_Integer theI2)
1593{
1594 Standard_Boolean bRet;
1595 Standard_Integer nS;
1596 bRet = Standard_False;
1597 //
1598 BOPCol_ListIteratorOfListOfInteger aItLI;
1599 //
1600 const BOPDS_ShapeInfo& aSI = ShapeInfo(theI2);
1601 const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
1602 aItLI.Initialize(aLI);
1603 for(;aItLI.More(); aItLI.Next()) {
1604 nS = aItLI.Value();
1605 if (nS == theI1) {
1606 bRet = Standard_True;
1607 break;
1608 }
1609 }
1610
1611 return bRet;
1612}
1613
1614//=======================================================================
1615// function: Paves
1616// purpose:
1617//=======================================================================
1618 void BOPDS_DS::Paves(const Standard_Integer theEdge,
1619 BOPDS_ListOfPave& theLP)
1620{
1621 Standard_Integer aNb, i;
1622 BOPDS_Pave *pPaves;
1623 BOPDS_ListIteratorOfListOfPaveBlock aIt;
1624 BOPDS_MapOfPave aMP;
1625 //
1626 const BOPDS_ListOfPaveBlock& aLPB = PaveBlocks(theEdge);
1627 aNb = aLPB.Extent();
1628 aNb = (aNb==0) ? 0 : (aNb+1);
1629 //
1630 pPaves=(BOPDS_Pave *)myAllocator->Allocate(aNb*sizeof(BOPDS_Pave));
1631 for (i=0; i<aNb; ++i) {
1632 new (pPaves+i) BOPDS_Pave();
1633 }
1634 //
1635 i = 0;
1636 for (aIt.Initialize(aLPB); aIt.More(); aIt.Next()) {
1637 const Handle(BOPDS_PaveBlock)& aPB = aIt.Value();
1638 if (aMP.Add(aPB->Pave1())){
1639 pPaves[i] = aPB->Pave1();
1640 ++i;
1641 }
1642 if (aMP.Add(aPB->Pave2())){
1643 pPaves[i] = aPB->Pave2();
1644 ++i;
1645 }
1646 }
1647 //
1648 SortShell(aNb, pPaves);
1649 //
1650 for (i = 0; i < aNb; ++i) {
1651 theLP.Append(pPaves[i]);
1652 }
1653}
1654
1655//=======================================================================
1656// function: UpdateTolerance
1657// purpose:
1658//=======================================================================
1659 void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
1660 const Standard_Real aTol)
1661{
1662 Standard_Integer nV;
1663 Standard_Real aTolV;
1664 BRep_Builder aBB;
1665 BOPCol_ListIteratorOfListOfInteger aIt;
1666 //
1667 const TopoDS_Edge& aE = *(TopoDS_Edge*)&Shape(nE);
1668 aBB.UpdateEdge(aE, aTol);
1669 BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
1670 Bnd_Box& aBoxE=aSIE.ChangeBox();
1671 BRepBndLib::Add(aE, aBoxE);
1672 //
1673 const BOPCol_ListOfInteger& aLI = aSIE.SubShapes();
1674 aIt.Initialize(aLI);
1675 for (; aIt.More(); aIt.Next()) {
1676 nV = aIt.Value();
1677 const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&Shape(nV);
1678 aTolV = BRep_Tool::Tolerance(aV);
1679 if (aTolV < aTol) {
1680 aBB.UpdateVertex(aV, aTol);
1681 BOPDS_ShapeInfo& aSIV = ChangeShapeInfo(nV);
1682 Bnd_Box& aBoxV = aSIV.ChangeBox();
1683 BRepBndLib::Add(aV, aBoxV);
1684 }
1685 }
1686}
1687
1688//=======================================================================
1689//function : TotalShapes
1690//purpose :
1691//=======================================================================
1692void TotalShapes(const TopoDS_Shape& aS,
1693 Standard_Integer& aNbS)
1694{
1695 TopoDS_Shape *pS;
1696 //
1697 pS=(TopoDS_Shape *)&aS;
1698 if (!pS->Checked()) {
1699 TopoDS_Iterator aIt;
1700 //
1701 pS->Checked(1);
1702 ++aNbS;
1703 aIt.Initialize(aS);
1704 for (; aIt.More(); aIt.Next()) {
1705 const TopoDS_Shape& aSx=aIt.Value();
1706 TotalShapes(aSx, aNbS);
1707 }
1708 }
1709}
1710//=======================================================================
1711//function : ResetShape
1712//purpose :
1713//=======================================================================
1714void ResetShape(const TopoDS_Shape& aS)
1715{
1716 TopoDS_Shape *pS;
1717 //
1718 pS=(TopoDS_Shape *)&aS;
1719 pS->Checked(0);
1720}
1721//=======================================================================
1722//function : ResetShape
1723//purpose :
1724//=======================================================================
1725void ResetShapes(const TopoDS_Shape& aS)
1726{
1727 TopoDS_Iterator aIt;
1728 //
1729 ResetShape(aS);
1730 aIt.Initialize(aS);
1731 for (; aIt.More(); aIt.Next()) {
1732 const TopoDS_Shape& aSx=aIt.Value();
1733 ResetShape(aSx);
1734 }
1735}
1736#include <Geom_Curve.hxx>
1737
1738//=======================================================================
1739//function : ComputeParameter
1740//purpose :
1741//=======================================================================
1742Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
1743 const TopoDS_Edge& aE)
1744{
1745 Standard_Real aT1, aT2, aTRet, aTolE2, aD2;
1746 gp_Pnt aPC, aPV;
1747 Handle(Geom_Curve) aC3D;
1748 TopoDS_Edge aEE;
1749 //
1750 aEE=aE;
1751 aEE.Orientation(TopAbs_FORWARD);
1752 //
1753 aTRet=0.;
1754 //
1755 aTolE2=BRep_Tool::Tolerance(aE);
1756 aTolE2=aTolE2*aTolE2;
1757 //
1758 aPV=BRep_Tool::Pnt(aV);
1759 //
1760 aC3D=BRep_Tool::Curve (aEE, aT1, aT2);
1761 //
1762 aC3D->D0(aT1, aPC);
1763 aD2=aPC.SquareDistance(aPV);
1764 if (aD2<aTolE2) {
1765 aTRet=aT1;
1766 }
1767 //
1768 aC3D->D0(aT2, aPC);
1769 aD2=aPC.SquareDistance(aPV);
1770 if (aD2<aTolE2) {
1771 aTRet=aT2;
1772 }
1773 //
1774 return aTRet;
1775}
1776//=======================================================================
1777// function: SortShell
1778// purpose :
1779//=======================================================================
1780void SortShell(const int n, BOPDS_Pave *a)
1781{
1782 int nd, i, j, l, d=1;
1783 BOPDS_Pave x;
1784 //
1785 while(d<=n) {
1786 d*=2;
1787 }
1788 //
1789 while (d) {
1790 d=(d-1)/2;
1791 //
1792 nd=n-d;
1793 for (i=0; i<nd; ++i) {
1794 j=i;
1795 m30:;
1796 l=j+d;
1797 if (a[l] < a[j]){
1798 x=a[j];
1799 a[j]=a[l];
1800 a[l]=x;
1801 j-=d;
1802 if (j > -1) goto m30;
1803 }//if (a[l] < a[j]){
1804 }//for (i=0; i<nd; ++i)
1805 }//while (1)
1806}