projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0026560: BRepBndLib build too large bounding box in Z direction for planar spline...
[occt.git] / src / BOPAlgo / BOPAlgo_PaveFiller_6.cxx
CommitLineData
4e57c75e 1// Created by: Peter KURNEV
973c2be1 2// Copyright (c) 2010-2014 OPEN CASCADE SAS
4e57c75e 3// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
4// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
5// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6//
973c2be1 7// This file is part of Open CASCADE Technology software library.
4e57c75e 8//
d5f74e42 9// This library is free software; you can redistribute it and/or modify it under
10// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 11// by the Free Software Foundation, with special exception defined in the file
12// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
13// distribution for complete text of the license and disclaimer of any warranty.
4e57c75e 14//
973c2be1 15// Alternatively, this file may be used under the terms of Open CASCADE
16// commercial license or contractual agreement.
4e57c75e 17
42cf5bc1 18#include <Bnd_Box.hxx>
19#include <BOPAlgo_PaveFiller.hxx>
20#include <BOPAlgo_SectionAttribute.hxx>
21#include <BOPAlgo_Tools.hxx>
22#include <BOPCol_DataMapOfIntegerReal.hxx>
4e57c75e 23#include <BOPCol_DataMapOfShapeInteger.hxx>
42cf5bc1 24#include <BOPCol_ListOfInteger.hxx>
25#include <BOPCol_ListOfShape.hxx>
26#include <BOPCol_MapOfInteger.hxx>
a2098360 27#include <BOPCol_NCVector.hxx>
c7b59798 28#include <BOPCol_Parallel.hxx>
42cf5bc1 29#include <BOPDS_CommonBlock.hxx>
30#include <BOPDS_CoupleOfPaveBlocks.hxx>
4e57c75e 31#include <BOPDS_Curve.hxx>
42cf5bc1 32#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
33#include <BOPDS_DS.hxx>
4e57c75e 34#include <BOPDS_FaceInfo.hxx>
42cf5bc1 35#include <BOPDS_Interf.hxx>
36#include <BOPDS_Iterator.hxx>
37#include <BOPDS_ListOfPave.hxx>
38#include <BOPDS_ListOfPaveBlock.hxx>
4e57c75e 39#include <BOPDS_MapOfPaveBlock.hxx>
40#include <BOPDS_PaveBlock.hxx>
42cf5bc1 41#include <BOPDS_Point.hxx>
42#include <BOPDS_ShapeInfo.hxx>
4e57c75e 43#include <BOPDS_VectorOfCurve.hxx>
44#include <BOPDS_VectorOfPoint.hxx>
42cf5bc1 45#include <BOPTools_AlgoTools.hxx>
46#include <BOPTools_AlgoTools3D.hxx>
47#include <BRep_Builder.hxx>
48#include <BRep_Tool.hxx>
49#include <BRepAdaptor_Curve.hxx>
50#include <BRepAdaptor_Surface.hxx>
51#include <BRepBndLib.hxx>
52#include <BRepBuilderAPI_MakeVertex.hxx>
53#include <BRepTools.hxx>
54#include <Geom2d_Curve.hxx>
55#include <Geom_Curve.hxx>
56#include <GeomAPI_ProjectPointOnCurve.hxx>
57#include <GeomAPI_ProjectPointOnSurf.hxx>
58#include <gp_Pnt.hxx>
59#include <IntSurf_ListOfPntOn2S.hxx>
60#include <IntSurf_PntOn2S.hxx>
61#include <IntTools_Context.hxx>
62#include <IntTools_Curve.hxx>
63#include <IntTools_EdgeFace.hxx>
64#include <IntTools_FaceFace.hxx>
65#include <IntTools_PntOn2Faces.hxx>
66#include <IntTools_SequenceOfCurves.hxx>
67#include <IntTools_SequenceOfPntOn2Faces.hxx>
68#include <IntTools_ShrunkRange.hxx>
69#include <IntTools_Tools.hxx>
42cf5bc1 70#include <Precision.hxx>
71#include <TopExp.hxx>
72#include <TopExp_Explorer.hxx>
73#include <TopoDS_Compound.hxx>
74#include <TopoDS_Edge.hxx>
75#include <TopoDS_Face.hxx>
76#include <TopoDS_Vertex.hxx>
4e57c75e 77
42cf5bc1 78//
b4109929 79static void ToleranceFF(const BRepAdaptor_Surface& aBAS1,
80 const BRepAdaptor_Surface& aBAS2,
4e57c75e 81 Standard_Real& aTolFF);
82
a2098360 83/////////////////////////////////////////////////////////////////////////
84//=======================================================================
85//class : BOPAlgo_FaceFace
86//purpose :
87//=======================================================================
36f4947b 88class BOPAlgo_FaceFace :
89 public IntTools_FaceFace,
90 public BOPAlgo_Algo {
91
a2098360 92 public:
36f4947b 93 DEFINE_STANDARD_ALLOC
94
95 BOPAlgo_FaceFace() :
96 IntTools_FaceFace(),
97 BOPAlgo_Algo(),
98 myIF1(-1), myIF2(-1), myTolFF(1.e-7) {
a2098360 99 }
100 //
36f4947b 101 virtual ~BOPAlgo_FaceFace() {
a2098360 102 }
103 //
104 void SetIndices(const Standard_Integer nF1,
105 const Standard_Integer nF2) {
106 myIF1=nF1;
107 myIF2=nF2;
108 }
109 //
110 void Indices(Standard_Integer& nF1,
111 Standard_Integer& nF2) const {
112 nF1=myIF1;
113 nF2=myIF2;
114 }
115 //
116 void SetFaces(const TopoDS_Face& aF1,
117 const TopoDS_Face& aF2) {
118 myF1=aF1;
119 myF2=aF2;
120 }
121 //
122 const TopoDS_Face& Face1()const {
123 return myF1;
124 }
125 //
126 const TopoDS_Face& Face2()const {
127 return myF2;
128 }
129 //
130 void SetTolFF(const Standard_Real aTolFF) {
131 myTolFF=aTolFF;
132 }
133 //
134 Standard_Real TolFF() const{
135 return myTolFF;
136 }
137 //
36f4947b 138 virtual void Perform() {
139 BOPAlgo_Algo::UserBreak();
a2098360 140 IntTools_FaceFace::Perform(myF1, myF2);
141 }
142 //
143 protected:
144 Standard_Integer myIF1;
145 Standard_Integer myIF2;
146 Standard_Real myTolFF;
147 TopoDS_Face myF1;
148 TopoDS_Face myF2;
149};
150//
151//=======================================================================
152typedef BOPCol_NCVector
153 <BOPAlgo_FaceFace> BOPAlgo_VectorOfFaceFace;
154//
c7b59798 155typedef BOPCol_Functor
a2098360 156 <BOPAlgo_FaceFace,
157 BOPAlgo_VectorOfFaceFace> BOPAlgo_FaceFaceFunctor;
158//
c7b59798 159typedef BOPCol_Cnt
a2098360 160 <BOPAlgo_FaceFaceFunctor,
161 BOPAlgo_VectorOfFaceFace> BOPAlgo_FaceFaceCnt;
162/////////////////////////////////////////////////////////////////////////
4e57c75e 163//=======================================================================
164//function : PerformFF
165//purpose :
166//=======================================================================
7ff8f019 167void BOPAlgo_PaveFiller::PerformFF()
4e57c75e 168{
169 Standard_Integer iSize;
170 Standard_Boolean bValid;
171 //
172 myErrorStatus=0;
173 //
174 myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
175 iSize=myIterator->ExpectedLength();
176 if (!iSize) {
177 return;
178 }
179 //
180 Standard_Boolean bJustAdd, bApp, bCompC2D1, bCompC2D2, bIsDone;
7ff8f019 181 Standard_Boolean bToSplit, bTangentFaces;
402bfe81 182 Standard_Integer nF1, nF2, aNbCurves, aNbPoints, i, aNbLP;
a2098360 183 Standard_Integer aNbFaceFace, k;
4e57c75e 184 Standard_Real aApproxTol, aTolR3D, aTolR2D, aTolFF;
b4109929 185 BRepAdaptor_Surface aBAS1, aBAS2;
af4e6dab 186 BOPCol_MapOfInteger aMI;
a2098360 187 BOPAlgo_VectorOfFaceFace aVFaceFace;
4e57c75e 188 //
189 BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
4e57c75e 190 aFFs.SetIncrement(iSize);
4e57c75e 191 //
192 bApp=mySectionAttribute.Approximation();
193 bCompC2D1=mySectionAttribute.PCurveOnS1();
194 bCompC2D2=mySectionAttribute.PCurveOnS2();
195 aApproxTol=1.e-7;
196 bToSplit = Standard_False;
197 //
198 for (; myIterator->More(); myIterator->Next()) {
199 myIterator->Value(nF1, nF2, bJustAdd);
200 if(bJustAdd) {
201 continue;
202 }
203 //
204 const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
205 const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
206 //
b4109929 207 aBAS1.Initialize(aF1, Standard_False);
208 aBAS2.Initialize(aF2, Standard_False);
209 //
210 if (aBAS1.GetType() == GeomAbs_Plane &&
211 aBAS2.GetType() == GeomAbs_Plane) {
212 Standard_Boolean bToIntersect;
213 //
af4e6dab 214 if (aMI.Add(nF1)) {
78c66ef1 215 myDS->UpdateFaceInfoOn(nF1);
216 myDS->UpdateFaceInfoIn(nF1);
af4e6dab 217 }
218 if (aMI.Add(nF2)) {
78c66ef1 219 myDS->UpdateFaceInfoOn(nF2);
220 myDS->UpdateFaceInfoIn(nF2);
af4e6dab 221 }
222 //
b4109929 223 bToIntersect = CheckPlanes(nF1, nF2);
224 if (!bToIntersect) {
225 myDS->AddInterf(nF1, nF2);
402bfe81 226 BOPDS_InterfFF& aFF=aFFs.Append1();
b4109929 227 aFF.SetIndices(nF1, nF2);
228 aFF.Init(0, 0);
229 continue;
230 }
231 }
232 //
a2098360 233 ToleranceFF(aBAS1, aBAS2, aTolFF);
234 //
235 BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1();
236 //
237 aFaceFace.SetIndices(nF1, nF2);
238 aFaceFace.SetFaces(aF1, aF2);
239 aFaceFace.SetTolFF(aTolFF);
4e57c75e 240 //
241 IntSurf_ListOfPntOn2S aListOfPnts;
242 GetEFPnts(nF1, nF2, aListOfPnts);
243 aNbLP = aListOfPnts.Extent();
244 if (aNbLP) {
245 aFaceFace.SetList(aListOfPnts);
246 }
a2098360 247 //
4e57c75e 248 aFaceFace.SetParameters(bApp, bCompC2D1, bCompC2D2, aApproxTol);
36f4947b 249 aFaceFace.SetProgressIndicator(myProgressIndicator);
a2098360 250 }//for (; myIterator->More(); myIterator->Next()) {
251 //
252 aNbFaceFace=aVFaceFace.Extent();
253 //======================================================
254 BOPAlgo_FaceFaceCnt::Perform(myRunParallel, aVFaceFace);
255 //======================================================
256 //
257 for (k=0; k < aNbFaceFace; ++k) {
258 BOPAlgo_FaceFace& aFaceFace=aVFaceFace(k);
259 //
260 aFaceFace.Indices(nF1, nF2);
261 aTolFF=aFaceFace.TolFF();
4e57c75e 262 //
263 bIsDone=aFaceFace.IsDone();
264 if (bIsDone) {
265 aTolR3D=aFaceFace.TolReached3d();
266 aTolR2D=aFaceFace.TolReached2d();
7ff8f019 267 bTangentFaces=aFaceFace.TangentFaces();
4e57c75e 268 //
4e57c75e 269 if (aTolR3D < aTolFF){
270 aTolR3D=aTolFF;
271 }
272 if (aTolR2D < 1.e-7){
273 aTolR2D=1.e-7;
274 }
275 //
276 aFaceFace.PrepareLines3D(bToSplit);
277 //
278 const IntTools_SequenceOfCurves& aCvsX=aFaceFace.Lines();
279 const IntTools_SequenceOfPntOn2Faces& aPntsX=aFaceFace.Points();
280 //
281 aNbCurves=aCvsX.Length();
282 aNbPoints=aPntsX.Length();
283 //
955b3e71 284 if (aNbCurves || aNbPoints) {
285 myDS->AddInterf(nF1, nF2);
286 }
4e57c75e 287 //
402bfe81 288 BOPDS_InterfFF& aFF=aFFs.Append1();
4e57c75e 289 aFF.SetIndices(nF1, nF2);
290 //
291 aFF.SetTolR3D(aTolR3D);
292 aFF.SetTolR2D(aTolR2D);
7ff8f019 293 aFF.SetTangentFaces(bTangentFaces);
4e57c75e 294 //
295 // Curves, Points
296 aFF.Init(aNbCurves, aNbPoints);
297 //
298 // Curves
bcd19756 299
300 // Fix bounding box expanding coefficient.
301 Standard_Real aBoxExpandValue = aTolR3D;
302 if (aNbCurves > 0)
303 {
304 // Modify geometric expanding coefficient by topology value,
305 // since this bounging box used in sharing (vertex or edge).
306 Standard_Real aMaxVertexTol = Max (BRep_Tool::MaxTolerance(aFaceFace.Face1(), TopAbs_VERTEX),
307 BRep_Tool::MaxTolerance(aFaceFace.Face2(), TopAbs_VERTEX));
308 aBoxExpandValue += aMaxVertexTol;
309 }
310
4e57c75e 311 BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
312 for (i=1; i<=aNbCurves; ++i) {
313 Bnd_Box aBox;
314 //
315 const IntTools_Curve& aIC=aCvsX(i);
316 const Handle(Geom_Curve)& aC3D= aIC.Curve();
bcd19756 317 bValid=IntTools_Tools::CheckCurve(aC3D, aBoxExpandValue, aBox);
4e57c75e 318 if (bValid) {
402bfe81 319 BOPDS_Curve& aNC=aVNC.Append1();
4e57c75e 320 aNC.SetCurve(aIC);
321 aNC.SetBox(aBox);
322 }
323 }
324 //
325 // Points
326 BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
327 for (i=1; i<=aNbPoints; ++i) {
328 const IntTools_PntOn2Faces& aPi=aPntsX(i);
329 const gp_Pnt& aP=aPi.P1().Pnt();
330 //
402bfe81 331 BOPDS_Point& aNP=aVNP.Append1();
4e57c75e 332 aNP.SetPnt(aP);
333 }
334 //}// if (aNbCs || aNbPs)
335 }// if (bIsDone) {
336 else {// 904/L1
402bfe81 337 BOPDS_InterfFF& aFF=aFFs.Append1();
4e57c75e 338 aFF.SetIndices(nF1, nF2);
339 aNbCurves=0;
340 aNbPoints=0;
341 aFF.Init(aNbCurves, aNbPoints);
342 }
a2098360 343 }// for (k=0; k < aNbFaceFace; ++k) {
4e57c75e 344}
345//=======================================================================
346//function : MakeBlocks
347//purpose :
348//=======================================================================
78c66ef1 349void BOPAlgo_PaveFiller::MakeBlocks()
4e57c75e 350{
351 Standard_Integer aNbFF;
352 //
353 myErrorStatus=0;
354 //
355 BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
356 aNbFF=aFFs.Extent();
357 if (!aNbFF) {
358 return;
359 }
360 //
361 Standard_Boolean bExist, bValid2D;
362 Standard_Integer i, nF1, nF2, aNbC, aNbP, j;
363 Standard_Integer nV1, nV2;
96a95605 364 Standard_Real aTolR3D, aT1, aT2, aTol;
488e5b9d 365 Handle(NCollection_BaseAllocator) aAllocator;
4e57c75e 366 BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
367 TopoDS_Edge aES;
368 Handle(BOPDS_PaveBlock) aPBOut;
369 //
370 //-----------------------------------------------------scope f
488e5b9d 371 aAllocator=
372 NCollection_BaseAllocator::CommonBaseAllocator();
4e57c75e 373 //
3285a59a 374 BOPCol_ListOfInteger aLSE(aAllocator), aLBV(aAllocator);
4e57c75e 375 BOPCol_MapOfInteger aMVOnIn(100, aAllocator), aMF(100, aAllocator),
376 aMVStick(100,aAllocator), aMVEF(100, aAllocator),
3285a59a 377 aMI(100, aAllocator);
decdfc94 378 BOPDS_IndexedMapOfPaveBlock aMPBOnIn(100, aAllocator);
379 BOPDS_MapOfPaveBlock aMPBAdd(100, aAllocator);
4e57c75e 380 BOPDS_ListOfPaveBlock aLPB(aAllocator);
381 BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMSCPB(100, aAllocator);
382 BOPCol_DataMapOfShapeInteger aMVI(100, aAllocator);
78c66ef1 383 BOPDS_DataMapOfPaveBlockListOfPaveBlock aDMExEdges(100, aAllocator);
b4109929 384 BOPCol_DataMapOfIntegerReal aMVTol(100, aAllocator);
78c66ef1 385 BOPCol_DataMapOfIntegerInteger aDMI(100, aAllocator);
3285a59a 386 BOPCol_DataMapOfIntegerListOfInteger aDMBV(100, aAllocator);
387 BOPCol_DataMapIteratorOfDataMapOfIntegerReal aItMV;
4e57c75e 388 //
389 for (i=0; i<aNbFF; ++i) {
36f4947b 390 //
391 UserBreak();
392 //
4e57c75e 393 BOPDS_InterfFF& aFF=aFFs(i);
394 aFF.Indices(nF1, nF2);
395 //
396 BOPDS_VectorOfPoint& aVP=aFF.ChangePoints();
397 aNbP=aVP.Extent();
398 BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
399 aNbC=aVC.Extent();
400 if (!aNbP && !aNbC) {
401 continue;
402 }
403 //
404 const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
405 const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
406 //
407 aTolR3D=aFF.TolR3D();
4e57c75e 408 //
409 // Update face info
410 if (aMF.Add(nF1)) {
411 myDS->UpdateFaceInfoOn(nF1);
3285a59a 412 myDS->UpdateFaceInfoIn(nF1);
4e57c75e 413 }
414 if (aMF.Add(nF2)) {
415 myDS->UpdateFaceInfoOn(nF2);
3285a59a 416 myDS->UpdateFaceInfoIn(nF2);
4e57c75e 417 }
3285a59a 418 //
4e57c75e 419 BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
420 BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
421 //
422 aMVOnIn.Clear();
423 aMPBOnIn.Clear();
3285a59a 424 aDMBV.Clear();
b4109929 425 aMVTol.Clear();
4e57c75e 426 //
427 myDS->VerticesOnIn(nF1, nF2, aMVOnIn, aMPBOnIn);
428 myDS->SharedEdges(nF1, nF2, aLSE, aAllocator);
429
430 // 1. Treat Points
431 for (j=0; j<aNbP; ++j) {
432 TopoDS_Vertex aV;
433 BOPDS_CoupleOfPaveBlocks aCPB;
434 //
435 BOPDS_Point& aNP=aVP.ChangeValue(j);
436 const gp_Pnt& aP=aNP.Pnt();
437 //
438 bExist=IsExistingVertex(aP, aTolR3D, aMVOnIn);
439 if (!bExist) {
440 BOPTools_AlgoTools::MakeNewVertex(aP, aTolR3D, aV);
441 //
442 aCPB.SetIndexInterf(i);
443 aCPB.SetIndex(j);
444 aMSCPB.Add(aV, aCPB);
445 }
446 }
447 //
448 // 2. Treat Curves
449 aMVStick.Clear();
450 aMVEF.Clear();
78c66ef1 451 GetStickVertices(nF1, nF2, aMVStick, aMVEF, aMI);
4e57c75e 452 //
453 for (j=0; j<aNbC; ++j) {
454 BOPDS_Curve& aNC=aVC.ChangeValue(j);
455 const IntTools_Curve& aIC=aNC.Curve();
4e57c75e 456 // DEBt
457 aNC.InitPaveBlock1();
458 //
78c66ef1 459 PutPavesOnCurve(aMVOnIn, aTolR3D, aNC, nF1, nF2, aMI, aMVEF, aMVTol);
4e57c75e 460 //
78c66ef1 461 PutStickPavesOnCurve(aF1, aF2, aMI, aNC, aMVStick, aMVTol);
7ff8f019 462 //904/F7
4e57c75e 463 if (aNbC == 1) {
78c66ef1 464 PutEFPavesOnCurve(aNC, aMI, aMVEF, aMVTol);
4e57c75e 465 }
466 //
467 if (aIC.HasBounds()) {
3285a59a 468 aLBV.Clear();
469 //
470 PutBoundPaveOnCurve(aF1, aF2, aTolR3D, aNC, aLBV);
471 //
472 if (!aLBV.IsEmpty()) {
473 aDMBV.Bind(j, aLBV);
474 }
4e57c75e 475 }
476 }//for (j=0; j<aNbC; ++j) {
477 //
478 // Put closing pave if needed
479 for (j=0; j<aNbC; ++j) {
480 BOPDS_Curve& aNC=aVC.ChangeValue(j);
481 PutClosingPaveOnCurve (aNC);
482 }
483 //
484 // 3. Make section edges
485 for (j=0; j<aNbC; ++j) {
486 BOPDS_Curve& aNC=aVC.ChangeValue(j);
487 const IntTools_Curve& aIC=aNC.Curve();
488 //
489 BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
490 Handle(BOPDS_PaveBlock)& aPB1=aNC.ChangePaveBlock1();
491 //
492 aLPB.Clear();
493 aPB1->Update(aLPB, Standard_False);
494 //
495 aItLPB.Initialize(aLPB);
496 for (; aItLPB.More(); aItLPB.Next()) {
497 Handle(BOPDS_PaveBlock)& aPB=aItLPB.ChangeValue();
498 aPB->Indices(nV1, nV2);
499 aPB->Range (aT1, aT2);
500 //
501 if (fabs(aT1 - aT2) < Precision::PConfusion()) {
502 continue;
503 }
504 //
465d1fba 505 bValid2D=myContext->IsValidBlockForFaces(aT1, aT2, aIC,
506 aF1, aF2, aTolR3D);
4e57c75e 507 if (!bValid2D) {
508 continue;
509 }
510 //
511 bExist=IsExistingPaveBlock(aPB, aNC, aTolR3D, aLSE);
512 if (bExist) {
513 continue;
514 }
515 //
516 bExist=IsExistingPaveBlock(aPB, aNC, aTolR3D, aMPBOnIn, aPBOut);
517 if (bExist) {
518 if (aMPBAdd.Add(aPBOut)) {
519 Standard_Boolean bInBothFaces = Standard_True;
5a77460e 520 if (!myDS->IsCommonBlock(aPBOut)) {
4e57c75e 521 Standard_Integer nE;
522 Standard_Real aTolE;
523 //
524 nE = aPBOut->Edge();
525 const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(nE);
526 aTolE = BRep_Tool::Tolerance(aE);
527 if (aTolR3D > aTolE) {
528 myDS->UpdateEdgeTolerance(nE, aTolR3D);
529 }
530 bInBothFaces = Standard_False;
531 } else {
532 bInBothFaces = (aFI1.PaveBlocksOn().Contains(aPBOut) ||
533 aFI1.PaveBlocksIn().Contains(aPBOut))&&
534 (aFI2.PaveBlocksOn().Contains(aPBOut) ||
535 aFI2.PaveBlocksIn().Contains(aPBOut));
536 }
537 if (!bInBothFaces) {
3285a59a 538 PreparePostTreatFF(i, j, aPBOut, aMSCPB, aMVI, aLPBC);
4e57c75e 539 }
540 }
541 continue;
542 }
543 //
544 // Make Edge
545 const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
546 const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
547 //
465d1fba 548 BOPTools_AlgoTools::MakeEdge (aIC, aV1, aT1,
549 aV2, aT2, aTolR3D, aES);
4e57c75e 550 BOPTools_AlgoTools::MakePCurve(aES, aF1, aF2, aIC,
551 mySectionAttribute.PCurveOnS1(),
552 mySectionAttribute.PCurveOnS2());
553 //
554 if (BOPTools_AlgoTools::IsMicroEdge(aES, myContext)) {
555 continue;
556 }
557 //
558 // Append the Pave Block to the Curve j
559 aLPBC.Append(aPB);
560 //
561 // Keep info for post treatment
562 BOPDS_CoupleOfPaveBlocks aCPB;
563 aCPB.SetIndexInterf(i);
564 aCPB.SetIndex(j);
565 aCPB.SetPaveBlock1(aPB);
566 //
567 aMSCPB.Add(aES, aCPB);
568 aMVI.Bind(aV1, nV1);
569 aMVI.Bind(aV2, nV2);
b4109929 570 //
571 aMVTol.UnBind(nV1);
572 aMVTol.UnBind(nV2);
4e57c75e 573 }
574 //
575 aLPBC.RemoveFirst();
576 }//for (j=0; j<aNbC; ++j) {
b4109929 577 //back to previous tolerance values for unused vertices
578 aItMV.Initialize(aMVTol);
579 for (; aItMV.More(); aItMV.Next()) {
580 nV1 = aItMV.Key();
581 aTol = aItMV.Value();
582 //
583 const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV1);
465d1fba 584 const Handle(BRep_TVertex)& TV =
585 *((Handle(BRep_TVertex)*)&aV.TShape());
b4109929 586 TV->Tolerance(aTol);
587 }
588 //
3285a59a 589 ProcessExistingPaveBlocks(i, aMPBOnIn, aDMBV, aMSCPB, aMVI, aMPBAdd);
4e57c75e 590 }//for (i=0; i<aNbFF; ++i) {
591 //
592 // post treatment
78c66ef1 593 myErrorStatus=PostTreatFF(aMSCPB, aMVI, aDMExEdges, aDMI, aAllocator);
4e57c75e 594 if (myErrorStatus) {
595 return;
596 }
597 //
598 // update face info
1b7ae951 599 UpdateFaceInfo(aDMExEdges, aDMI);
78c66ef1 600 //Update all pave blocks
601 UpdatePaveBlocks(aDMI);
4e57c75e 602 //-----------------------------------------------------scope t
603 aMF.Clear();
604 aMVStick.Clear();
605 aMPBOnIn.Clear();
606 aMVOnIn.Clear();
607 aDMExEdges.Clear();
78c66ef1 608 aMI.Clear();
609 aDMI.Clear();
4e57c75e 610}
611
612//=======================================================================
613//function : PostTreatFF
614//purpose :
615//=======================================================================
a942f2da 616Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
4e57c75e 617 (BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMSCPB,
618 BOPCol_DataMapOfShapeInteger& aMVI,
619 BOPDS_DataMapOfPaveBlockListOfPaveBlock& aDMExEdges,
78c66ef1 620 BOPCol_DataMapOfIntegerInteger& aDMI,
7f22979e 621 const Handle(NCollection_BaseAllocator)& theAllocator)
4e57c75e 622{
623 Standard_Integer iRet, aNbS;
624 //
625 iRet=0;
626 aNbS=theMSCPB.Extent();
627 if (!aNbS) {
628 return iRet;
629 }
630 //
631 Standard_Boolean bHasPaveBlocks, bOld;
1d47d8d0 632 Standard_Integer iErr, nSx, nVSD, iX, iP, iC, j, nV, iV = 0, iE, k;
af4e6dab 633 Standard_Integer jx, aNbLPBx;
4e57c75e 634 Standard_Real aT;
4e57c75e 635 TopAbs_ShapeEnum aType;
636 TopoDS_Shape aV, aE;
637 BOPCol_ListIteratorOfListOfShape aItLS;
638 BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
639 BOPDS_PDS aPDS;
640 Handle(BOPDS_PaveBlock) aPB1;
641 BOPDS_Pave aPave[2], aPave1[2];
642 BOPDS_ShapeInfo aSI;
643 //
644 BOPCol_ListOfShape aLS(theAllocator);
645 BOPAlgo_PaveFiller aPF(theAllocator);
646 //
647 BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
648 //
4e57c75e 649 // 0
650 if (aNbS==1) {
651 const TopoDS_Shape& aS=theMSCPB.FindKey(1);
652 const BOPDS_CoupleOfPaveBlocks &aCPB=theMSCPB.FindFromIndex(1);
653
654 //
655 aType=aS.ShapeType();
656 if (aType==TopAbs_VERTEX) {
657 aSI.SetShapeType(aType);
658 aSI.SetShape(aS);
659 iV=myDS->Append(aSI);
660 //
661 iX=aCPB.IndexInterf();
662 iP=aCPB.Index();
663 BOPDS_InterfFF& aFF=aFFs(iX);
664 BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
665 BOPDS_Point& aNP=aVNP(iP);
666 aNP.SetIndex(iV);
667 }
668 else if (aType==TopAbs_EDGE) {
669 aPB1=aCPB.PaveBlock1();
670 //
671 if (aPB1->HasEdge()) {
672 BOPDS_ListOfPaveBlock aLPBx;
673 aLPBx.Append(aPB1);
674 aDMExEdges.Bind(aPB1, aLPBx);
675 } else {
676 aSI.SetShapeType(aType);
677 aSI.SetShape(aS);
678 iE=myDS->Append(aSI);
679 //
680 aPB1->SetEdge(iE);
681 }
682 }
683 return iRet;
684 }
685 //
686 // 1 prepare arguments
687 for (k=1; k<=aNbS; ++k) {
688 const TopoDS_Shape& aS=theMSCPB.FindKey(k);
689 aLS.Append(aS);
690 }
691 //
692 // 2 Fuse shapes
36f4947b 693 aPF.SetProgressIndicator(myProgressIndicator);
a942f2da 694 aPF.SetRunParallel(myRunParallel);
4e57c75e 695 aPF.SetArguments(aLS);
696 aPF.Perform();
697 iErr=aPF.ErrorStatus();
698 if (iErr) {
4e57c75e 699 return iRet;
700 }
701 aPDS=aPF.PDS();
702 //
703 aItLS.Initialize(aLS);
704 for (; aItLS.More(); aItLS.Next()) {
705 const TopoDS_Shape& aSx=aItLS.Value();
706 nSx=aPDS->Index(aSx);
707 const BOPDS_ShapeInfo& aSIx=aPDS->ShapeInfo(nSx);
708 //
709 aType=aSIx.ShapeType();
710 //
711 if (aType==TopAbs_VERTEX) {
712 if (aPDS->HasShapeSD(nSx, nVSD)) {
713 aV=aPDS->Shape(nVSD);
714 }
715 else {
716 aV=aSx;
717 }
718 // index of new vertex in theDS -> iV
719 if (!aMVI.IsBound(aV)) {
720 aSI.SetShapeType(aType);
721 aSI.SetShape(aV);
722 iV=myDS->Append(aSI);
723 //
724 aMVI.Bind(aV, iV);
725 }
726 else {
727 iV=aMVI.Find(aV);
728 }
729 // update FF interference
730 const BOPDS_CoupleOfPaveBlocks &aCPB=theMSCPB.FindFromKey(aSx);
731 iX=aCPB.IndexInterf();
732 iP=aCPB.Index();
733 BOPDS_InterfFF& aFF=aFFs(iX);
734 BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
735 BOPDS_Point& aNP=aVNP(iP);
736 aNP.SetIndex(iV);
737 }//if (aType==TopAbs_VERTEX) {
738 //
739 else if (aType==TopAbs_EDGE) {
740 bHasPaveBlocks=aPDS->HasPaveBlocks(nSx);
741 const BOPDS_CoupleOfPaveBlocks &aCPB=theMSCPB.FindFromKey(aSx);
742 iX=aCPB.IndexInterf();
743 iC=aCPB.Index();
744 aPB1=aCPB.PaveBlock1();
745 //
746 bOld = aPB1->HasEdge();
747 if (bOld) {
748 BOPDS_ListOfPaveBlock aLPBx;
749 aDMExEdges.Bind(aPB1, aLPBx);
750 }
751 //
752 if (!bHasPaveBlocks) {
753 if (bOld) {
754 aDMExEdges.ChangeFind(aPB1).Append(aPB1);
1b7ae951 755 }
756 else {
4e57c75e 757 aSI.SetShapeType(aType);
758 aSI.SetShape(aSx);
759 iE=myDS->Append(aSI);
760 //
761 aPB1->SetEdge(iE);
762 }
763 }
764 else {
765 BOPDS_InterfFF& aFF=aFFs(iX);
766 BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
767 BOPDS_Curve& aNC=aVNC(iC);
768 BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
769 //
770 const BOPDS_ListOfPaveBlock& aLPBx=aPDS->PaveBlocks(nSx);
771 aNbLPBx=aLPBx.Extent();
772 //
773 if (bOld && !aNbLPBx) {
774 aDMExEdges.ChangeFind(aPB1).Append(aPB1);
775 continue;
776 }
777 //
778 if (!bOld) {
779 aItLPB.Initialize(aLPBC);
780 for (; aItLPB.More(); aItLPB.Next()) {
781 const Handle(BOPDS_PaveBlock)& aPBC=aItLPB.Value();
782 if (aPBC==aPB1) {
783 aLPBC.Remove(aItLPB);
784 break;
785 }
786 }
787 }
788 //
789 if (!aNbLPBx) {
790 aE=aSx;
791 //
792 if (!aMVI.IsBound(aE)) {
793 aSI.SetShapeType(aType);
794 aSI.SetShape(aE);
795 iE=myDS->Append(aSI);
796 aMVI.Bind(aE, iE);
797 }
798 else {
799 iE=aMVI.Find(aE);
800 }
801 // append new PaveBlock to aLPBC
4e57c75e 802 aPB1->SetEdge(iE);
803 aLPBC.Append(aPB1);
804 } // if (!aNbLPBx) {
805 //
806 else {
807 aItLPB.Initialize(aLPBx);
808 if (bOld) {
809 aPave1[0] = aPB1->Pave1();
810 aPave1[1] = aPB1->Pave2();
811 }
812 for (; aItLPB.More(); aItLPB.Next()) {
813 const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
5a77460e 814 const Handle(BOPDS_PaveBlock) aPBRx=aPDS->RealPaveBlock(aPBx);
4e57c75e 815 //
816 // update vertices of paves
817 aPave[0]=aPBx->Pave1();
818 aPave[1]=aPBx->Pave2();
819 for (j=0; j<2; ++j) {
820 jx = 0;
821 if (bOld) {
822 aT = aPave[j].Parameter();
823 if (aT == aPave1[0].Parameter()) {
824 jx = 1;
825 } else if (aT == aPave1[1].Parameter()) {
826 jx = 2;
827 }
828 //
829 if (jx) {
830 iV = aPave1[jx-1].Index();
831 }
832 }
833 if (!jx) {
834 nV=aPave[j].Index();
835 aV=aPDS->Shape(nV);
836 //
465d1fba 837 if (!aMVI.IsBound(aV)) {
838 // index of new vertex in theDS -> iV
4e57c75e 839 aSI.SetShapeType(TopAbs_VERTEX);
840 aSI.SetShape(aV);
841 iV=myDS->Append(aSI);
842 aMVI.Bind(aV, iV);
843 }
844 else {
845 iV=aMVI.Find(aV);
846 }
847 }
78c66ef1 848 const BOPDS_Pave& aP1 = !j ? aPB1->Pave1() : aPB1->Pave2();
465d1fba 849 if (aP1.Parameter() == aPave[j].Parameter() &&
850 aP1.Index() != iV) {
78c66ef1 851 aDMI.Bind(aP1.Index(), iV);
6a43d224 852 myDS->AddShapeSD(aP1.Index(), iV);
78c66ef1 853 }
854 //
4e57c75e 855 aPave[j].SetIndex(iV);
856 }
857 //
858 // add edge
859 aE=aPDS->Shape(aPBRx->Edge());
860 //
861 if (!aMVI.IsBound(aE)) {
862 aSI.SetShapeType(aType);
863 aSI.SetShape(aE);
864 iE=myDS->Append(aSI);
865 aMVI.Bind(aE, iE);
866 }
867 else {
868 iE=aMVI.Find(aE);
869 }
870 // append new PaveBlock to aLPBC
871 Handle(BOPDS_PaveBlock) aPBC=new BOPDS_PaveBlock();
872 //
873 aPBC->SetPave1(aPave[0]);
874 aPBC->SetPave2(aPave[1]);
875 aPBC->SetEdge(iE);
876 if (bOld) {
877 aPBC->SetOriginalEdge(aPB1->OriginalEdge());
878 aDMExEdges.ChangeFind(aPB1).Append(aPBC);
879 }
880 else {
881 aLPBC.Append(aPBC);
882 }
883 }
884 }
885 }
886 }//else if (aType==TopAbs_EDGE)
887 }//for (; aItLS.More(); aItLS.Next()) {
888 return iRet;
889}
890
891//=======================================================================
892//function : UpdateFaceInfo
893//purpose :
894//=======================================================================
465d1fba 895void BOPAlgo_PaveFiller::UpdateFaceInfo
1b7ae951 896 (BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDME,
897 const BOPCol_DataMapOfIntegerInteger& theDMV)
4e57c75e 898{
899 Standard_Integer i, j, nV1, nF1, nF2,
1b7ae951 900 aNbFF, aNbC, aNbP;
4e57c75e 901 BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
1b7ae951 902 BOPCol_MapOfInteger aMF;
4e57c75e 903 //
904 BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
905 aNbFF=aFFs.Extent();
906 //
907 //1. Sections (curves, points);
908 for (i=0; i<aNbFF; ++i) {
909 BOPDS_InterfFF& aFF=aFFs(i);
910 aFF.Indices(nF1, nF2);
911 //
912 BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
913 BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
914 //
1b7ae951 915 // 1.1. Section edges
4e57c75e 916 BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
917 aNbC=aVNC.Extent();
918 for (j=0; j<aNbC; ++j) {
919 BOPDS_Curve& aNC=aVNC(j);
920 BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
4e57c75e 921 //
1b7ae951 922 // Add section edges to face info
3285a59a 923 aItLPB.Initialize(aLPBC);
924 for (; aItLPB.More(); ) {
4e57c75e 925 const Handle(BOPDS_PaveBlock)& aPB=aItLPB.Value();
3285a59a 926 //
927 // Treat existing pave blocks
928 if (theDME.IsBound(aPB)) {
929 BOPDS_ListOfPaveBlock& aLPB=theDME.ChangeFind(aPB);
930 UpdateExistingPaveBlocks(aPB, aLPB, nF1, nF2);
931 aLPBC.Remove(aItLPB);
932 continue;
933 }
934 //
4e57c75e 935 aFI1.ChangePaveBlocksSc().Add(aPB);
936 aFI2.ChangePaveBlocksSc().Add(aPB);
3285a59a 937 aItLPB.Next();
4e57c75e 938 }
939 }
1b7ae951 940 //
941 // 1.2. Section vertices
4e57c75e 942 const BOPDS_VectorOfPoint& aVNP=aFF.Points();
943 aNbP=aVNP.Extent();
944 for (j=0; j<aNbP; ++j) {
945 const BOPDS_Point& aNP=aVNP(j);
946 nV1=aNP.Index();
85915310 947 if (nV1<0) {
948 continue;
949 }
4e57c75e 950 aFI1.ChangeVerticesSc().Add(nV1);
951 aFI2.ChangeVerticesSc().Add(nV1);
952 }
1b7ae951 953 //
954 aMF.Add(nF1);
955 aMF.Add(nF2);
4e57c75e 956 }
957 //
1b7ae951 958 Standard_Boolean bVerts, bEdges;
959 //
960 bVerts = theDMV.Extent() > 0;
961 bEdges = theDME.Extent() > 0;
962 //
963 if (!bVerts && !bEdges) {
4e57c75e 964 return;
965 }
966 //
1b7ae951 967 // 2. Update Face Info information with new vertices and new
968 // pave blocks created in PostTreatFF from existing ones
969 Standard_Integer nV2, aNbPB;
970 BOPCol_MapIteratorOfMapOfInteger aItMF;
971 BOPCol_DataMapIteratorOfDataMapOfIntegerInteger aItMV;
972 //
973 aItMF.Initialize(aMF);
974 for (; aItMF.More(); aItMF.Next()) {
975 nF1 = aItMF.Value();
4e57c75e 976 //
1b7ae951 977 BOPDS_FaceInfo& aFI = myDS->ChangeFaceInfo(nF1);
4e57c75e 978 //
1b7ae951 979 // 2.1. Update information about vertices
980 if (bVerts) {
981 BOPCol_MapOfInteger& aMVOn = aFI.ChangeVerticesOn();
982 BOPCol_MapOfInteger& aMVIn = aFI.ChangeVerticesIn();
983 //
984 aItMV.Initialize(theDMV);
985 for (; aItMV.More(); aItMV.Next()) {
986 nV1 = aItMV.Key();
987 nV2 = aItMV.Value();
988 //
989 if (aMVOn.Remove(nV1)) {
990 aMVOn.Add(nV2);
4e57c75e 991 }
1b7ae951 992 //
993 if (aMVIn.Remove(nV1)) {
994 aMVIn.Add(nV2);
995 }
996 } // for (; aItMV.More(); aItMV.Next()) {
997 } // if (bVerts) {
998 //
999 // 2.2. Update information about pave blocks
1000 if (bEdges) {
1001 BOPDS_IndexedMapOfPaveBlock& aMPBOn = aFI.ChangePaveBlocksOn();
1002 BOPDS_IndexedMapOfPaveBlock& aMPBIn = aFI.ChangePaveBlocksIn();
1003 //
1004 BOPDS_IndexedMapOfPaveBlock aMPBCopy;
1005 for (i = 0; i < 2; ++i) {
1006 BOPDS_IndexedMapOfPaveBlock& aMPBOnIn = !i ? aMPBOn : aMPBIn;
1007 aMPBCopy = aMPBOnIn;
1008 aMPBOnIn.Clear();
1009 //
1010 aNbPB = aMPBCopy.Extent();
1011 for (j = 1; j <= aNbPB; ++j) {
1012 const Handle(BOPDS_PaveBlock)& aPB = aMPBCopy(j);
1013 if (theDME.IsBound(aPB)) {
1014 const BOPDS_ListOfPaveBlock& aLPB = theDME.Find(aPB);
3285a59a 1015 if (aLPB.IsEmpty()) {
1016 aMPBOnIn.Add(aPB);
1017 continue;
1018 }
1019 //
1b7ae951 1020 aItLPB.Initialize(aLPB);
1021 for (; aItLPB.More(); aItLPB.Next()) {
1022 const Handle(BOPDS_PaveBlock)& aPB1 = aItLPB.Value();
1023 aMPBOnIn.Add(aPB1);
1024 }
1025 }
1026 else {
1027 aMPBOnIn.Add(aPB);
1028 }
1029 } // for (j = 1; j <= aNbPB; ++j) {
1030 } // for (i = 0; i < 2; ++i) {
1031 } // if (bEdges) {
1032 }
4e57c75e 1033}
4e57c75e 1034//=======================================================================
1035//function : IsExistingVertex
1036//purpose :
1037//=======================================================================
1038 Standard_Boolean BOPAlgo_PaveFiller::IsExistingVertex
1039 (const gp_Pnt& aP,
1040 const Standard_Real theTolR3D,
1041 const BOPCol_MapOfInteger& aMVOnIn)const
1042{
1043 Standard_Boolean bRet;
1044 Standard_Integer nV, iFlag;
1045 Standard_Real aTolV;
1046 gp_Pnt aPV;
1047 Bnd_Box aBoxP;
1048 BOPCol_MapIteratorOfMapOfInteger aIt;
1049 //
1050 bRet=Standard_True;
1051 //
1052 aBoxP.Add(aP);
1053 aBoxP.Enlarge(theTolR3D);
1054 //
1055 aIt.Initialize(aMVOnIn);
1056 for (; aIt.More(); aIt.Next()) {
1057 Bnd_Box aBoxV;
1058 //
1059 nV=aIt.Value();
1060 const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nV)));
1061 aPV=BRep_Tool::Pnt(aV);
1062 aTolV=BRep_Tool::Tolerance(aV);
1063 aBoxV.Add(aP);
1064 aBoxV.Enlarge(aTolV);
1065 //
1066 if (!aBoxP.IsOut(aBoxV)) {
1067 iFlag=BOPTools_AlgoTools::ComputeVV(aV, aP, theTolR3D);
1068 if (!iFlag) {
1069 return bRet;
1070 }
1071 }
1072 }
1073 return !bRet;
1074}
1075//=======================================================================
1076//function : IsExistingPaveBlock
1077//purpose :
1078//=======================================================================
1079 Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
1080 (const Handle(BOPDS_PaveBlock)& thePB,
1081 const BOPDS_Curve& theNC,
1082 const Standard_Real theTolR3D,
1083 const BOPCol_ListOfInteger& theLSE)
1084{
1085 Standard_Boolean bRet=Standard_True;
1086 //
1087 if (theLSE.IsEmpty()) {
1088 return !bRet;
1089 }
1090 //
1091 Standard_Real aT1, aT2, aTm, aTx, aTol;
1092 Standard_Integer nE, iFlag;
1093 gp_Pnt aPm;
1094 Bnd_Box aBoxPm;
1095 BOPCol_ListIteratorOfListOfInteger aItLI;
1096 //
1097 thePB->Range(aT1, aT2);
1098 aTm=IntTools_Tools::IntermediatePoint (aT1, aT2);
1099 theNC.Curve().D0(aTm, aPm);
1100 aBoxPm.Add(aPm);
1101 aBoxPm.Enlarge(theTolR3D);
1102 //
1103 aItLI.Initialize(theLSE);
1104 for (; aItLI.More(); aItLI.Next()) {
1105 nE=aItLI.Value();
1106 const BOPDS_ShapeInfo& aSIE=myDS->ChangeShapeInfo(nE);
1107 const Bnd_Box& aBoxE=aSIE.Box();
1108 if (!aBoxE.IsOut(aBoxPm)) {
1109 const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
1110 aTol = BRep_Tool::Tolerance(aE);
1111 aTol = aTol > theTolR3D ? aTol : theTolR3D;
1112 iFlag=myContext->ComputePE(aPm, aTol, aE, aTx);
1113 if (!iFlag) {
1114 return bRet;
1115 }
1116 }
1117 }
1118 return !bRet;
1119}
1120
1121//=======================================================================
1122//function : IsExistingPaveBlock
1123//purpose :
1124//=======================================================================
1125 Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
1126 (const Handle(BOPDS_PaveBlock)& thePB,
1127 const BOPDS_Curve& theNC,
1128 const Standard_Real theTolR3D,
decdfc94 1129 const BOPDS_IndexedMapOfPaveBlock& theMPBOnIn,
c04c30b3 1130 Handle(BOPDS_PaveBlock)& aPBOut)
4e57c75e 1131{
1132 Standard_Boolean bRet;
1133 Standard_Real aT1, aT2, aTm, aTx;
decdfc94 1134 Standard_Integer nSp, iFlag1, iFlag2, nV11, nV12, nV21, nV22, i, aNbPB;
4e57c75e 1135 gp_Pnt aP1, aPm, aP2;
1136 Bnd_Box aBoxP1, aBoxPm, aBoxP2;
4e57c75e 1137 //
78c66ef1 1138 bRet=Standard_False;
4e57c75e 1139 const IntTools_Curve& aIC=theNC.Curve();
1140 //
1141 thePB->Range(aT1, aT2);
1142 thePB->Indices(nV11, nV12);
1143 //first point
1144 aIC.D0(aT1, aP1);
1145 aBoxP1.Add(aP1);
1146 aBoxP1.Enlarge(theTolR3D);
1147 //intermediate point
1148 aTm=IntTools_Tools::IntermediatePoint (aT1, aT2);
1149 aIC.D0(aTm, aPm);
1150 aBoxPm.Add(aPm);
1151 aBoxPm.Enlarge(theTolR3D);
1152 //last point
1153 aIC.D0(aT2, aP2);
1154 aBoxP2.Add(aP2);
1155 aBoxP2.Enlarge(theTolR3D);
1156 //
decdfc94 1157 aNbPB = theMPBOnIn.Extent();
1158 for (i = 1; i <= aNbPB; ++i) {
1159 const Handle(BOPDS_PaveBlock)& aPB = theMPBOnIn(i);
4e57c75e 1160 aPB->Indices(nV21, nV22);
1161 nSp=aPB->Edge();
1162 const BOPDS_ShapeInfo& aSISp=myDS->ChangeShapeInfo(nSp);
78c66ef1 1163 const TopoDS_Edge& aSp=(*(TopoDS_Edge *)(&aSISp.Shape()));
4e57c75e 1164 const Bnd_Box& aBoxSp=aSISp.Box();
78c66ef1 1165 //
465d1fba 1166 iFlag1 = (nV11 == nV21 || nV11 == nV22) ? 2 :
1167 (!aBoxSp.IsOut(aBoxP1) ? 1 : 0);
1168 iFlag2 = (nV12 == nV21 || nV12 == nV22) ? 2 :
1169 (!aBoxSp.IsOut(aBoxP2) ? 1 : 0);
78c66ef1 1170 if (iFlag1 && iFlag2) {
465d1fba 1171 if (aBoxSp.IsOut(aBoxPm) || myContext->ComputePE(aPm,
1172 theTolR3D,
1173 aSp,
1174 aTx)) {
78c66ef1 1175 continue;
1176 }
1177 //
1178 if (iFlag1 == 1) {
1179 iFlag1 = !myContext->ComputePE(aP1, theTolR3D, aSp, aTx);
1180 }
1181 //
1182 if (iFlag2 == 1) {
1183 iFlag2 = !myContext->ComputePE(aP2, theTolR3D, aSp, aTx);
1184 }
1185 //
1186 if (iFlag1 && iFlag2) {
1187 aPBOut = aPB;
1188 bRet=Standard_True;
1189 break;
4e57c75e 1190 }
1191 }
1192 }
78c66ef1 1193 return bRet;
4e57c75e 1194}
4e57c75e 1195//=======================================================================
1196//function : PutBoundPaveOnCurve
1197//purpose :
1198//=======================================================================
1199 void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
1200 const TopoDS_Face& aF2,
1201 const Standard_Real aTolR3D,
1202 BOPDS_Curve& aNC,
3285a59a 1203 BOPCol_ListOfInteger& aLVB)
4e57c75e 1204{
1205 Standard_Boolean bVF;
1206 Standard_Integer nV, iFlag, nVn, j, aNbEP;
1207 Standard_Real aT[2], aTmin, aTmax, aTV, aTol, aTolVnew;
1208 gp_Pnt aP[2];
1209 TopoDS_Vertex aVn;
1210 BOPDS_ListIteratorOfListOfPave aItLP;
1211 BOPDS_Pave aPn, aPMM[2];
1212 //
1213 aTolVnew = Precision::Confusion();
1214 //
1215 const IntTools_Curve& aIC=aNC.Curve();
1216 aIC.Bounds(aT[0], aT[1], aP[0], aP[1]);
1217 //
1218 Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1219 const BOPDS_ListOfPave& aLP=aPB->ExtPaves();
1220 //
1221 aNbEP=aLP.Extent();
1222 if (aNbEP) {
1223 aTmin=1.e10;
1224 aTmax=-aTmin;
1225 //
1226 aItLP.Initialize(aLP);
1227 for (; aItLP.More(); aItLP.Next()) {
1228 const BOPDS_Pave& aPv=aItLP.Value();
1229 aPv.Contents(nV, aTV);
1230 if (aTV<aTmin) {
1231 aPMM[0]=aPv;
1232 aTmin=aTV;
1233 }
1234 if (aTV>aTmax) {
1235 aPMM[1]=aPv;
1236 aTmax=aTV;
1237 }
1238 }
1239 }
1240 //
1241 for (j=0; j<2; ++j) {
1242 //if curve is closed, process only one bound
1243 if (j && aP[1].IsEqual(aP[0], aTolVnew)) {
1244 continue;
1245 }
1246 //
1247 iFlag=1;
1248 //
1249 if (aNbEP) {
1250 Bnd_Box aBoxP;
1251 //
1252 aBoxP.Set(aP[j]);
1253 aTol = aTolR3D+Precision::Confusion();
1254 aBoxP.Enlarge(aTol);
1255 const BOPDS_Pave& aPV=aPMM[j];
1256 nV=aPV.Index();
1257 const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
1258 const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&aSIV.Shape()));
1259 const Bnd_Box& aBoxV=aSIV.Box();
1260 if (!aBoxP.IsOut(aBoxV)){
1261 iFlag=BOPTools_AlgoTools::ComputeVV(aV, aP[j], aTol);
1262 }
1263 }
1264 if (iFlag) {
1265 // 900/L5
1266 bVF=myContext->IsValidPointForFaces (aP[j], aF1, aF2, aTolR3D);
1267 if (!bVF) {
1268 continue;
1269 }
1270 //
1271 BOPDS_ShapeInfo aSIVn;
1272 //
1273 BOPTools_AlgoTools::MakeNewVertex(aP[j], aTolR3D, aVn);
1274 aSIVn.SetShapeType(TopAbs_VERTEX);
1275 aSIVn.SetShape(aVn);
1276 //
1277 nVn=myDS->Append(aSIVn);
1278 //
1279 aPn.SetIndex(nVn);
1280 aPn.SetParameter(aT[j]);
1281 aPB->AppendExtPave(aPn);
1282 //
1283 aVn=(*(TopoDS_Vertex *)(&myDS->Shape(nVn)));
1284 BOPTools_AlgoTools::UpdateVertex (aIC, aT[j], aVn);
1285 //
1286 aTolVnew = BRep_Tool::Tolerance(aVn);
1287 //
1288 BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVn);
1289 Bnd_Box& aBoxDS=aSIDS.ChangeBox();
1290 BRepBndLib::Add(aVn, aBoxDS);
3285a59a 1291 //
1292 aLVB.Append(nVn);
4e57c75e 1293 }
1294 }
1295}
1296
1297//=======================================================================
78c66ef1 1298//function : PutPavesOnCurve
4e57c75e 1299//purpose :
1300//=======================================================================
465d1fba 1301 void BOPAlgo_PaveFiller::PutPavesOnCurve
1302 (const BOPCol_MapOfInteger& aMVOnIn,
1303 const Standard_Real aTolR3D,
1304 BOPDS_Curve& aNC,
1305 const Standard_Integer nF1,
1306 const Standard_Integer nF2,
1307 const BOPCol_MapOfInteger& aMI,
1308 const BOPCol_MapOfInteger& aMVEF,
1309 BOPCol_DataMapOfIntegerReal& aMVTol)
4e57c75e 1310{
78c66ef1 1311 Standard_Boolean bInBothFaces;
4e57c75e 1312 Standard_Integer nV;
4e57c75e 1313 BOPCol_MapIteratorOfMapOfInteger aIt;
1314 //
4e57c75e 1315 const Bnd_Box& aBoxC=aNC.Box();
1316 //
78c66ef1 1317 //Put EF vertices first
1318 aIt.Initialize(aMVEF);
1319 for (; aIt.More(); aIt.Next()) {
1320 nV=aIt.Value();
1321 PutPaveOnCurve(nV, aTolR3D, aNC, aMI, aMVTol, 2);
1322 }
1323 //Put all other vertices
4e57c75e 1324 aIt.Initialize(aMVOnIn);
1325 for (; aIt.More(); aIt.Next()) {
1326 nV=aIt.Value();
78c66ef1 1327 if (aMVEF.Contains(nV)) {
1328 continue;
4e57c75e 1329 }
1330 //
78c66ef1 1331 const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
1332 const Bnd_Box& aBoxV=aSIV.Box();
4e57c75e 1333 //
78c66ef1 1334 if (aBoxC.IsOut(aBoxV)){
1335 continue;
1336 }
1337 if (!myDS->IsNewShape(nV)) {
1338 const BOPDS_FaceInfo& aFI1 = myDS->FaceInfo(nF1);
1339 const BOPDS_FaceInfo& aFI2 = myDS->FaceInfo(nF2);
b4109929 1340 //
78c66ef1 1341 bInBothFaces = (aFI1.VerticesOn().Contains(nV) ||
1342 aFI1.VerticesIn().Contains(nV))&&
1343 (aFI2.VerticesOn().Contains(nV) ||
1344 aFI2.VerticesIn().Contains(nV));
1345 if (!bInBothFaces) {
1346 continue;
b4109929 1347 }
4e57c75e 1348 }
78c66ef1 1349 //
1350 PutPaveOnCurve(nV, aTolR3D, aNC, aMI, aMVTol, 1);
4e57c75e 1351 }
1352}
1353
1354//=======================================================================
1355//function : ExtendedTolerance
1356//purpose :
1357//=======================================================================
465d1fba 1358Standard_Boolean BOPAlgo_PaveFiller::ExtendedTolerance
1359 (const Standard_Integer nV,
1360 const BOPCol_MapOfInteger& aMI,
1361 Standard_Real& aTolVExt,
1362 const Standard_Integer aType)
4e57c75e 1363{
1364 Standard_Boolean bFound = Standard_False;
1365 if (!(myDS->IsNewShape(nV))) {
1366 return bFound;
1367 }
78c66ef1 1368 //
1369 Standard_Integer i, k, aNbLines, aNbInt;
4e57c75e 1370 Standard_Real aT11, aT12, aD1, aD2, aD;
1371 TopoDS_Vertex aV;
1372 gp_Pnt aPV, aP11, aP12;
78c66ef1 1373 //
1374 k = 0;
1375 aNbInt = 2;
1376 if (aType == 1) {
1377 aNbInt = 1;
1378 } else if (aType == 2) {
1379 k = 1;
1380 }
1381 //
4e57c75e 1382 aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
1383 aPV=BRep_Tool::Pnt(aV);
1384 //
1385 BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
1386 BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
78c66ef1 1387 //
1388 for (; k<aNbInt; ++k) {
4e57c75e 1389 aNbLines = !k ? aEEs.Extent() : aEFs.Extent();
1390 for (i = 0; i < aNbLines; ++i) {
1391 BOPDS_Interf *aInt = !k ? (BOPDS_Interf*) (&aEEs(i)) :
78c66ef1 1392 (BOPDS_Interf*) (&aEFs(i));
4e57c75e 1393 if (aInt->IndexNew() == nV) {
465d1fba 1394 if (aMI.Contains(aInt->Index1()) &&
1395 aMI.Contains(aInt->Index2())) {
4e57c75e 1396 const IntTools_CommonPrt& aComPrt = !k ? aEEs(i).CommonPart() :
78c66ef1 1397 aEFs(i).CommonPart();
4e57c75e 1398 //
1399 const TopoDS_Edge& aE1=aComPrt.Edge1();
1400 aComPrt.Range1(aT11, aT12);
1401 BOPTools_AlgoTools::PointOnEdge(aE1, aT11, aP11);
1402 BOPTools_AlgoTools::PointOnEdge(aE1, aT12, aP12);
1403 aD1=aPV.Distance(aP11);
1404 aD2=aPV.Distance(aP12);
1405 aD=(aD1>aD2)? aD1 : aD2;
1406 if (aD>aTolVExt) {
1407 aTolVExt=aD;
1408 }
1409 return !bFound;
1410 }//if (aMI.Contains(aEF.Index1()) && aMI.Contains(aEF.Index2())) {
1411 }//if (aInt->IndexNew() == nV) {
1412 }//for (i = 0; i < aNbLines; ++i) {
1413 }//for (k=0; k<2; ++k) {
4e57c75e 1414 return bFound;
1415}
1416
1417//=======================================================================
1418//function : GetEFPnts
1419//purpose :
1420//=======================================================================
1421 void BOPAlgo_PaveFiller::GetEFPnts(const Standard_Integer nF1,
1422 const Standard_Integer nF2,
1423 IntSurf_ListOfPntOn2S& aListOfPnts)
1424{
1425 Standard_Integer nE, nF, nFOpposite, aNbEFs, i;
1426 Standard_Real U1, U2, V1, V2, f, l;
78c66ef1 1427 BOPCol_MapOfInteger aMI;
4e57c75e 1428 //
1429 //collect indexes of all shapes from nF1 and nF2.
78c66ef1 1430 GetFullShapeMap(nF1, aMI);
1431 GetFullShapeMap(nF2, aMI);
4e57c75e 1432 //
1433 BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
1434 aNbEFs = aEFs.Extent();
1435 //
1436 for(i = 0; i < aNbEFs; ++i) {
1437 const BOPDS_InterfEF& aEF = aEFs(i);
78c66ef1 1438 if (aEF.HasIndexNew()) {
1439 aEF.Indices(nE, nFOpposite);
1440 if(aMI.Contains(nE) && aMI.Contains(nFOpposite)) {
1441 const IntTools_CommonPrt& aCP = aEF.CommonPart();
4e57c75e 1442 Standard_Real aPar = aCP.VertexParameter1();
1443 const TopoDS_Edge& aE = (*(TopoDS_Edge*)(&myDS->Shape(nE)));
465d1fba 1444 const TopoDS_Face& aFOpposite =
1445 (*(TopoDS_Face*)(&myDS->Shape(nFOpposite)));
4e57c75e 1446 //
1447 const Handle(Geom_Curve)& aCurve = BRep_Tool::Curve(aE, f, l);
1448 //
1449 nF = (nFOpposite == nF1) ? nF2 : nF1;
1450 const TopoDS_Face& aF = (*(TopoDS_Face*)(&myDS->Shape(nF)));
465d1fba 1451 Handle(Geom2d_Curve) aPCurve =
1452 BRep_Tool::CurveOnSurface(aE, aF, f, l);
4e57c75e 1453 //
465d1fba 1454 GeomAPI_ProjectPointOnSurf& aProj=myContext->ProjPS(aFOpposite);
4e57c75e 1455 //
1456 gp_Pnt aPoint;
1457 aCurve->D0(aPar, aPoint);
1458 IntSurf_PntOn2S aPnt;
1459 if(!aPCurve.IsNull()) {
1460 gp_Pnt2d aP2d = aPCurve->Value(aPar);
1461 aProj.Perform(aPoint);
1462 if(aProj.IsDone()) {
1463 aProj.LowerDistanceParameters(U1,V1);
1464 if (nF == nF1) {
1465 aPnt.SetValue(aP2d.X(),aP2d.Y(),U1,V1);
1466 } else {
1467 aPnt.SetValue(U1,V1,aP2d.X(),aP2d.Y());
1468 }
1469 aListOfPnts.Append(aPnt);
1470 }
1471 }
1472 else {
1473 GeomAPI_ProjectPointOnSurf& aProj1 = myContext->ProjPS(aF);
1474 aProj1.Perform(aPoint);
1475 aProj.Perform(aPoint);
1476 if(aProj1.IsDone() && aProj.IsDone()){
1477 aProj1.LowerDistanceParameters(U1,V1);
1478 aProj.LowerDistanceParameters(U2,V2);
1479 if (nF == nF1) {
1480 aPnt.SetValue(U1,V1,U2,V2);
1481 } else {
1482 aPnt.SetValue(U2,V2,U1,V1);
1483 }
1484 aListOfPnts.Append(aPnt);
1485 }
1486 }
1487 }
1488 }
1489 }
1490}
1491
1492//=======================================================================
1493//function : ProcessUnUsedVertices
1494//purpose :
1495//=======================================================================
465d1fba 1496 void BOPAlgo_PaveFiller::PutEFPavesOnCurve
1497 (BOPDS_Curve& aNC,
1498 const BOPCol_MapOfInteger& aMI,
1499 const BOPCol_MapOfInteger& aMVEF,
1500 BOPCol_DataMapOfIntegerReal& aMVTol)
4e57c75e 1501{
1502 if (!aMVEF.Extent()) {
1503 return;
1504 }
1505 //
1506 const IntTools_Curve& aIC=aNC.Curve();
1507 GeomAbs_CurveType aTypeC;
1508 aTypeC=aIC.Type();
1509 if (!(aTypeC==GeomAbs_BezierCurve || aTypeC==GeomAbs_BSplineCurve)) {
1510 return;
1511 }
1512 //
1513 Standard_Integer nV;
1514 BOPCol_MapOfInteger aMV;
1515 //
1516 aMV.Assign(aMVEF);
1517 RemoveUsedVertices(aNC, aMV);
1518 if (!aMV.Extent()) {
1519 return;
1520 }
1521 //
1522 Standard_Real aDist;
1523 BOPDS_Pave aPave;
1524 //
1525 const Handle(Geom_Curve)& aC3D=aIC.Curve();
4e57c75e 1526 GeomAPI_ProjectPointOnCurve& aProjPT = myContext->ProjPT(aC3D);
78c66ef1 1527 //
4e57c75e 1528 BOPCol_MapIteratorOfMapOfInteger aItMI;
1529 aItMI.Initialize(aMV);
1530 for (; aItMI.More(); aItMI.Next()) {
1531 nV = aItMI.Value();
1532 const TopoDS_Vertex& aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
1533 gp_Pnt aPV = BRep_Tool::Pnt(aV);
1534 aProjPT.Perform(aPV);
1535 Standard_Integer aNbPoints = aProjPT.NbPoints();
1536 if (aNbPoints) {
1537 aDist = aProjPT.LowerDistance();
78c66ef1 1538 PutPaveOnCurve(nV, aDist, aNC, aMI, aMVTol);
4e57c75e 1539 }
1540 }
1541}
1542
1543//=======================================================================
1544//function : ProcessUnUsedVertices
1545//purpose :
1546//=======================================================================
465d1fba 1547 void BOPAlgo_PaveFiller::PutStickPavesOnCurve
1548 (const TopoDS_Face& aF1,
1549 const TopoDS_Face& aF2,
1550 const BOPCol_MapOfInteger& aMI,
1551 BOPDS_Curve& aNC,
1552 const BOPCol_MapOfInteger& aMVStick,
1553 BOPCol_DataMapOfIntegerReal& aMVTol)
4e57c75e 1554{
1555 BOPCol_MapOfInteger aMV;
1556 aMV.Assign(aMVStick);
1557 RemoveUsedVertices(aNC, aMV);
1558 //
1559 if (!aMV.Extent()) {
1560 return;
1561 }
1562 //
4e57c75e 1563 Handle(Geom_Surface) aS1=BRep_Tool::Surface(aF1);
1564 Handle(Geom_Surface) aS2=BRep_Tool::Surface(aF2);
ec0cdc0e 1565 //
1566 const IntTools_Curve& aIC=aNC.Curve();
ec0cdc0e 1567 //if (aTypeC==GeomAbs_BezierCurve || aTypeC==GeomAbs_BSplineCurve) {
1568 Handle(Geom2d_Curve) aC2D[2];
1569 //
1570 aC2D[0]=aIC.FirstCurve2d();
1571 aC2D[1]=aIC.SecondCurve2d();
1572 if (!aC2D[0].IsNull() && !aC2D[1].IsNull()) {
1573 Standard_Integer nV, m, n;
1574 Standard_Real aTC[2], aD, aD2, u, v, aDT2, aScPr, aDScPr;
1575 gp_Pnt aPC[2], aPV;
1576 gp_Dir aDN[2];
1577 gp_Pnt2d aP2D;
1578 BOPCol_MapIteratorOfMapOfInteger aItMI, aItMI1;
1579 //
1580 aDT2=2e-7; // the rich criteria
1581 aDScPr=5.e-9; // the creasing criteria
1582 aIC.Bounds(aTC[0], aTC[1], aPC[0], aPC[1]);
4e57c75e 1583 //
ec0cdc0e 1584 aItMI.Initialize(aMV);
1585 for (; aItMI.More(); aItMI.Next()) {
1586 nV = aItMI.Value();
1587 const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&myDS->Shape(nV));
1588 aPV=BRep_Tool::Pnt(aV);
4e57c75e 1589 //
ec0cdc0e 1590 for (m=0; m<2; ++m) {
1591 aD2=aPC[m].SquareDistance(aPV);
1592 if (aD2>aDT2) {// no rich
1593 continue;
1594 }
78c66ef1 1595 //
ec0cdc0e 1596 for (n=0; n<2; ++n) {
1597 Handle(Geom_Surface)& aS=(!n)? aS1 : aS2;
1598 aC2D[n]->D0(aTC[m], aP2D);
1599 aP2D.Coord(u, v);
1600 BOPTools_AlgoTools3D::GetNormalToSurface(aS, u, v, aDN[n]);
1601 }
1602 //
1603 aScPr=aDN[0]*aDN[1];
1604 if (aScPr<0.) {
1605 aScPr=-aScPr;
1606 }
1607 aScPr=1.-aScPr;
78c66ef1 1608 //
ec0cdc0e 1609 if (aScPr>aDScPr) {
1610 continue;
1611 }
1612 //
1613 // The intersection curve aIC is vanishing curve (the crease)
1614 aD=sqrt(aD2);
1615 //
1616 PutPaveOnCurve(nV, aD, aNC, aMI, aMVTol);
4e57c75e 1617 }
ec0cdc0e 1618 }//for (jVU=1; jVU=aNbVU; ++jVU) {
1619 }
1620 //}//if (aTypeC==GeomAbs_BezierCurve || aTypeC==GeomAbs_BSplineCurve) {
1621 //}//if(aType1==GeomAbs_Torus || aType2==GeomAbs_Torus) {
4e57c75e 1622}
1623
1624//=======================================================================
1625//function : GetStickVertices
1626//purpose :
1627//=======================================================================
1628 void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
1629 const Standard_Integer nF2,
1630 BOPCol_MapOfInteger& aMVStick,
78c66ef1 1631 BOPCol_MapOfInteger& aMVEF,
1632 BOPCol_MapOfInteger& aMI)
4e57c75e 1633{
78c66ef1 1634 Standard_Integer nS1, nS2, nVNew, aTypeInt, i;
4e57c75e 1635 //
1636 BOPDS_VectorOfInterfVV& aVVs=myDS->InterfVV();
1637 BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
1638 BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
1639 BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
1640 BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
1641 //
465d1fba 1642 Standard_Integer aNbLines[5] = {
1643 aVVs.Extent(), aVEs.Extent(), aEEs.Extent(),
1644 aVFs.Extent(), aEFs.Extent()
1645 };
78c66ef1 1646 //collect indices of all shapes from nF1 and nF2.
1647 aMI.Clear();
1648 GetFullShapeMap(nF1, aMI);
1649 GetFullShapeMap(nF2, aMI);
1650 //
1651 //collect VV, VE, EE, VF interferences
1652 for (aTypeInt = 0; aTypeInt < 4; ++aTypeInt) {
1653 for (i = 0; i < aNbLines[aTypeInt]; ++i) {
1654 BOPDS_Interf* aInt = (aTypeInt==0) ? (BOPDS_Interf*)(&aVVs(i)) :
1655 ((aTypeInt==1) ? (BOPDS_Interf*)(&aVEs(i)) :
465d1fba 1656 ((aTypeInt==2) ? (BOPDS_Interf*)(&aEEs(i)) :
1657 (BOPDS_Interf*)(&aVFs(i))));
78c66ef1 1658 if (aInt->HasIndexNew()) {
1659 aInt->Indices(nS1, nS2);
1660 if(aMI.Contains(nS1) && aMI.Contains(nS2)) {
1661 nVNew = aInt->IndexNew();
1662 aMVStick.Add(nVNew);
1663 }
4e57c75e 1664 }
1665 }
1666 }
4e57c75e 1667 //collect EF interferences
78c66ef1 1668 for (i = 0; i < aNbLines[4]; ++i) {
1669 const BOPDS_InterfEF& aInt = aEFs(i);
1670 if (aInt.HasIndexNew()) {
1671 aInt.Indices(nS1, nS2);
1672 if(aMI.Contains(nS1) && aMI.Contains(nS2)) {
1673 nVNew = aInt.IndexNew();
4e57c75e 1674 aMVStick.Add(nVNew);
1675 aMVEF.Add(nVNew);
1676 }
1677 }
1678 }
1679}
1680
1681//=======================================================================
78c66ef1 1682// function: GetFullShapeMap
4e57c75e 1683// purpose:
1684//=======================================================================
78c66ef1 1685void BOPAlgo_PaveFiller::GetFullShapeMap(const Standard_Integer nF,
1686 BOPCol_MapOfInteger& aMI)
4e57c75e 1687{
78c66ef1 1688 BOPCol_ListIteratorOfListOfInteger aIt;
1689 Standard_Integer nS;
1690 //
1691 const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(nF);
1692 const BOPCol_ListOfInteger& aLI = aSI.SubShapes();
1693 //
4e57c75e 1694 aMI.Add(nF);
78c66ef1 1695 aIt.Initialize(aLI);
1696 for (; aIt.More(); aIt.Next()) {
1697 nS = aIt.Value();
1698 aMI.Add(nS);
4e57c75e 1699 }
1700}
1701
1702//=======================================================================
1703// function: RemoveUsedVertices
1704// purpose:
1705//=======================================================================
1706void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
1707 BOPCol_MapOfInteger& aMV)
1708{
1709 if (!aMV.Extent()) {
1710 return;
1711 }
1712 Standard_Integer nV;
1713 BOPDS_Pave aPave;
1714 BOPDS_ListIteratorOfListOfPave aItLP;
1715 //
1716 Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
1717 const BOPDS_ListOfPave& aLP = aPB->ExtPaves();
1718 aItLP.Initialize(aLP);
1719 for (;aItLP.More();aItLP.Next()) {
1720 aPave = aItLP.Value();
1721 nV = aPave.Index();
1722 aMV.Remove(nV);
1723 }
1724}
1725
1726//=======================================================================
1727//function : PutPaveOnCurve
1728//purpose :
1729//=======================================================================
465d1fba 1730 void BOPAlgo_PaveFiller::PutPaveOnCurve
1731 (const Standard_Integer nV,
1732 const Standard_Real aTolR3D,
1733 BOPDS_Curve& aNC,
1734 const BOPCol_MapOfInteger& aMI,
1735 BOPCol_DataMapOfIntegerReal& aMVTol,
1736 const Standard_Integer iCheckExtend)
4e57c75e 1737{
1738 Standard_Boolean bIsVertexOnLine;
787c4320 1739 Standard_Real aT, aTolV;
4e57c75e 1740 //
787c4320 1741 const TopoDS_Vertex& aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
78c66ef1 1742 Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
4e57c75e 1743 const IntTools_Curve& aIC = aNC.Curve();
1744 //
1745 bIsVertexOnLine=myContext->IsVertexOnLine(aV, aIC, aTolR3D, aT);
78c66ef1 1746 if (!bIsVertexOnLine && iCheckExtend) {
787c4320 1747 aTolV = BRep_Tool::Tolerance(aV);
78c66ef1 1748 //
787c4320 1749 ExtendedTolerance(nV, aMI, aTolV, iCheckExtend);
1750 bIsVertexOnLine=myContext->IsVertexOnLine(aV, aTolV, aIC, aTolR3D, aT);
78c66ef1 1751 }
1752 //
4e57c75e 1753 if (bIsVertexOnLine) {
787c4320 1754 // check if aPB contains the parameter aT
1755 Standard_Boolean bExist;
1756 Standard_Integer nVToUpdate;
1757 Standard_Real aPTol, aDist, aTolVNew, aTolV2, aDTol;
1758 TopoDS_Vertex aVToUpdate;
1759 gp_Pnt aP1, aP2;
4e57c75e 1760 //
787c4320 1761 aTolV2 = 0.;
1762 aDTol = 1.e-12;
4e57c75e 1763 //
787c4320 1764 GeomAdaptor_Curve aGAC(aIC.Curve());
1765 aPTol = aGAC.Resolution(aTolR3D);
b4109929 1766 //
787c4320 1767 bExist = aPB->ContainsParameter(aT, aPTol, nVToUpdate);
1768 if (bExist) {
1769 // use existing pave
1770 aP1 = BRep_Tool::Pnt(aV);
1771 aTolV2 = BRep_Tool::Tolerance(aV);
1772 aVToUpdate = (*(TopoDS_Vertex *)(&myDS->Shape(nVToUpdate)));
1773 }
1774 else {
1775 // add new pave
1776 BOPDS_Pave aPave;
1777 aPave.SetIndex(nV);
1778 aPave.SetParameter(aT);
1779 aPB->AppendExtPave(aPave);
1780 //
1781 aP1 = aGAC.Value(aT);
1782 nVToUpdate = nV;
1783 aVToUpdate = aV;
1784 }
b4109929 1785 //
787c4320 1786 aTolV = BRep_Tool::Tolerance(aVToUpdate);
1787 aP2 = BRep_Tool::Pnt(aVToUpdate);
1788 aDist = aP1.Distance(aP2);
1789 aTolVNew = aDist - aTolV2;
1790 //
1791 if (aTolVNew > aTolV) {
1792 BRep_Builder aBB;
1793 aBB.UpdateVertex(aVToUpdate, aTolVNew+aDTol);
1794 //
1795 if (!aMVTol.IsBound(nVToUpdate)) {
1796 aMVTol.Bind(nVToUpdate, aTolV);
b4109929 1797 }
787c4320 1798 //
1799 BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVToUpdate);
1800 Bnd_Box& aBoxDS=aSIDS.ChangeBox();
1801 BRepBndLib::Add(aVToUpdate, aBoxDS);
b4109929 1802 }
4e57c75e 1803 }
1804}
1805
1806//=======================================================================
1807//function : ProcessOldPaveBlocks
1808//purpose :
1809//=======================================================================
1810 void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
1811 (const Standard_Integer theInt,
decdfc94 1812 const BOPDS_IndexedMapOfPaveBlock& aMPBOnIn,
3285a59a 1813 const BOPCol_DataMapOfIntegerListOfInteger& aDMBV,
4e57c75e 1814 BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
1815 BOPCol_DataMapOfShapeInteger& aMVI,
4e57c75e 1816 BOPDS_MapOfPaveBlock& aMPB)
1817{
3285a59a 1818 if (aDMBV.IsEmpty()) {
1819 return;
1820 }
1821 //
4e57c75e 1822 Standard_Real aT;
3285a59a 1823 Standard_Integer i, nV, nE, iC, aNbPB, iFlag;
1824 BOPCol_ListIteratorOfListOfInteger aItLI;
1825 BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItBV;
4e57c75e 1826 //
3285a59a 1827 BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
4e57c75e 1828 BOPDS_InterfFF& aFF = aFFs(theInt);
3285a59a 1829 BOPDS_VectorOfCurve& aVC = aFF.ChangeCurves();
1830 //
1831 aNbPB = aMPBOnIn.Extent();
1832 //
1833 aItBV.Initialize(aDMBV);
1834 for (; aItBV.More(); aItBV.Next()) {
1835 iC = aItBV.Key();
1836 const BOPCol_ListOfInteger& aLBV = aItBV.Value();
4e57c75e 1837 //
3285a59a 1838 BOPDS_Curve& aNC = aVC.ChangeValue(iC);
1839 BOPDS_ListOfPaveBlock& aLPBC = aNC.ChangePaveBlocks();
1840 //
1841 aItLI.Initialize(aLBV);
1842 for (; aItLI.More(); aItLI.Next()) {
1843 nV = aItLI.Value();
1844 const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
1845 const Bnd_Box& aBoxV=aSIV.Box();
1846 const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aSIV.Shape();
1847 if (!aMVI.IsBound(aV)) {
4e57c75e 1848 continue;
1849 }
4e57c75e 1850 //
3285a59a 1851 for (i = 1; i <= aNbPB; ++i) {
1852 const Handle(BOPDS_PaveBlock)& aPB = aMPBOnIn(i);
1853 if (aPB->Pave1().Index() == nV || aPB->Pave2().Index() == nV) {
1854 continue;
1855 }
1856 //
1857 if (aMPB.Contains(aPB)) {
1858 continue;
1859 }
1860 //
1861 nE = aPB->Edge();
1862 const BOPDS_ShapeInfo& aSIE = myDS->ShapeInfo(nE);
1863 const Bnd_Box& aBoxE = aSIE.Box();
1864 //
1865 if (aBoxV.IsOut(aBoxE)) {
1866 continue;
1867 }
1868 //
4e57c75e 1869 const TopoDS_Edge& aE = *(TopoDS_Edge*)&aSIE.Shape();
1870 //
3285a59a 1871 iFlag = myContext->ComputeVE(aV, aE, aT);
4e57c75e 1872 if (!iFlag) {
1873 aMPB.Add(aPB);
3285a59a 1874 PreparePostTreatFF(theInt, iC, aPB, aMSCPB, aMVI, aLPBC);
4e57c75e 1875 }
1876 }
1877 }
1878 }
1879}
4e57c75e 1880//=======================================================================
1881//function : UpdateExistingPaveBlocks
1882//purpose :
1883//=======================================================================
1884 void BOPAlgo_PaveFiller::UpdateExistingPaveBlocks
1885 (const Handle(BOPDS_PaveBlock)& aPBf,
1886 BOPDS_ListOfPaveBlock& aLPB,
1887 const Standard_Integer nF1,
1888 const Standard_Integer nF2)
1889{
1890 Standard_Integer nE;
1891 Standard_Boolean bCB;
1892 Handle(BOPDS_PaveBlock) aPB, aPB1, aPB2, aPB2n;
1893 Handle(BOPDS_CommonBlock) aCB;
1894 BOPDS_ListIteratorOfListOfPaveBlock aIt, aIt1, aIt2;
4e57c75e 1895 //
1b7ae951 1896 // 1. Remove micro edges from aLPB
4e57c75e 1897 aIt.Initialize(aLPB);
1898 for (; aIt.More();) {
1899 aPB = aIt.Value();
1900 const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(aPB->Edge());
1901 if (BOPTools_AlgoTools::IsMicroEdge(aE, myContext)) {
1902 aLPB.Remove(aIt);
1903 continue;
1904 }
1905 aIt.Next();
1906 }
1907 //
1908 if (!aLPB.Extent()) {
1909 return;
1910 }
4e57c75e 1911 //
1912 BOPDS_FaceInfo& aFI1 = myDS->ChangeFaceInfo(nF1);
1913 BOPDS_FaceInfo& aFI2 = myDS->ChangeFaceInfo(nF2);
1914 //
1915 BOPDS_IndexedMapOfPaveBlock& aMPBOn1 = aFI1.ChangePaveBlocksOn();
1916 BOPDS_IndexedMapOfPaveBlock& aMPBIn1 = aFI1.ChangePaveBlocksIn();
1917 BOPDS_IndexedMapOfPaveBlock& aMPBOn2 = aFI2.ChangePaveBlocksOn();
1918 BOPDS_IndexedMapOfPaveBlock& aMPBIn2 = aFI2.ChangePaveBlocksIn();
1919 //
1b7ae951 1920 // 2. Remove old pave blocks
5a77460e 1921 const Handle(BOPDS_CommonBlock)& aCB1 = myDS->CommonBlock(aPBf);
4e57c75e 1922 bCB = !aCB1.IsNull();
1923 BOPDS_ListOfPaveBlock aLPB1;
1924 //
1925 if (bCB) {
1926 aLPB1.Assign(aCB1->PaveBlocks());
1927 } else {
1928 aLPB1.Append(aPBf);
1929 }
1930 aIt1.Initialize(aLPB1);
1931 for (; aIt1.More(); aIt1.Next()) {
1932 aPB1 = aIt1.Value();
1933 nE = aPB1->OriginalEdge();
1934 //
1935 BOPDS_ListOfPaveBlock& aLPB2 = myDS->ChangePaveBlocks(nE);
1936 aIt2.Initialize(aLPB2);
1937 for (; aIt2.More(); aIt2.Next()) {
1938 aPB2 = aIt2.Value();
1939 if (aPB1 == aPB2) {
1940 aLPB2.Remove(aIt2);
1941 break;
1942 }
1943 }
1944 }
1945 //
1b7ae951 1946 // 3. Update pave blocks
4e57c75e 1947 if (bCB) {
1b7ae951 1948 //create new common blocks
3285a59a 1949 BOPDS_ListOfPaveBlock aLPBNew;
4e57c75e 1950 const BOPCol_ListOfInteger& aFaces = aCB1->Faces();
1951 aIt.Initialize(aLPB);
1952 for (; aIt.More(); aIt.Next()) {
51740958 1953 const Handle(BOPDS_PaveBlock)& aPBValue = aIt.Value();
4e57c75e 1954 //
1955 aCB = new BOPDS_CommonBlock;
1956 aIt1.Initialize(aLPB1);
1957 for (; aIt1.More(); aIt1.Next()) {
1958 aPB2 = aIt1.Value();
1959 nE = aPB2->OriginalEdge();
1960 //
1961 aPB2n = new BOPDS_PaveBlock;
51740958 1962 aPB2n->SetPave1(aPBValue->Pave1());
1963 aPB2n->SetPave2(aPBValue->Pave2());
1964 aPB2n->SetEdge(aPBValue->Edge());
4e57c75e 1965 aPB2n->SetOriginalEdge(nE);
1966 aCB->AddPaveBlock(aPB2n);
5a77460e 1967 myDS->SetCommonBlock(aPB2n, aCB);
4e57c75e 1968 myDS->ChangePaveBlocks(nE).Append(aPB2n);
1969 }
1970 aCB->AddFaces(aFaces);
1971 myDS->SortPaveBlocks(aCB);
1972 //
3285a59a 1973 const Handle(BOPDS_PaveBlock)& aPBNew = aCB->PaveBlocks().First();
1974 aLPBNew.Append(aPBNew);
4e57c75e 1975 }
3285a59a 1976 //
1977 aLPB = aLPBNew;
4e57c75e 1978 }
1b7ae951 1979 else {
1980 nE = aPBf->OriginalEdge();
1981 BOPDS_ListOfPaveBlock& aLPBE = myDS->ChangePaveBlocks(nE);
1982 aIt.Initialize(aLPB);
1983 for (; aIt.More(); aIt.Next()) {
1984 aPB = aIt.Value();
1985 aLPBE.Append(aPB);
4e57c75e 1986 }
1987 }
1988 //
4e57c75e 1989 Standard_Boolean bIn1, bIn2;
1990 //
1991 bIn1 = aMPBOn1.Contains(aPBf) || aMPBIn1.Contains(aPBf);
1992 bIn2 = aMPBOn2.Contains(aPBf) || aMPBIn2.Contains(aPBf);
1993 //
1b7ae951 1994 if (bIn1 && bIn2) {
1995 return;
1996 }
1997 //
1998 // 4. Check new pave blocks for coincidence
1999 // with the opposite face.
2000 // In case of coincidence create common blocks
2001 Standard_Integer nF;
2002 Standard_Real aTolE, aTolF;
2003 //
2004 nF = bIn1 ? nF2 : nF1;
2005 const TopoDS_Face& aF = *(TopoDS_Face*)&myDS->Shape(nF);
2006 BOPDS_IndexedMapOfPaveBlock& aMPBIn = bIn1 ? aMPBIn2 : aMPBIn1;
2007 aTolF = BRep_Tool::Tolerance(aF);
2008 //
2009 aIt.Initialize(aLPB);
2010 for (; aIt.More(); aIt.Next()) {
51740958 2011 Handle(BOPDS_PaveBlock)& aPBChangeValue = aIt.ChangeValue();
2012 const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(aPBChangeValue->Edge());
1b7ae951 2013 aTolE = BRep_Tool::Tolerance(aE);
2014 //
2015 IntTools_EdgeFace anEF;
2016 anEF.SetEdge(aE);
2017 anEF.SetFace(aF);
2018 anEF.SetTolE(aTolE);
2019 anEF.SetTolF(aTolF);
51740958 2020 anEF.SetRange(aPBChangeValue->Pave1().Parameter(), aPBChangeValue->Pave2().Parameter());
1b7ae951 2021 anEF.SetContext(myContext);
2022 anEF.Perform();
4e57c75e 2023 //
1b7ae951 2024 const IntTools_SequenceOfCommonPrts& aCPrts=anEF.CommonParts();
2025 if (aCPrts.Length() == 1) {
2026 Standard_Boolean bCoinc = (aCPrts(1).Type() == TopAbs_EDGE);
2027 if (bCoinc) {
2028 if (bCB) {
51740958 2029 aCB = myDS->CommonBlock(aPBChangeValue);
1b7ae951 2030 } else {
2031 aCB = new BOPDS_CommonBlock;
51740958 2032 aCB->AddPaveBlock(aPBChangeValue);
2033 myDS->SetCommonBlock(aPBChangeValue, aCB);
1b7ae951 2034 }
2035 aCB->AddFace(nF);
2036 //
51740958 2037 aMPBIn.Add(aPBChangeValue);
1b7ae951 2038 }
4e57c75e 2039 }
2040 }
2041}
4e57c75e 2042//=======================================================================
2043// function: PutClosingPaveOnCurve
2044// purpose:
2045//=======================================================================
2046 void BOPAlgo_PaveFiller::PutClosingPaveOnCurve(BOPDS_Curve& aNC)
2047{
2048 Standard_Boolean bIsClosed, bHasBounds, bAdded;
2049 Standard_Integer nVC, j;
2050 Standard_Real aT[2], aTC, dT, aTx;
2051 gp_Pnt aP[2] ;
2052 BOPDS_Pave aPVx;
2053 BOPDS_ListIteratorOfListOfPave aItLP;
2054 //
2055 const IntTools_Curve& aIC=aNC.Curve();
2056 const Handle(Geom_Curve)& aC3D=aIC.Curve();
2057 if(aC3D.IsNull()) {
2058 return;
2059 }
2060 //
2061 bIsClosed=IntTools_Tools::IsClosed(aC3D);
2062 if (!bIsClosed) {
2063 return;
2064 }
2065 //
2066 bHasBounds=aIC.HasBounds ();
2067 if (!bHasBounds){
2068 return;
2069 }
2070 //
2071 bAdded=Standard_False;
2072 dT=Precision::PConfusion();
2073 aIC.Bounds (aT[0], aT[1], aP[0], aP[1]);
2074 //
2075 Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
2076 BOPDS_ListOfPave& aLP=aPB->ChangeExtPaves();
2077 //
2078 aItLP.Initialize(aLP);
2079 for (; aItLP.More() && !bAdded; aItLP.Next()) {
2080 const BOPDS_Pave& aPC=aItLP.Value();
2081 nVC=aPC.Index();
2082 aTC=aPC.Parameter();
2083 //
2084 for (j=0; j<2; ++j) {
2085 if (fabs(aTC-aT[j]) < dT) {
2086 aTx=(!j) ? aT[1] : aT[0];
2087 aPVx.SetIndex(nVC);
2088 aPVx.SetParameter(aTx);
2089 aLP.Append(aPVx);
2090 //
2091 bAdded=Standard_True;
2092 break;
2093 }
2094 }
2095 }
2096}
4e57c75e 2097//=======================================================================
2098//function : PreparePostTreatFF
2099//purpose :
2100//=======================================================================
2101 void BOPAlgo_PaveFiller::PreparePostTreatFF
2102 (const Standard_Integer aInt,
3285a59a 2103 const Standard_Integer aCur,
4e57c75e 2104 const Handle(BOPDS_PaveBlock)& aPB,
2105 BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
2106 BOPCol_DataMapOfShapeInteger& aMVI,
3285a59a 2107 BOPDS_ListOfPaveBlock& aLPBC)
4e57c75e 2108{
3285a59a 2109 Standard_Integer nV1, nV2;
4e57c75e 2110 //
4e57c75e 2111 aLPBC.Append(aPB);
2112 //
2113 aPB->Indices(nV1, nV2);
2114 const TopoDS_Vertex& aV1=(*(TopoDS_Vertex *)(&myDS->Shape(nV1)));
2115 const TopoDS_Vertex& aV2=(*(TopoDS_Vertex *)(&myDS->Shape(nV2)));
2116 const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(aPB->Edge());
2117 // Keep info for post treatment
2118 BOPDS_CoupleOfPaveBlocks aCPB;
2119 aCPB.SetIndexInterf(aInt);
3285a59a 2120 aCPB.SetIndex(aCur);
4e57c75e 2121 aCPB.SetPaveBlock1(aPB);
2122 //
2123 aMSCPB.Add(aE, aCPB);
2124 aMVI.Bind(aV1, nV1);
2125 aMVI.Bind(aV2, nV2);
2126}
2127
b4109929 2128//=======================================================================
2129//function : CheckPlanes
2130//purpose :
2131//=======================================================================
465d1fba 2132Standard_Boolean BOPAlgo_PaveFiller::CheckPlanes
2133 (const Standard_Integer nF1,
2134 const Standard_Integer nF2)const
b4109929 2135{
2136 Standard_Boolean bToIntersect;
af4e6dab 2137 Standard_Integer i, nV2, iCnt;
b4109929 2138 BOPCol_MapIteratorOfMapOfInteger aIt;
2139 //
af4e6dab 2140 bToIntersect=Standard_False;
b4109929 2141 //
af4e6dab 2142 const BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
2143 const BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
b4109929 2144 //
af4e6dab 2145 const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
2146 const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
b4109929 2147 //
af4e6dab 2148 iCnt=0;
2149 for (i=0; (i<2 && !bToIntersect); ++i) {
2150 const BOPCol_MapOfInteger& aMV2=(!i) ? aFI2.VerticesIn()
2151 : aFI2.VerticesOn();
2152 //
2153 aIt.Initialize(aMV2);
b4109929 2154 for (; aIt.More(); aIt.Next()) {
af4e6dab 2155 nV2=aIt.Value();
2156 if (aMVIn1.Contains(nV2) || aMVOn1.Contains(nV2)) {
78c66ef1 2157 ++iCnt;
2158 if (iCnt>1) {
2159 bToIntersect=!bToIntersect;
2160 break;
2161 }
b4109929 2162 }
2163 }
2164 }
b4109929 2165 //
2166 return bToIntersect;
2167}
4e57c75e 2168//=======================================================================
78c66ef1 2169//function : UpdatePaveBlocks
2170//purpose :
2171//=======================================================================
465d1fba 2172void BOPAlgo_PaveFiller::UpdatePaveBlocks
2173 (const BOPCol_DataMapOfIntegerInteger& aDMI)
78c66ef1 2174{
2175 if (aDMI.IsEmpty()) {
2176 return;
2177 }
2178 //
2179 Standard_Integer nSp, aNbPBP, nV[2], i, j;
2180 Standard_Real aT[2];
2181 Standard_Boolean bCB, bRebuild;
2182 BOPDS_ListIteratorOfListOfPaveBlock aItPB;
2183 BOPDS_MapOfPaveBlock aMPB;
2184 //
2185 BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
2186 aNbPBP = aPBP.Extent();
2187 for (i=0; i<aNbPBP; ++i) {
2188 BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
2189 //
2190 aItPB.Initialize(aLPB);
2191 for (; aItPB.More(); aItPB.Next()) {
2192 Handle(BOPDS_PaveBlock) aPB=aItPB.Value();
2193 const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
2194 bCB = !aCB.IsNull();
2195 if (bCB) {
2196 aPB=aCB->PaveBlock1();
2197 }
2198 //
2199 if (aMPB.Add(aPB)) {
2200 bRebuild = Standard_False;
2201 aPB->Indices(nV[0], nV[1]);
2202 aPB->Range(aT[0], aT[1]);
2203 //
2204 for (j = 0; j < 2; ++j) {
2205 if (aDMI.IsBound(nV[j])) {
2206 BOPDS_Pave aPave;
2207 //
2208 nV[j] = aDMI.Find(nV[j]);
2209 aPave.SetIndex(nV[j]);
2210 aPave.SetParameter(aT[j]);
2211 //
2212 bRebuild = Standard_True;
2213 if (!j) {
2214 aPB->SetPave1(aPave);
2215 } else {
2216 aPB->SetPave2(aPave);
2217 }
2218 }
2219 }
2220 //
2221 if (bRebuild) {
787c4320 2222 nSp = SplitEdge(aPB->OriginalEdge(), nV[0], aT[0], nV[1], aT[1]);
78c66ef1 2223 if (bCB) {
2224 aCB->SetEdge(nSp);
2225 }
2226 else {
2227 aPB->SetEdge(nSp);
2228 }
2229 }// if (bRebuild) {
2230 }// if (aMPB.Add(aPB)) {
2231 }// for (; aItPB.More(); aItPB.Next()) {
2232 }// for (i=0; i<aNbPBP; ++i) {
2233 aMPB.Clear();
2234}
2235//=======================================================================
4e57c75e 2236//function : ToleranceFF
2237//purpose : Computes the TolFF according to the tolerance value and
2238// types of the faces.
2239//=======================================================================
b4109929 2240 void ToleranceFF(const BRepAdaptor_Surface& aBAS1,
2241 const BRepAdaptor_Surface& aBAS2,
4e57c75e 2242 Standard_Real& aTolFF)
2243{
2244 Standard_Real aTol1, aTol2;
2245 Standard_Boolean isAna1, isAna2;
2246 //
b4109929 2247 aTol1 = aBAS1.Tolerance();
2248 aTol2 = aBAS2.Tolerance();
4e57c75e 2249 aTolFF = Max(aTol1, aTol2);
2250 //
b4109929 2251 isAna1 = (aBAS1.GetType() == GeomAbs_Plane ||
2252 aBAS1.GetType() == GeomAbs_Cylinder ||
2253 aBAS1.GetType() == GeomAbs_Cone ||
2254 aBAS1.GetType() == GeomAbs_Sphere ||
2255 aBAS1.GetType() == GeomAbs_Torus);
4e57c75e 2256 //
b4109929 2257 isAna2 = (aBAS2.GetType() == GeomAbs_Plane ||
2258 aBAS2.GetType() == GeomAbs_Cylinder ||
2259 aBAS2.GetType() == GeomAbs_Cone ||
2260 aBAS2.GetType() == GeomAbs_Sphere ||
2261 aBAS2.GetType() == GeomAbs_Torus);
4e57c75e 2262 //
b4109929 2263 if (!isAna1 || !isAna2) {
2264 aTolFF = Max(aTolFF, 5.e-6);
2265 }
4e57c75e 2266}
Open CASCADE Technology repository