is
CorrectTolerances (myclass;
- aS: Shape from TopoDS;
- aTolMax: Real from Standard =0.0001);
+ aS: Shape from TopoDS);
---Purpose:
--- Provides valid values of tolerances for the shape <aS>
- --- <aTolMax> is max value of the tolerance that can be
- --- accepted for correction. If real value of the tolerance
- --- will be greater than <aTolMax>, the correction does not
- --- perform.
- ---
+
CorrectCurveOnSurface (myclass;
- aS: Shape from TopoDS;
- aTolMax: Real from Standard =0.0001);
+ aS: Shape from TopoDS);
---Purpose:
--- Provides valid values of tolerances for the shape <aS>
--- in terms of BRepCheck_InvalidCurveOnSurface.
---
CorrectPointOnCurve (myclass;
- aS: Shape from TopoDS;
- aTolMax: Real from Standard =0.0001);
+ aS: Shape from TopoDS);
---Purpose:
--- Provides valid values of tolerances for the shape <aS>
--- in terms of BRepCheck_InvalidPointOnCurve.
static
- void CheckEdge (const TopoDS_Edge& E,
- const Standard_Real aMaxTol);
+ void CheckEdge (const TopoDS_Edge& E);
static
void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
- const TopoDS_Face& S,
- const Standard_Real aMaxTol);
+ const TopoDS_Face& S);
static
Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
const Adaptor3d_Curve& Other,
static
void CorrectVertexTolerance(const TopoDS_Edge& aE);
//
-
//=======================================================================
// Function : CorrectTolerances
// purpose :
//=======================================================================
- void BOP_CorrectTolerances::CorrectTolerances(const TopoDS_Shape& aShape,
- const Standard_Real aMaxTol)
+ void BOP_CorrectTolerances::CorrectTolerances(const TopoDS_Shape& aShape)
{
- BOP_CorrectTolerances::CorrectPointOnCurve(aShape, aMaxTol);
- BOP_CorrectTolerances::CorrectCurveOnSurface(aShape, aMaxTol);
+ BOP_CorrectTolerances::CorrectPointOnCurve(aShape);
+ BOP_CorrectTolerances::CorrectCurveOnSurface(aShape);
}
-
//=======================================================================
// Function : CorrectPointOnCurve
// purpose :
//=======================================================================
- void BOP_CorrectTolerances::CorrectPointOnCurve(const TopoDS_Shape& S,
- const Standard_Real aMaxTol)
+ void BOP_CorrectTolerances::CorrectPointOnCurve(const TopoDS_Shape& S)
{
Standard_Integer i, aNb;
TopTools_IndexedMapOfShape Edges;
aNb=Edges.Extent();
for (i=1; i<=aNb; i++) {
const TopoDS_Edge& E= TopoDS::Edge(Edges(i));
- CheckEdge(E, aMaxTol);
+ CheckEdge(E);
}
}
// Function : CorrectCurveOnSurface
// purpose :
//=======================================================================
- void BOP_CorrectTolerances::CorrectCurveOnSurface(const TopoDS_Shape& S,
- const Standard_Real aMaxTol)
+ void BOP_CorrectTolerances::CorrectCurveOnSurface(const TopoDS_Shape& S)
{
Standard_Integer i, aNbFaces, j, aNbEdges;
TopTools_IndexedMapOfShape Faces;
aNbEdges=Edges.Extent();
for (j=1; j<=aNbEdges; j++) {
const TopoDS_Edge& E= TopoDS::Edge(Edges(j));
- CorrectEdgeTolerance (E, F, aMaxTol);
+ CorrectEdgeTolerance (E, F);
}
}
}
// purpose : Correct tolerances for Edge
//=======================================================================
void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
- const TopoDS_Face& S,
- const Standard_Real aMaxTol)
+ const TopoDS_Face& S)
{
//
// 1. Minimum of conditions to Perform
Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
if (ok) {
- if (cr->IsCurveOnClosedSurface()) {
- //return ;// BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
- }
- else {
- //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
- }
- if (SameParameter) {
- //return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
- }
- //
+ //modified by NIZNHY-PKV Thu Sep 27 10:28:27 2012f
+ TE->UpdateTolerance(aNewTol+Delta);
+ CorrectVertexTolerance(myShape);
+ /*
if (aNewTol<aMaxTol) {
TE->UpdateTolerance(aNewTol+Delta);
- //
CorrectVertexTolerance(myShape);
- }
+ //}
+ */
+ //modified by NIZNHY-PKV Thu Sep 27 10:28:44 2012t
}
if (cr->IsCurveOnClosedSurface()) {
ACS.Load(GHPC); // meme remarque...
ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
if (ok) {
- //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
- if (SameParameter) {
- //return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
- }
+ //modified by NIZNHY-PKV Thu Sep 27 10:33:36 2012f
+ TE->UpdateTolerance(aNewTol+Delta);
+ CorrectVertexTolerance(myShape);
+ /*
if (aNewTol<aMaxTol) {
TE->UpdateTolerance(aNewTol+Delta);
CorrectVertexTolerance(myShape);
}
+ */
+ //modified by NIZNHY-PKV Thu Sep 27 10:34:00 2012t
}
}
}
P = Handle(Geom_Plane)::DownCast(Su);
}
if (P.IsNull()) { // not a plane
- return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
+ return;
}
else {// on fait la projection a la volee, comme BRep_Tool
Standard_Boolean okx = Validate(myHCurve->Curve(),ACS,
Tol,Standard_True, aNewTol); // voir dub...
if (okx) {
- //return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
+ //modified by NIZNHY-PKV Thu Sep 27 10:34:10 2012f
+ TE->UpdateTolerance(aNewTol+Delta);
+ CorrectVertexTolerance(myShape);
+ /*
if (aNewTol<aMaxTol) {
TE->UpdateTolerance(aNewTol+Delta);
CorrectVertexTolerance(myShape);
}
+ */
}
}
// Function : CheckEdge
// purpose : Correct tolerances for Vertices on Edge
//=======================================================================
-void CheckEdge (const TopoDS_Edge& Ed, const Standard_Real aMaxTol)
+void CheckEdge (const TopoDS_Edge& Ed)
{
TopoDS_Edge E=Ed;
E.Orientation(TopAbs_FORWARD);
aD2=prep.SquareDistance(Controlp);
if (aD2 > Tol) {
aNewTolerance=sqrt(aD2)+dd;
+ //modified by NIZNHY-PKV Thu Sep 27 10:34:41 2012f
+ TV->UpdateTolerance(aNewTolerance);
+ /*
if (aNewTolerance<aMaxTol)
TV->UpdateTolerance(aNewTolerance);
+ */
}
}
itpr.Next();
if (aD2 > Tol) {
aNewTolerance=sqrt(aD2)+dd;
+ //modified by NIZNHY-PKV Thu Sep 27 10:34:55 2012f
+ TV->UpdateTolerance(aNewTolerance);
+ /*
if (aNewTolerance<aMaxTol)
TV->UpdateTolerance(aNewTolerance);
+ */
+ //modified by NIZNHY-PKV Thu Sep 27 10:35:01 2012t
}
}
}
mySectionEdges.Append(aS);
}
myResult=aCompound;
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
if (!myErrorStatus) {
FillModified();
#include <BOP_Refiner.hxx>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx>
-#include <TopTools_DataMapOfShapeInteger.hxx>
// function: Destroy
// purpose:
//=======================================================================
-void BOP_ShellShell::Destroy() {
-}
+ void BOP_ShellShell::Destroy() {}
//=======================================================================
// function: DoWithFiller
// purpose:
//=======================================================================
-void BOP_ShellShell::DoWithFiller(const BOPTools_DSFiller& aDSFiller)
+ void BOP_ShellShell::DoWithFiller(const BOPTools_DSFiller& aDSFiller)
{
myErrorStatus=0;
myIsDone=Standard_False;
try {
OCC_CATCH_SIGNALS
+ // modified by NIZHNY-MKK Fri Sep 3 15:14:17 2004.BEGIN
if(!myDSFiller->IsDone()) {
myErrorStatus = 1;
BOPTColStd_Dump::PrintMessage("DSFiller is invalid: Can not build result\n");
return;
}
- //
+ // modified by NIZHNY-MKK Fri Sep 3 15:14:20 2004.END
+
Standard_Boolean bIsNewFiller;
bIsNewFiller=aDSFiller.IsNewFiller();
aRefiner.SetInternals(myInternals);
aRefiner.Do();
//
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
FillModified();
myIsDone=Standard_True;
// function: BuildResult
// purpose:
//=================================================================================
-void BOP_ShellShell::BuildResult()
+ void BOP_ShellShell::BuildResult()
{
const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
//
// vars
Standard_Boolean bIsTouchCase, bIsTouch;
- Standard_Integer i, aNb, j, aNbj, iFF, nF1, iRank, nF2;
+ Standard_Integer i, aNb, j, aNbj, iFF, nF1, iRank;
TopTools_ListOfShape aListOfNewFaces;
TopTools_IndexedMapOfShape anEMap;
TopAbs_Orientation anOriF1;
}
}
// 3. Add IN2D, ON2D Parts to the WES
- //
- //modified by NIZNHY-PKV Fri Sep 14 10:00:44 2012f
- BOP_WireEdgeSet aWES1 (myFace);
- //
- for (j=1; j<=aNbj; j++) {
- iFF=aFFIndicesMap(j);
- BOPTools_SSInterference& aFF=aFFs(iFF);
- bIsTouch=aFF.IsTangentFaces();
- if (bIsTouch) {
- nF2=aFF.OppositeIndex(nF1);
- AddINON2DPartsSh(nF1, iFF, aWES1);
- }
- }
- //
- if (iRank==2 || (iRank==1 && myOperation==BOP_CUT)) {
- // #0023431
- // Refine WES to remove duplicated edges:
- // - for the faces of the Object: Cut operation
- // - for the faces of the Tool: all operations
- //
- // The duplications caused by the separated treatment
- // the faces of an argument for the cases when:
- // -these faces contain shared edges and
- // -they are same domain faces with the faces of the other argument.
- TopTools_DataMapOfShapeInteger aDMSI;
-
- //--
- aWES1.InitStartElements();
- for (; aWES1.MoreStartElements(); aWES1.NextStartElement()) {
- const TopoDS_Edge& aE=*((TopoDS_Edge*)&aWES1.StartElement());
- if (!aDMSI.IsBound(aE)) {
- Standard_Integer iCnt=1;
- //
- aDMSI.Bind(aE, iCnt);
- }
- else {
- Standard_Integer& iCnt=aDMSI.ChangeFind(aE);
- ++iCnt;
- }
- }
- //
- aWES1.InitStartElements();
- for (; aWES1.MoreStartElements(); aWES1.NextStartElement()) {
- const TopoDS_Shape& aE=aWES1.StartElement();
- const Standard_Integer& iCnt=aDMSI.Find(aE);
- if (iCnt==1) {
- aWES.AddStartElement(aE);
- }
- }
- }
- else {
- aWES1.InitStartElements();
- for (; aWES1.MoreStartElements(); aWES1.NextStartElement()) {
- const TopoDS_Shape& aE=aWES1.StartElement();
- aWES.AddStartElement(aE);
- }
- }
- //--
- /*
for (j=1; j<=aNbj; j++) {
iFF=aFFIndicesMap(j);
BOPTools_SSInterference& aFF=aFFs(iFF);
AddINON2DPartsSh(nF1, iFF, aWES);
}
}
- */
- //modified by NIZNHY-PKV Fri Sep 14 10:00:48 2012t
// 4. Add EF parts (E (from F2) on F1 ),
// where F2 is non-same-domain face to F1
anEMap.Clear();
}
}// end of (bIsTouchCase)'s else
//
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ // Display the WES
+ if (myDraw) {
+ const TopTools_ListOfShape& aWESL=aWES.StartElements();
+ BOP_Draw::DrawListOfEdgesWithPC (myFace, aWESL, i, "ew_");
+ BOP_Draw::Wait();
+ }
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
//
// d. Build new Faces from myFace
BOP_FaceBuilder aFB;
//
}// for (i=1; i<=aNb; i++)
//
-
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ // Display the new Faces
+ if (myDraw) {
+ BOP_Draw::DrawListOfShape(aListOfNewFaces, "fn_");
+ }
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
myNewFaces.Clear();
myNewFaces.Append(aListOfNewFaces);
}
-/* DEB
- {
- TopoDS_Compound aCx;
- BRep_Builder aBB;
- //
- aBB.MakeCompound(aCx);
- aBB.Add(aCx, myFace);
- //
- aWES.InitStartElements();
- for (; aWES.MoreStartElements(); aWES.NextStartElement()) {
- const TopoDS_Shape& aE = aWES.StartElement();
- aBB.Add(aCx, aE);
- }
- int a=0;
- }
-
-*/
aRefiner.Do();
//
//
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
FillModified();
//
// 3. Post-pro the result aShape
// and filling the myShapes field .
- TopExp_Explorer aShellExp(aShape, TopAbs_SHELL);
+ //modified by NIZNHY-PKV Tue Sep 18 12:06:25 2012f
+ Standard_Integer aNbSh;
+ TopExp_Explorer aShellExp;
+ //
+ aShellExp.Init(aShape, TopAbs_SHELL);
+ for (aNbSh=0; aShellExp.More(); aShellExp.Next(), ++aNbSh) {
+ const TopoDS_Shape& aSh=aShellExp.Current();
+ }
+ //
+ if (aNbSh==1) {
+ Standard_Boolean bIsClosed;
+ //
+ bIsClosed=BRep_Tool::IsClosed(aShell);
+ if (bIsClosed) {
+ myShapes.Append(myFaces);
+ myIsDone=Standard_True;
+ return;
+ }
+ }
+ //modified by NIZNHY-PKV Tue Sep 18 12:06:26 2012t
+ //
+ aShellExp.Init(aShape, TopAbs_SHELL);
for (; aShellExp.More(); aShellExp.Next()) {
const TopoDS_Shape& aSh= aShellExp.Current();
myShapes.Append(aLF);
}
}
-
+ //
myIsDone=Standard_True;
}
aRefiner.SetInternals(myInternals);
aRefiner.Do();
//
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
FillModified();
//
BuildResult();
//
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
FillModified();
myIsDone=Standard_True;
//
BuildResult();
//
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
FillModified();
//
BuildResult();
//
- BOP_CorrectTolerances::CorrectTolerances(myResult, 0.01);
+ BOP_CorrectTolerances::CorrectTolerances(myResult);
//
FillModified();
myIsDone=Standard_True;
--- Try to put 3D-point <aP> (parameter aT) on the curve <aBC>
---
---modified by NIZNHY-PKV Thu Oct 20 07:17:11 2011f
PutClosingPaveOnCurve (me:out;
aBC :out Curve from BOPTools;
aFF :out SSInterference from BOPTools)
--- Put paves on the curve <aBC> in case when <aBC>
-- is closed 3D-curve
---
---modified by NIZNHY-PKV Thu Oct 20 07:17:11 2011t
FindPave (me:out;
aP :Pnt from gp;
aTolExt : out Real from Standard)
returns Boolean from Standard
is protected;
+
+ --modified by NIZNHY-PKV Tue Aug 28 09:45:00 2012ft
+ TreatTechnoVertices(me:out;
+ aFF:out SSInterference from BOPTools)
+ is protected;
+
+ SplitPaveBlock(me:out;
+ aPB: PaveBlock from BOPTools;
+ nVT: Integer from Standard;
+ aPB1:out PaveBlock from BOPTools;
+ aPB2:out PaveBlock from BOPTools)
+ is protected;
+
+ CheckCoincidence(me:out;
+ aPB1: PaveBlock from BOPTools;
+ aPB2: PaveBlock from BOPTools)
+ returns Boolean from Standard
+ is protected;
+ --modified by NIZNHY-PKV Mon Jul 09 13:15:55 2012t
fields
if (aMap.Contains(nV1) && aMap.Contains(nV2)) {
//
const BOPTools_ListOfPaveBlock& aLPBExisting=aFFi.PaveBlocks();
+ //
+ //modified by NIZNHY-PKV Tue Sep 18 11:59:35 2012f
+ iCheckIntermediatePoint=1;
+ BOPTools_ListIteratorOfListOfPaveBlock anItLPB(aLPBExisting);
+ for (; anItLPB.More(); anItLPB.Next()) {
+ const BOPTools_PaveBlock& aPBR=anItLPB.Value();
+ iCheckIntermediatePoint=
+ CheckIntermediatePoint(aPBNew, aPBR, aTolR3D);
+ if (!iCheckIntermediatePoint) {
+ break;
+ }
+ }
+ bIsPaveBlock=(iCheckIntermediatePoint==0);
+ /*
bIsPaveBlock=IsPaveBlock(nV1, nV2, aLPBExisting);
//
iCheckIntermediatePoint=1;
}
bIsPaveBlock=bIsPaveBlock && !iCheckIntermediatePoint;
}
+ */
+ //modified by NIZNHY-PKV Tue Sep 18 12:00:02 2012t
//
if (bIsPaveBlock) {
continue;
}
}
//wkar OCC334 t
+ //modified by NIZNHY-PKV Tue Sep 18 12:01:23 2012f
+ TreatTechnoVertices(aFFi);
+ //modified by NIZNHY-PKV Tue Sep 18 12:01:28 2012t
}
}
//=======================================================================
--- /dev/null
+// Created on: 2001-03-13
+// Created by: Peter KURNEV
+// Copyright (c) 2001-2012 OPEN CASCADE SAS
+//
+// The content of this file is subject to the Open CASCADE Technology Public
+// License Version 6.5 (the "License"). You may not use the content of this file
+// except in compliance with the License. Please obtain a copy of the License
+// at http://www.opencascade.org and read it completely before using this file.
+//
+// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
+// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
+//
+// The Original Code and all software distributed under the License is
+// distributed on an "AS IS" basis, without warranty of any kind, and the
+// Initial Developer hereby disclaims all such warranties, including without
+// limitation, any warranties of merchantability, fitness for a particular
+// purpose or non-infringement. Please see the License for the specific terms
+// and conditions governing the rights and limitations under the License.
+
+#include <BOPTools_PaveFiller.ixx>
+
+#include <TColStd_ListOfInteger.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TColStd_IndexedMapOfInteger.hxx>
+
+#include <gp_Pnt.hxx>
+#include <Geom_Curve.hxx>
+
+#include <TopoDS_Edge.hxx>
+#include <BRep_Builder.hxx>
+
+#include <BooleanOperations_ShapesDataStructure.hxx>
+
+#include <IntTools_Curve.hxx>
+#include <IntTools_Tools.hxx>
+
+#include <BOPTools_Tools.hxx>
+#include <BOPTools_SequenceOfCurves.hxx>
+#include <BOPTools_Curve.hxx>
+#include <BOPTools_ListOfPaveBlock.hxx>
+#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
+#include <BOPTools_Pave.hxx>
+#include <BOPTools_ListOfCommonBlock.hxx>
+#include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
+#include <BOPTools_CommonBlock.hxx>
+
+//modified by NIZNHY-PKV Tue Aug 28 09:45:19 2012ft
+//=======================================================================
+//function : TreatTechnoVertices
+//purpose :
+//=======================================================================
+void BOPTools_PaveFiller::TreatTechnoVertices(BOPTools_SSInterference& aFFi)
+{
+ Standard_Boolean bFlag, bSplitted;
+ Standard_Integer nF1, nF2, aBid, j, aNbCurves, aNbVT, aNbLPB, nE, nVT, iFlag;
+ Standard_Integer nF, nE1, nE2, k;
+ Standard_Real aT;
+ TColStd_IndexedMapOfInteger aMVT;
+
+ TColStd_ListIteratorOfListOfInteger aItLI;
+ BOPTools_Pave aPave;
+ BOPTools_ListOfPaveBlock aLPB, aLPBS;
+ BOPTools_ListIteratorOfListOfPaveBlock aItLPB, aItLPB1;
+ //
+ nF1=aFFi.Index1();
+ nF2=aFFi.Index2();
+ BOPTools_SequenceOfCurves& aBCs=aFFi.Curves();
+ //
+ aNbCurves=aBCs.Length();
+ for (j=1; j<=aNbCurves; j++) {
+ BOPTools_Curve& aBC=aBCs(j);
+ //Handle(Geom_Curve) aC3D= aBC.Curve().Curve(); //DEB
+ TColStd_ListOfInteger& aLVT=aBC.TechnoVertices();
+ aItLI.Initialize(aLVT);
+ for (; aItLI.More(); aItLI.Next()) {
+ nVT=aItLI.Value();
+ aMVT.Add(nVT);
+ }
+ }
+ //
+ aNbVT=aMVT.Extent();
+ if (!aNbVT) {// nothing to do
+ return;
+ }
+ //------------------------------
+ //
+ aBid=0;
+ SplitsInFace (aBid, nF1, nF2, aLPB);
+ SplitsInFace (aBid, nF2, nF1, aLPB);
+ SplitsOnFace (aBid, nF1, nF2, aLPB);
+ //
+ aNbLPB=aLPB.Extent();
+ if (!aNbLPB) {// nothing to do
+ return;
+ }
+ //
+ for (k=1; k<=aNbVT; ++k) {
+ nVT=aMVT(k);
+ const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&(myDS->Shape(nVT)));
+ //
+ // 1.Collect Pave Blocks (pretenders) to split by nVT => aLPBS
+ aLPBS.Clear();
+ aItLPB.Initialize(aLPB);
+ for (; aItLPB.More(); aItLPB.Next()) {
+ const BOPTools_PaveBlock& aPB=aItLPB.Value();
+ nE=aPB.OriginalEdge();
+ const TopoDS_Edge& aE=*((TopoDS_Edge*)&(myDS->Shape(nE)));
+ //
+ iFlag=myContext->ComputeVE(aV, aE, aT);
+ if (iFlag) {
+ continue;
+ }
+ //
+ aPave.SetIndex(nVT);
+ aPave.SetParam(aT);
+ //
+ BOPTools_ListOfPaveBlock& aLPBE=mySplitShapesPool(myDS->RefEdge(nE));
+ aItLPB1.Initialize(aLPBE);
+ for (; aItLPB1.More(); aItLPB1.Next()) {
+ const BOPTools_PaveBlock& aPBE=aItLPB1.Value();
+ if (aPBE.IsInBlock(aPave)) {
+ aLPBS.Append(aPBE);
+ }
+ }
+ }//for (; aItLPB.More(); aItLPB.Next()) {
+ //
+ // 2.Split Pave Blocks [aLPBS] by the vertex [nVT]
+ BOPTools_ListIteratorOfListOfCommonBlock aItCB1, aItCB2;
+ BOPTools_PaveBlock aPB11, aPB12, aPB21, aPB22, aPB1, aPB2;
+ //
+ aItLPB.Initialize(aLPBS);
+ for (; aItLPB.More(); aItLPB.Next()) {
+ const BOPTools_PaveBlock& aPBS=aItLPB.Value();
+ nE=aPBS.OriginalEdge();
+ //
+ BOPTools_ListOfCommonBlock& aLCB1=myCommonBlockPool(myDS->RefEdge(nE));
+ aItCB1.Initialize(aLCB1);
+ for (; aItCB1.More(); aItCB1.Next()) {
+ BOPTools_CommonBlock& aCB1=aItCB1.Value();
+ aPB1=aCB1.PaveBlock1(nE);
+ nE1=aPB1.OriginalEdge();
+ //
+ if (aPB1.IsEqual(aPBS)) {
+ //
+ SplitPaveBlock(aPB1, nVT, aPB11, aPB12);
+ //
+ nF=aCB1.Face();
+ if (nF) {
+ BOPTools_CommonBlock aCBa, aCBb;
+ //
+ aLCB1.Remove(aItCB1);
+ //
+ aCBa.SetPaveBlock1(aPB11);
+ aCBa.SetFace(nF);
+ aCBb.SetPaveBlock2(aPB12);
+ aCBb.SetFace(nF);
+ //
+ aLCB1.Append(aCBa);
+ aLCB1.Append(aCBb);
+ //
+ break;
+ }// if (nF) {
+ else { // 1
+ BOPTools_CommonBlock aCBa, aCBb;
+ //
+ aPB2=aCB1.PaveBlock2(nE);
+ nE2=aPB2.OriginalEdge();
+ //
+ SplitPaveBlock(aPB2, nVT, aPB21, aPB22);
+ //
+ //aLCB1.Remove(aItCB1);
+ //
+ iFlag=0;
+ BOPTools_ListOfCommonBlock& aLCB2=myCommonBlockPool(myDS->RefEdge(nE2));
+ aItCB2.Initialize(aLCB2);
+ for (; aItCB2.More(); aItCB2.Next()) {
+ BOPTools_CommonBlock& aCB2=aItCB2.Value();
+ BOPTools_PaveBlock& aPBx=aCB2.PaveBlock1(nE2);
+ if (aPBx.IsEqual(aPB2)) {
+ aLCB2.Remove(aItCB2);
+ aLCB1.Remove(aItCB1);
+ //
+ bFlag=CheckCoincidence(aPB11, aPB21);
+ if (bFlag) {
+ aCBa.SetPaveBlock1(aPB11);
+ aCBa.SetPaveBlock2(aPB21);
+ aCBb.SetPaveBlock1(aPB12);
+ aCBb.SetPaveBlock2(aPB22);
+ }
+ else {
+ aCBa.SetPaveBlock1(aPB11);
+ aCBa.SetPaveBlock2(aPB22);
+ aCBb.SetPaveBlock1(aPB12);
+ aCBb.SetPaveBlock2(aPB21);
+ }
+ //
+ aLCB1.Append(aCBa);
+ aLCB1.Append(aCBb);
+ aLCB2.Append(aCBa);
+ aLCB2.Append(aCBb);
+ //
+ iFlag=1;
+ break;
+ }//if (aPB1.IsEqual(aPB2)) {
+ }//for (; aItCB2.More(); aItCB2.Next()) {
+ }//else { // 1
+ }//if (aPB1.IsEqual(aPBS)) {
+ if (iFlag) {
+ break;
+ }
+ }//for (; aItCB.More(); aItCB.Next()) {
+ }//for (; aItLPB.More(); aItLPB.Next()) {
+ }//for (k=1; k<=aNbVT; ++k) {
+}
+//=======================================================================
+//function : SplitPaveBlock
+//purpose :
+//=======================================================================
+void BOPTools_PaveFiller::SplitPaveBlock(const BOPTools_PaveBlock& aPBE,
+ const Standard_Integer nVT,
+ BOPTools_PaveBlock& aPB1,
+ BOPTools_PaveBlock& aPB2)
+{
+ Standard_Integer nE, iFlag;
+ Standard_Real aT;
+ BOPTools_Pave aPave;
+ BOPTools_ListIteratorOfListOfPaveBlock aItLPB;
+ //
+ const TopoDS_Vertex& aVT=*((TopoDS_Vertex*)&(myDS->Shape(nVT)));
+ //
+ nE=aPBE.OriginalEdge();
+ const TopoDS_Edge& aE=*((TopoDS_Edge*)&(myDS->Shape(nE)));
+ //
+ BOPTools_ListOfPaveBlock& aLPB=mySplitShapesPool(myDS->RefEdge(nE));
+ //
+ aItLPB.Initialize(aLPB);
+ for (; aItLPB.More(); aItLPB.Next()) {
+ const BOPTools_PaveBlock& aPB=aItLPB.Value();
+ if (aPB.IsEqual(aPBE)) {
+ aLPB.Remove(aItLPB);
+ break;
+ }
+ }
+ //
+ iFlag=myContext->ComputeVE(aVT, aE, aT);
+ //
+ aPave.SetIndex(nVT);
+ aPave.SetParam(aT);
+ //
+ aPB1.SetOriginalEdge(nE);
+ aPB1.SetPave1(aPBE.Pave1());
+ aPB1.SetPave2(aPave);
+ //
+ aPB2.SetOriginalEdge(nE);
+ aPB2.SetPave1(aPave);
+ aPB2.SetPave2(aPBE.Pave2());
+ //
+ aLPB.Append(aPB1);
+ aLPB.Append(aPB2);
+}
+
+//=======================================================================
+//function : CheckCoincidence
+//purpose :
+//=======================================================================
+Standard_Boolean
+ BOPTools_PaveFiller::CheckCoincidence(const BOPTools_PaveBlock& aPB1,
+ const BOPTools_PaveBlock& aPB2)
+
+{
+ Standard_Boolean bRet;
+ Standard_Integer nV11, nV12, nV21, nV22, nE1, nE2, iFlag;
+ Standard_Real aT11, aT12, aT21, aT22, aTM, aTN, aTolE1;
+ gp_Pnt aPM;
+ TopoDS_Vertex aVM;
+ BRep_Builder aBB;
+ //
+ const BOPTools_Pave& aPave11=aPB1.Pave1();
+ nV11=aPave11.Index();
+ aT11=aPave11.Param();
+ //
+ const BOPTools_Pave& aPave12=aPB1.Pave2();
+ aT12=aPave12.Param();
+ nV12=aPave12.Index();
+ //
+ const BOPTools_Pave& aPave21=aPB2.Pave1();
+ nV21=aPave21.Index();
+ aT21=aPave21.Param();
+ //
+ const BOPTools_Pave& aPave22=aPB2.Pave2();
+ nV22=aPave22.Index();
+ aT22=aPave22.Param();
+ //
+ bRet=((nV11==nV21 && nV12==nV22) || (nV11==nV22 && nV12==nV21));
+ if (!bRet) {
+ return bRet;
+ }
+ //
+ nE1=aPB1.OriginalEdge();
+ const TopoDS_Edge& aE1=*((TopoDS_Edge*)&(myDS->Shape(nE1)));
+ aTolE1=BRep_Tool::Tolerance(aE1);
+ //
+ nE2=aPB2.OriginalEdge();
+ const TopoDS_Edge& aE2=*((TopoDS_Edge*)&(myDS->Shape(nE2)));
+ //
+ aTM=IntTools_Tools::IntermediatePoint (aT11, aT12);
+ BOPTools_Tools::PointOnEdge(aE1, aTM, aPM);
+ //
+ aBB.MakeVertex (aVM, aPM, aTolE1);
+ //
+ iFlag=myContext->ComputeVE(aVM, aE2, aTN);
+ if (iFlag) {
+ bRet=!bRet; //False
+ }
+ //
+ if (aT21 <aT22) {
+ bRet=(aTN>aT21 && aTN<aT22);
+ }
+ else {
+ bRet=(aTN>aT22 && aTN<aT21);
+ }
+ return bRet;
+}
BOPTools_PaveFiller_2.cxx
BOPTools_PaveFiller_3.cxx
BOPTools_PaveFiller_4.cxx
+BOPTools_PaveFiller_5.cxx
projects / occt-copy.git / commitdiff