OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0028591: BOP Cut creates wrong result

Browse Source 
The Face/Face intersection procedure has been changed in Boolean Operations algorithm.
Previously, the intersection tolerance for all section curves between pair of faces has been calculated
as the maximal tolerance among all curves. Now, each curve has its own valid tolerance calculated
as the maximal deviation of the 3D curve from its 2D curves on faces or surfaces in case there are no 2D curves.

Thus, such methods of IntTools_FaceFace algorithm as TolReached3d(), TolReal() and TolReached2d() have been removed.
Now the tolerances of the curve can be obtained from the curve itself (IntTools_Curve - result of intersection):
- IntTools_Curve::Tolerance() - returns the valid tolerance for the curve;
- IntTools_Curve::TangentialTolerance() - returns the tangential tolerance, which depends on the size of the common
  between faces. Currently, this tolerance is computed for Plane/Plane cases only. For other case, the value
  of the tangential tolerance is the maximal tolerance of faces.

2D intersection tolerance (IntTools_FaceFace::TolReached2d()) has been completely removed from the algorithm as unused.
This commit is contained in:
emv 2017-03-29 08:46:31 +03:00 committed by bugmaster
parent 769a2e88e0
commit 5652dc6272
16 changed files with 512 additions and 861 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
dox/dev_guides/upgrade/upgrade.md
View File

@ -1237,4 +1237,14 @@ The following Grid management methods within class V3d_Viewer do not implicitly
@subsection upgrade_720_Removal_Of_Old_Boolean_Operations_Draw Removal of the Draw commands based on old Boolean operations @subsection upgrade_720_Removal_Of_Old_Boolean_Operations_Draw Removal of the Draw commands based on old Boolean operations
* The commands *fubl* and *cubl* have been removed. The alternative for these commands are the commands *bfuseblend* and *bcutblend* respectively. * The commands *fubl* and *cubl* have been removed. The alternative for these commands are the commands *bfuseblend* and *bcutblend* respectively.
* The command *ksection* has been removed. The alternative for this command is the command *bsection*. * The command *ksection* has been removed. The alternative for this command is the command *bsection*.
@subsection upgrade_720_Change_Of_FaceFace_Intersection Change of Face/Face intersection in Boolean operations
* Previously, the intersection tolerance for all section curves between pair of faces has been calculated as the maximal tolerance among all curves.
Now, each curve has its own valid tolerance calculated as the maximal deviation of the 3D curve from its 2D curves or surfaces in case there are no 2D curves.
* The methods *IntTools_FaceFace::TolReached3d()*, *IntTools_FaceFace::TolReal()* and *IntTools_FaceFace::TolReached2d()* have been removed.
* Intersection tolerances of the curve can be obtained from the curve itself:
- *IntTools_Curve::Tolerance()* - returns the valid tolerance for the curve;
- *IntTools_Curve::TangentialTolerance()* - returns the tangential tolerance, which reflects the size of the common between faces.
* 2d tolerance (*IntTools_FaceFace::TolReached2d()*) has been completely removed from the algorithm as unused.

9
src/BOPAlgo/BOPAlgo_PaveFiller.hxx
View File

@ -189,7 +189,6 @@ protected:
//! Checks and puts paves from <theMVOn> on the curve <theNC>. //! Checks and puts paves from <theMVOn> on the curve <theNC>.
Standard_EXPORT void PutPavesOnCurve (const BOPCol_MapOfInteger& theMVOn, Standard_EXPORT void PutPavesOnCurve (const BOPCol_MapOfInteger& theMVOn,
const Standard_Real theTolR3D,
BOPDS_Curve& theNC, BOPDS_Curve& theNC,
const Standard_Integer nF1, const Standard_Integer nF1,
const Standard_Integer nF2, const Standard_Integer nF2,
@ -198,8 +197,7 @@ protected:
BOPCol_DataMapOfIntegerReal& theMVTol, BOPCol_DataMapOfIntegerReal& theMVTol,
BOPCol_DataMapOfIntegerListOfInteger& aDMVLV); BOPCol_DataMapOfIntegerListOfInteger& aDMVLV);
Standard_EXPORT void FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC, Standard_EXPORT void FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC);
const Standard_Real theTolR3D);
//! Depending on the parameter aType it checks whether //! Depending on the parameter aType it checks whether
//! the vertex nV was created in EE or EF intersections. //! the vertex nV was created in EE or EF intersections.
@ -211,7 +209,10 @@ protected:
//! other - checks both types of intersections. //! other - checks both types of intersections.
Standard_EXPORT Standard_Boolean ExtendedTolerance (const Standard_Integer nV, const BOPCol_MapOfInteger& aMI, Standard_Real& aTolVExt, const Standard_Integer aType = 0); Standard_EXPORT Standard_Boolean ExtendedTolerance (const Standard_Integer nV, const BOPCol_MapOfInteger& aMI, Standard_Real& aTolVExt, const Standard_Integer aType = 0);
Standard_EXPORT void PutBoundPaveOnCurve (const TopoDS_Face& theF1, const TopoDS_Face& theF2, const Standard_Real theTolR3D, BOPDS_Curve& theNC, BOPCol_ListOfInteger& theLBV); Standard_EXPORT void PutBoundPaveOnCurve(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
BOPDS_Curve& theNC,
BOPCol_ListOfInteger& theLBV);
Standard_EXPORT Standard_Boolean IsExistingPaveBlock Standard_EXPORT Standard_Boolean IsExistingPaveBlock
(const Handle(BOPDS_PaveBlock)& thePB, const BOPDS_Curve& theNC, (const Handle(BOPDS_PaveBlock)& thePB, const BOPDS_Curve& theNC,

326
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -79,9 +79,8 @@
#include <TopoDS_Vertex.hxx> #include <TopoDS_Vertex.hxx>
// //
static void ToleranceFF(const BRepAdaptor_Surface& aBAS1, static Standard_Real ToleranceFF(const BRepAdaptor_Surface& aBAS1,
const BRepAdaptor_Surface& aBAS2, const BRepAdaptor_Surface& aBAS2);
Standard_Real& aTolFF);
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
//======================================================================= //=======================================================================
@ -173,33 +172,30 @@ typedef BOPCol_Cnt
//======================================================================= //=======================================================================
void BOPAlgo_PaveFiller::PerformFF() void BOPAlgo_PaveFiller::PerformFF()
{ {
Standard_Integer iSize; myErrorStatus = 0;
Standard_Boolean bValid;
//
myErrorStatus=0;
// //
myIterator->Initialize(TopAbs_FACE, TopAbs_FACE); myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
iSize=myIterator->ExpectedLength(); Standard_Integer iSize = myIterator->ExpectedLength();
if (!iSize) { if (!iSize) {
return; return;
} }
// //
Standard_Boolean bApp, bCompC2D1, bCompC2D2, bIsDone; BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
Standard_Boolean bToSplit, bTangentFaces;
Standard_Integer nF1, nF2, aNbCurves, aNbPoints, i, aNbLP;
Standard_Integer aNbFaceFace, k;
Standard_Real aApproxTol, aTolR3D, aTolR2D, aTolFF, aTolReal;
BOPCol_MapOfInteger aMI;
BOPAlgo_VectorOfFaceFace aVFaceFace;
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aFFs.SetIncrement(iSize); aFFs.SetIncrement(iSize);
// //
bApp=mySectionAttribute.Approximation(); // Options for the intersection algorithm
bCompC2D1=mySectionAttribute.PCurveOnS1(); Standard_Boolean bApprox = mySectionAttribute.Approximation(),
bCompC2D2=mySectionAttribute.PCurveOnS2(); bCompC2D1 = mySectionAttribute.PCurveOnS1(),
aApproxTol=1.e-7; bCompC2D2 = mySectionAttribute.PCurveOnS2();
bToSplit = Standard_False; Standard_Real anApproxTol = 1.e-7;
// Post-processing options
Standard_Boolean bSplitCurve = Standard_False;
//
// Fence map to store faces with updated FaceInfo structure
BOPCol_MapOfInteger aMIFence;
// Prepare the pairs of faces for intersection
BOPAlgo_VectorOfFaceFace aVFaceFace;
Standard_Integer nF1, nF2;
// //
for (; myIterator->More(); myIterator->Next()) { for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nF1, nF2); myIterator->Value(nF1, nF2);
@ -207,11 +203,11 @@ void BOPAlgo_PaveFiller::PerformFF()
const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1))); const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2))); const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
// //
if (aMI.Add(nF1)) { if (aMIFence.Add(nF1)) {
myDS->UpdateFaceInfoOn(nF1); myDS->UpdateFaceInfoOn(nF1);
myDS->UpdateFaceInfoIn(nF1); myDS->UpdateFaceInfoIn(nF1);
} }
if (aMI.Add(nF2)) { if (aMIFence.Add(nF2)) {
myDS->UpdateFaceInfoOn(nF2); myDS->UpdateFaceInfoOn(nF2);
myDS->UpdateFaceInfoIn(nF2); myDS->UpdateFaceInfoIn(nF2);
} }
@ -220,9 +216,8 @@ void BOPAlgo_PaveFiller::PerformFF()
const BRepAdaptor_Surface& aBAS2 = myContext->SurfaceAdaptor(aF2); const BRepAdaptor_Surface& aBAS2 = myContext->SurfaceAdaptor(aF2);
if (aBAS1.GetType() == GeomAbs_Plane && if (aBAS1.GetType() == GeomAbs_Plane &&
aBAS2.GetType() == GeomAbs_Plane) { aBAS2.GetType() == GeomAbs_Plane) {
Standard_Boolean bToIntersect; // Check if the planes are really interfering
// Standard_Boolean bToIntersect = CheckPlanes(nF1, nF2);
bToIntersect = CheckPlanes(nF1, nF2);
if (!bToIntersect) { if (!bToIntersect) {
BOPDS_InterfFF& aFF=aFFs.Append1(); BOPDS_InterfFF& aFF=aFFs.Append1();
aFF.SetIndices(nF1, nF2); aFF.SetIndices(nF1, nF2);
@ -231,23 +226,23 @@ void BOPAlgo_PaveFiller::PerformFF()
} }
} }
// //
ToleranceFF(aBAS1, aBAS2, aTolFF);
//
if (myGlue == BOPAlgo_GlueOff) { if (myGlue == BOPAlgo_GlueOff) {
BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1(); BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Append1();
// //
aFaceFace.SetIndices(nF1, nF2); aFaceFace.SetIndices(nF1, nF2);
aFaceFace.SetFaces(aF1, aF2); aFaceFace.SetFaces(aF1, aF2);
// compute minimal tolerance for the curves
Standard_Real aTolFF = ToleranceFF(aBAS1, aBAS2);
aFaceFace.SetTolFF(aTolFF); aFaceFace.SetTolFF(aTolFF);
// //
IntSurf_ListOfPntOn2S aListOfPnts; IntSurf_ListOfPntOn2S aListOfPnts;
GetEFPnts(nF1, nF2, aListOfPnts); GetEFPnts(nF1, nF2, aListOfPnts);
aNbLP = aListOfPnts.Extent(); Standard_Integer aNbLP = aListOfPnts.Extent();
if (aNbLP) { if (aNbLP) {
aFaceFace.SetList(aListOfPnts); aFaceFace.SetList(aListOfPnts);
} }
// //
aFaceFace.SetParameters(bApp, bCompC2D1, bCompC2D2, aApproxTol); aFaceFace.SetParameters(bApprox, bCompC2D1, bCompC2D2, anApproxTol);
aFaceFace.SetFuzzyValue(myFuzzyValue); aFaceFace.SetFuzzyValue(myFuzzyValue);
aFaceFace.SetProgressIndicator(myProgressIndicator); aFaceFace.SetProgressIndicator(myProgressIndicator);
} }
@ -255,111 +250,84 @@ void BOPAlgo_PaveFiller::PerformFF()
// for the Glue mode just add all interferences of that type // for the Glue mode just add all interferences of that type
BOPDS_InterfFF& aFF = aFFs.Append1(); BOPDS_InterfFF& aFF = aFFs.Append1();
aFF.SetIndices(nF1, nF2); aFF.SetIndices(nF1, nF2);
aFF.SetTolR3D(Precision::Confusion());
aFF.SetTolR2D(Precision::PConfusion());
aFF.SetTolReal(Precision::Confusion());
aFF.SetTangentFaces(Standard_False); aFF.SetTangentFaces(Standard_False);
aFF.Init(0, 0); aFF.Init(0, 0);
} }
}//for (; myIterator->More(); myIterator->Next()) { }//for (; myIterator->More(); myIterator->Next()) {
// //
aNbFaceFace=aVFaceFace.Extent();
//====================================================== //======================================================
// Perform intersection
BOPAlgo_FaceFaceCnt::Perform(myRunParallel, aVFaceFace); BOPAlgo_FaceFaceCnt::Perform(myRunParallel, aVFaceFace);
//====================================================== //======================================================
// // Treatment of the results
for (k=0; k < aNbFaceFace; ++k) { Standard_Integer k, aNbFaceFace = aVFaceFace.Extent();
BOPAlgo_FaceFace& aFaceFace=aVFaceFace(k); for (k = 0; k < aNbFaceFace; ++k) {
// BOPAlgo_FaceFace& aFaceFace = aVFaceFace(k);
aFaceFace.Indices(nF1, nF2); aFaceFace.Indices(nF1, nF2);
aTolFF=aFaceFace.TolFF(); if (!aFaceFace.IsDone()) {
// BOPDS_InterfFF& aFF = aFFs.Append1();
bIsDone=aFaceFace.IsDone();
if (bIsDone) {
aTolR3D=aFaceFace.TolReached3d();
aTolR2D=aFaceFace.TolReached2d();
aTolReal = aFaceFace.TolReal();
bTangentFaces=aFaceFace.TangentFaces();
//
if (aTolR3D < aTolFF){
aTolR3D=aTolFF;
}
if (aTolReal < aTolFF) {
aTolReal = aTolFF;
}
if (aTolR2D < 1.e-7){
aTolR2D=1.e-7;
}
//
aFaceFace.PrepareLines3D(bToSplit);
//
const IntTools_SequenceOfCurves& aCvsX=aFaceFace.Lines();
const IntTools_SequenceOfPntOn2Faces& aPntsX=aFaceFace.Points();
//
aNbCurves=aCvsX.Length();
aNbPoints=aPntsX.Length();
//
if (aNbCurves || aNbPoints) {
myDS->AddInterf(nF1, nF2);
}
//
BOPDS_InterfFF& aFF=aFFs.Append1();
aFF.SetIndices(nF1, nF2); aFF.SetIndices(nF1, nF2);
// aFF.Init(0, 0);
aFF.SetTolR3D(aTolR3D); continue;
aFF.SetTolR2D(aTolR2D);
aFF.SetTolReal(aTolReal);
aFF.SetTangentFaces(bTangentFaces);
//
// Curves, Points
aFF.Init(aNbCurves, aNbPoints);
//
// Curves
// Fix bounding box expanding coefficient.
Standard_Real aBoxExpandValue = aTolR3D;
if (aNbCurves > 0)
{
// Modify geometric expanding coefficient by topology value,
// since this bounging box used in sharing (vertex or edge).
Standard_Real aMaxVertexTol = Max (BRep_Tool::MaxTolerance(aFaceFace.Face1(), TopAbs_VERTEX),
BRep_Tool::MaxTolerance(aFaceFace.Face2(), TopAbs_VERTEX));
aBoxExpandValue += aMaxVertexTol;
}
BOPDS_VectorOfCurve& aVNC=aFF.ChangeCurves();
for (i=1; i<=aNbCurves; ++i) {
Bnd_Box aBox;
//
const IntTools_Curve& aIC=aCvsX(i);
const Handle(Geom_Curve)& aC3D= aIC.Curve();
bValid=IntTools_Tools::CheckCurve(aC3D, aBoxExpandValue, aBox);
if (bValid) {
BOPDS_Curve& aNC=aVNC.Append1();
aNC.SetCurve(aIC);
aNC.SetBox(aBox);
}
}
//
// Points
BOPDS_VectorOfPoint& aVNP=aFF.ChangePoints();
for (i=1; i<=aNbPoints; ++i) {
const IntTools_PntOn2Faces& aPi=aPntsX(i);
const gp_Pnt& aP=aPi.P1().Pnt();
//
BOPDS_Point& aNP=aVNP.Append1();
aNP.SetPnt(aP);
}
//}// if (aNbCs || aNbPs)
}// if (bIsDone) {
else {// 904/L1
BOPDS_InterfFF& aFF=aFFs.Append1();
aFF.SetIndices(nF1, nF2);
aNbCurves=0;
aNbPoints=0;
aFF.Init(aNbCurves, aNbPoints);
} }
}// for (k=0; k < aNbFaceFace; ++k) { //
Standard_Boolean bTangentFaces = aFaceFace.TangentFaces();
Standard_Real aTolFF = aFaceFace.TolFF();
//
aFaceFace.PrepareLines3D(bSplitCurve);
//
const IntTools_SequenceOfCurves& aCvsX = aFaceFace.Lines();
const IntTools_SequenceOfPntOn2Faces& aPntsX = aFaceFace.Points();
//
Standard_Integer aNbCurves = aCvsX.Length();
Standard_Integer aNbPoints = aPntsX.Length();
//
if (aNbCurves || aNbPoints) {
myDS->AddInterf(nF1, nF2);
}
//
BOPDS_InterfFF& aFF = aFFs.Append1();
aFF.SetIndices(nF1, nF2);
aFF.SetTangentFaces(bTangentFaces);
aFF.Init(aNbCurves, aNbPoints);
//
// Curves
// Fix bounding box expanding coefficient.
Standard_Real aBoxExpandValue = aTolFF;
if (aNbCurves > 0)
{
// Modify geometric expanding coefficient by topology value,
// since this bounding box used in sharing (vertex or edge).
Standard_Real aMaxVertexTol = Max(BRep_Tool::MaxTolerance(aFaceFace.Face1(), TopAbs_VERTEX),
BRep_Tool::MaxTolerance(aFaceFace.Face2(), TopAbs_VERTEX));
aBoxExpandValue += aMaxVertexTol;
}
//
BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves();
for (Standard_Integer i = 1; i <= aNbCurves; ++i) {
Bnd_Box aBox;
const IntTools_Curve& aIC = aCvsX(i);
Standard_Boolean bIsValid = IntTools_Tools::CheckCurve(aIC, aBox);
if (bIsValid) {
BOPDS_Curve& aNC = aVNC.Append1();
aNC.SetCurve(aIC);
// make sure that the bounding box has the maximal gap
aBox.Enlarge(aBoxExpandValue);
aNC.SetBox(aBox);
aNC.SetTolerance(Max(aIC.Tolerance(), aTolFF));
}
}
//
// Points
BOPDS_VectorOfPoint& aVNP = aFF.ChangePoints();
for (Standard_Integer i = 1; i <= aNbPoints; ++i) {
const IntTools_PntOn2Faces& aPi = aPntsX(i);
const gp_Pnt& aP = aPi.P1().Pnt();
//
BOPDS_Point& aNP = aVNP.Append1();
aNP.SetPnt(aP);
}
}
} }
//======================================================================= //=======================================================================
//function : MakeBlocks //function : MakeBlocks
@ -384,7 +352,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
Standard_Boolean bExist, bValid2D; Standard_Boolean bExist, bValid2D;
Standard_Integer i, nF1, nF2, aNbC, aNbP, j; Standard_Integer i, nF1, nF2, aNbC, aNbP, j;
Standard_Integer nV1, nV2; Standard_Integer nV1, nV2;
Standard_Real aTolR3D, aT1, aT2; Standard_Real aT1, aT2;
Handle(NCollection_BaseAllocator) aAllocator; Handle(NCollection_BaseAllocator) aAllocator;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB; BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
TopoDS_Edge aES; TopoDS_Edge aES;
@ -395,7 +363,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
NCollection_BaseAllocator::CommonBaseAllocator(); NCollection_BaseAllocator::CommonBaseAllocator();
// //
BOPCol_ListOfInteger aLSE(aAllocator), aLBV(aAllocator); BOPCol_ListOfInteger aLSE(aAllocator), aLBV(aAllocator);
BOPCol_MapOfInteger aMVOnIn(100, aAllocator), aMF(100, aAllocator), BOPCol_MapOfInteger aMVOnIn(100, aAllocator),
aMVStick(100,aAllocator), aMVEF(100, aAllocator), aMVStick(100,aAllocator), aMVEF(100, aAllocator),
aMI(100, aAllocator), aMVBounds(100, aAllocator); aMI(100, aAllocator), aMVBounds(100, aAllocator);
BOPDS_IndexedMapOfPaveBlock aMPBOnIn(100, aAllocator); BOPDS_IndexedMapOfPaveBlock aMPBOnIn(100, aAllocator);
@ -429,20 +397,10 @@ void BOPAlgo_PaveFiller::MakeBlocks()
const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1))); const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2))); const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
// //
aTolR3D=aFF.TolR3D(); Standard_Real aTolFF = Max(BRep_Tool::Tolerance(aF1), BRep_Tool::Tolerance(aF2));
// //
// Update face info BOPDS_FaceInfo& aFI1 = myDS->ChangeFaceInfo(nF1);
if (aMF.Add(nF1)) { BOPDS_FaceInfo& aFI2 = myDS->ChangeFaceInfo(nF2);
myDS->UpdateFaceInfoOn(nF1);
myDS->UpdateFaceInfoIn(nF1);
}
if (aMF.Add(nF2)) {
myDS->UpdateFaceInfoOn(nF2);
myDS->UpdateFaceInfoIn(nF2);
}
//
BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
// //
aMVOnIn.Clear(); aMVOnIn.Clear();
aMPBOnIn.Clear(); aMPBOnIn.Clear();
@ -463,9 +421,9 @@ void BOPAlgo_PaveFiller::MakeBlocks()
BOPDS_Point& aNP=aVP.ChangeValue(j); BOPDS_Point& aNP=aVP.ChangeValue(j);
const gp_Pnt& aP=aNP.Pnt(); const gp_Pnt& aP=aNP.Pnt();
// //
bExist=IsExistingVertex(aP, aTolR3D, aMVOnIn); bExist=IsExistingVertex(aP, aTolFF, aMVOnIn);
if (!bExist) { if (!bExist) {
BOPTools_AlgoTools::MakeNewVertex(aP, aTolR3D, aV); BOPTools_AlgoTools::MakeNewVertex(aP, aTolFF, aV);
// //
aCPB.SetIndexInterf(i); aCPB.SetIndexInterf(i);
aCPB.SetIndex(j); aCPB.SetIndex(j);
@ -483,13 +441,13 @@ void BOPAlgo_PaveFiller::MakeBlocks()
// DEBt // DEBt
aNC.InitPaveBlock1(); aNC.InitPaveBlock1();
// //
PutPavesOnCurve(aMVOnIn, aTolR3D, aNC, nF1, nF2, aMI, aMVEF, aMVTol, aDMVLV); PutPavesOnCurve(aMVOnIn, aNC, nF1, nF2, aMI, aMVEF, aMVTol, aDMVLV);
} }
// if some E-F vertex was put on a curve due to large E-F intersection range, // if some E-F vertex was put on a curve due to large E-F intersection range,
// and it also was put on another curve correctly then remove this vertex from // and it also was put on another curve correctly then remove this vertex from
// the first curve. Detect such case if the distance to curve exceeds aTolR3D. // the first curve. Detect such case if the distance to curve exceeds aTolR3D.
FilterPavesOnCurves(aVC, aTolR3D); FilterPavesOnCurves(aVC);
for (j = 0; j<aNbC; ++j) { for (j = 0; j<aNbC; ++j) {
BOPDS_Curve& aNC=aVC.ChangeValue(j); BOPDS_Curve& aNC=aVC.ChangeValue(j);
@ -504,7 +462,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
if (aIC.HasBounds()) { if (aIC.HasBounds()) {
aLBV.Clear(); aLBV.Clear();
// //
PutBoundPaveOnCurve(aF1, aF2, aTolR3D, aNC, aLBV); PutBoundPaveOnCurve(aF1, aF2, aNC, aLBV);
// //
if (!aLBV.IsEmpty()) { if (!aLBV.IsEmpty()) {
aDMBV.Bind(j, aLBV); aDMBV.Bind(j, aLBV);
@ -526,6 +484,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
for (j=0; j<aNbC; ++j) { for (j=0; j<aNbC; ++j) {
BOPDS_Curve& aNC=aVC.ChangeValue(j); BOPDS_Curve& aNC=aVC.ChangeValue(j);
const IntTools_Curve& aIC=aNC.Curve(); const IntTools_Curve& aIC=aNC.Curve();
Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
// //
BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks(); BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
Handle(BOPDS_PaveBlock)& aPB1=aNC.ChangePaveBlock1(); Handle(BOPDS_PaveBlock)& aPB1=aNC.ChangePaveBlock1();
@ -587,8 +546,8 @@ void BOPAlgo_PaveFiller::MakeBlocks()
nE = aPBOut->Edge(); nE = aPBOut->Edge();
const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(nE); const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(nE);
aTolE = BRep_Tool::Tolerance(aE); aTolE = BRep_Tool::Tolerance(aE);
if (aTolNew < aFF.TolReal()) if (aTolNew < aNC.Tolerance())
aTolNew = aFF.TolReal(); // use real tolerance of intersection aTolNew = aNC.Tolerance(); // use real tolerance of intersection
if (aTolNew > aTolE) { if (aTolNew > aTolE) {
UpdateEdgeTolerance(nE, aTolNew); UpdateEdgeTolerance(nE, aTolNew);
} }
@ -702,7 +661,6 @@ void BOPAlgo_PaveFiller::MakeBlocks()
PutSEInOtherFaces(); PutSEInOtherFaces();
// //
//-----------------------------------------------------scope t //-----------------------------------------------------scope t
aMF.Clear();
aMVStick.Clear(); aMVStick.Clear();
aMPBOnIn.Clear(); aMPBOnIn.Clear();
aMVOnIn.Clear(); aMVOnIn.Clear();
@ -1035,8 +993,8 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
if (aPDS->IsCommonBlock(aPBRx)) { if (aPDS->IsCommonBlock(aPBRx)) {
const Handle(BOPDS_CommonBlock)& aCB = aPDS->CommonBlock(aPBRx); const Handle(BOPDS_CommonBlock)& aCB = aPDS->CommonBlock(aPBRx);
Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, aPDS, aPF.Context()); Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, aPDS, aPF.Context());
if (aFF.TolReal() < aTol) { if (aNC.Tolerance() < aTol) {
aFF.SetTolReal(aTol); aNC.SetTolerance(aTol);
} }
} }
} }
@ -1425,7 +1383,6 @@ Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
//======================================================================= //=======================================================================
void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1, void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
const TopoDS_Face& aF2, const TopoDS_Face& aF2,
const Standard_Real aTolR3D,
BOPDS_Curve& aNC, BOPDS_Curve& aNC,
BOPCol_ListOfInteger& aLVB) BOPCol_ListOfInteger& aLVB)
{ {
@ -1441,6 +1398,7 @@ void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
// //
const IntTools_Curve& aIC=aNC.Curve(); const IntTools_Curve& aIC=aNC.Curve();
aIC.Bounds(aT[0], aT[1], aP[0], aP[1]); aIC.Bounds(aT[0], aT[1], aP[0], aP[1]);
Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
// //
Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1(); Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
const BOPDS_ListOfPave& aLP=aPB->ExtPaves(); const BOPDS_ListOfPave& aLP=aPB->ExtPaves();
@ -1528,7 +1486,6 @@ void BOPAlgo_PaveFiller::PutBoundPaveOnCurve(const TopoDS_Face& aF1,
//======================================================================= //=======================================================================
void BOPAlgo_PaveFiller::PutPavesOnCurve void BOPAlgo_PaveFiller::PutPavesOnCurve
(const BOPCol_MapOfInteger& aMVOnIn, (const BOPCol_MapOfInteger& aMVOnIn,
const Standard_Real aTolR3D,
BOPDS_Curve& aNC, BOPDS_Curve& aNC,
const Standard_Integer nF1, const Standard_Integer nF1,
const Standard_Integer nF2, const Standard_Integer nF2,
@ -1542,6 +1499,7 @@ void BOPAlgo_PaveFiller::PutPavesOnCurve
BOPCol_MapIteratorOfMapOfInteger aIt; BOPCol_MapIteratorOfMapOfInteger aIt;
// //
const Bnd_Box& aBoxC=aNC.Box(); const Bnd_Box& aBoxC=aNC.Box();
Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
// //
//Put EF vertices first //Put EF vertices first
aIt.Initialize(aMVEF); aIt.Initialize(aMVEF);
@ -1590,13 +1548,11 @@ namespace {
Standard_Real Dist; // square distance from vertex to the paveblock Standard_Real Dist; // square distance from vertex to the paveblock
Standard_Real SinAngle; // sinus of angle between projection vector Standard_Real SinAngle; // sinus of angle between projection vector
// and tangent at projection point // and tangent at projection point
Standard_Real Tolerance; // tolerance of the section curve
}; };
} }
void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC, void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC)
const Standard_Real theTolR3D)
{ {
Standard_Real aSqTol = theTolR3D * theTolR3D;
// For each vertex found in ExtPaves of pave blocks of section curves // For each vertex found in ExtPaves of pave blocks of section curves
// collect list of pave blocks with distance to the curve // collect list of pave blocks with distance to the curve
NCollection_IndexedDataMap<Standard_Integer,NCollection_List<PaveBlockDist> > aIDMVertPBs; NCollection_IndexedDataMap<Standard_Integer,NCollection_List<PaveBlockDist> > aIDMVertPBs;
@ -1606,6 +1562,7 @@ void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC,
{ {
const BOPDS_Curve& aNC = theVNC(i); const BOPDS_Curve& aNC = theVNC(i);
const IntTools_Curve& aIC = aNC.Curve(); const IntTools_Curve& aIC = aNC.Curve();
const Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
GeomAdaptor_Curve aGAC(aIC.Curve()); GeomAdaptor_Curve aGAC(aIC.Curve());
const Handle(BOPDS_PaveBlock)& aPB = aNC.PaveBlocks().First(); const Handle(BOPDS_PaveBlock)& aPB = aNC.PaveBlocks().First();
const BOPDS_ListOfPave& aPaves = aPB->ExtPaves(); const BOPDS_ListOfPave& aPaves = aPB->ExtPaves();
@ -1630,7 +1587,7 @@ void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC,
NCollection_List<PaveBlockDist>* pList = aIDMVertPBs.ChangeSeek(nV); NCollection_List<PaveBlockDist>* pList = aIDMVertPBs.ChangeSeek(nV);
if (!pList) if (!pList)
pList = &aIDMVertPBs.ChangeFromIndex(aIDMVertPBs.Add(nV, NCollection_List<PaveBlockDist>())); pList = &aIDMVertPBs.ChangeFromIndex(aIDMVertPBs.Add(nV, NCollection_List<PaveBlockDist>()));
PaveBlockDist aPBD = { aPB, aSqDist, aSin }; PaveBlockDist aPBD = { aPB, aSqDist, aSin, aTolR3D };
pList->Append(aPBD); pList->Append(aPBD);
} }
} }
@ -1658,10 +1615,10 @@ void BOPAlgo_PaveFiller::FilterPavesOnCurves(const BOPDS_VectorOfCurve& theVNC,
// and there are other pave blocks for which the distance is less than the current. // and there are other pave blocks for which the distance is less than the current.
// Do not remove a vertex if it is projected on the curve with quite large angle // Do not remove a vertex if it is projected on the curve with quite large angle
// (see test bugs modalg_6 bug27761). // (see test bugs modalg_6 bug27761).
Standard_Real aCheckDist = 100. * Max(aSqTol, aMinDist);
for (itL.Init(aList); itL.More(); itL.Next()) for (itL.Init(aList); itL.More(); itL.Next())
{ {
const PaveBlockDist& aPBD = itL.Value(); const PaveBlockDist& aPBD = itL.Value();
Standard_Real aCheckDist = 100. * Max(aPBD.Tolerance*aPBD.Tolerance, aMinDist);
if (aPBD.Dist > aCheckDist && aPBD.SinAngle < aSinAngleMin) if (aPBD.Dist > aCheckDist && aPBD.SinAngle < aSinAngleMin)
{ {
aPBD.PB->RemoveExtPave(nV); aPBD.PB->RemoveExtPave(nV);
@ -2667,23 +2624,19 @@ void BOPAlgo_PaveFiller::RemovePaveBlocks(const BOPCol_MapOfInteger theEdges)
} }
} }
} }
//======================================================================= //=======================================================================
//function : ToleranceFF //function : ToleranceFF
//purpose : Computes the TolFF according to the tolerance value and //purpose : Computes the TolFF according to the tolerance value and
// types of the faces. // types of the faces.
//======================================================================= //=======================================================================
void ToleranceFF(const BRepAdaptor_Surface& aBAS1, Standard_Real ToleranceFF(const BRepAdaptor_Surface& aBAS1,
const BRepAdaptor_Surface& aBAS2, const BRepAdaptor_Surface& aBAS2)
Standard_Real& aTolFF)
{ {
Standard_Real aTol1, aTol2; Standard_Real aTol1 = aBAS1.Tolerance();
Standard_Real aTol2 = aBAS2.Tolerance();
Standard_Real aTolFF = Max(aTol1, aTol2);
//
Standard_Boolean isAna1, isAna2; Standard_Boolean isAna1, isAna2;
//
aTol1 = aBAS1.Tolerance();
aTol2 = aBAS2.Tolerance();
aTolFF = Max(aTol1, aTol2);
//
isAna1 = (aBAS1.GetType() == GeomAbs_Plane || isAna1 = (aBAS1.GetType() == GeomAbs_Plane ||
aBAS1.GetType() == GeomAbs_Cylinder || aBAS1.GetType() == GeomAbs_Cylinder ||
aBAS1.GetType() == GeomAbs_Cone || aBAS1.GetType() == GeomAbs_Cone ||
@ -2699,6 +2652,7 @@ void BOPAlgo_PaveFiller::RemovePaveBlocks(const BOPCol_MapOfInteger theEdges)
if (!isAna1 || !isAna2) { if (!isAna1 || !isAna2) {
aTolFF = Max(aTolFF, 5.e-6); aTolFF = Max(aTolFF, 5.e-6);
} }
return aTolFF;
} }
//======================================================================= //=======================================================================
//function : UpdateBlocksWithSharedVertices //function : UpdateBlocksWithSharedVertices
@ -2722,7 +2676,7 @@ void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
// //
Standard_Boolean bOnCurve, bHasShapeSD; Standard_Boolean bOnCurve, bHasShapeSD;
Standard_Integer i, nF1, nF2, aNbC, j, nV, nVSD; Standard_Integer i, nF1, nF2, aNbC, j, nV, nVSD;
Standard_Real aTolR3D, aTolV; Standard_Real aTolV;
BOPCol_MapOfInteger aMF; BOPCol_MapOfInteger aMF;
// //
for (i=0; i<aNbFF; ++i) { for (i=0; i<aNbFF; ++i) {
@ -2735,7 +2689,6 @@ void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
} }
// //
aFF.Indices(nF1, nF2); aFF.Indices(nF1, nF2);
aTolR3D=aFF.TolR3D();
// //
if (aMF.Add(nF1)) { if (aMF.Add(nF1)) {
myDS->UpdateFaceInfoOn(nF1); myDS->UpdateFaceInfoOn(nF1);
@ -2773,7 +2726,7 @@ void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
// Try to put vertices aMI on curves // Try to put vertices aMI on curves
for (j=0; j<aNbC; ++j) { for (j=0; j<aNbC; ++j) {
BOPDS_Curve& aNC=aVC.ChangeValue(j); BOPDS_Curve& aNC=aVC.ChangeValue(j);
//const IntTools_Curve& aIC=aNC.Curve(); Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
// //
aItMI.Initialize(aMI); aItMI.Initialize(aMI);
for (; aItMI.More(); aItMI.Next()) { for (; aItMI.More(); aItMI.Next()) {
@ -2832,10 +2785,7 @@ void BOPAlgo_PaveFiller::CorrectToleranceOfSE()
Standard_Integer aNb = aFFs.Extent(), i; Standard_Integer aNb = aFFs.Extent(), i;
for (i = 0; i < aNb; ++i) { for (i = 0; i < aNb; ++i) {
BOPDS_InterfFF& aFF = aFFs(i); BOPDS_InterfFF& aFF = aFFs(i);
Standard_Real aTolR3D = aFF.TolR3D(); //
Standard_Real aTolReal = aFF.TolReal();
Standard_Boolean bToReduce = aTolReal < aTolR3D;
// tolerance of intersection has been increased, so process this intersection
BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves(); BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves();
Standard_Integer aNbC = aVNC.Extent(), k; Standard_Integer aNbC = aVNC.Extent(), k;
for (k = 0; k < aNbC; ++k) { for (k = 0; k < aNbC; ++k) {
@ -2851,13 +2801,25 @@ void BOPAlgo_PaveFiller::CorrectToleranceOfSE()
} }
// //
Standard_Boolean bIsReduced = Standard_False; Standard_Boolean bIsReduced = Standard_False;
if (bToReduce && (aPB->OriginalEdge() < 0)) { if (aPB->OriginalEdge() < 0) {
const TopoDS_Edge& aE = TopoDS::Edge(myDS->Shape(nE)); // It is possible that due to small angle between faces the
Standard_Real aTolE = BRep_Tool::Tolerance(aE); // common zone between faces can be large and the tangential
if (aTolReal < aTolE) { // tolerance of the curve will be large as well.
// reduce edge tolerance // Here we're trying to reduce the tolerance of the section
reinterpret_cast<BRep_TEdge*>(aE.TShape().operator->())->Tolerance(aTolReal); // edge using the valid tolerance of the edge.
bIsReduced = Standard_True; // Note, that if the pave block has created common block with
// other edges its valid tolerance could have been changed to
// cover all edges in common block (see PostTreatFF() method).
Standard_Real aTolC = aNC.Tolerance();
Standard_Real aTolTang = aNC.TangentialTolerance();
if (aTolC < aTolTang) {
const TopoDS_Edge& aE = TopoDS::Edge(myDS->Shape(nE));
Standard_Real aTolE = BRep_Tool::Tolerance(aE);
if (aTolC < aTolE) {
// reduce edge tolerance
reinterpret_cast<BRep_TEdge*>(aE.TShape().operator->())->Tolerance(aTolC);
bIsReduced = Standard_True;
}
} }
} }
// //

28
src/BOPDS/BOPDS_Curve.hxx
View File

@ -118,33 +118,37 @@ virtual ~BOPDS_Curve();
//! has edge //! has edge
Standard_Boolean HasEdge() const; Standard_Boolean HasEdge() const;
//! Sets the tolerance for the curve.
void SetTolerance(const Standard_Real theTol)
{
myTolerance = theTol;
}
//! Returns the tolerance of the curve
Standard_Real Tolerance() const
{
return myTolerance;
}
//! Returns the tangential tolerance of the curve
Standard_Real TangentialTolerance() const
{
return myCurve.TangentialTolerance();
}
protected: protected:
BOPCol_BaseAllocator myAllocator; BOPCol_BaseAllocator myAllocator;
IntTools_Curve myCurve; IntTools_Curve myCurve;
BOPDS_ListOfPaveBlock myPaveBlocks; BOPDS_ListOfPaveBlock myPaveBlocks;
BOPCol_ListOfInteger myTechnoVertices; BOPCol_ListOfInteger myTechnoVertices;
Bnd_Box myBox; Bnd_Box myBox;
Standard_Real myTolerance;
private: private:
}; };
#include <BOPDS_Curve.lxx> #include <BOPDS_Curve.lxx>
#endif // _BOPDS_Curve_HeaderFile #endif // _BOPDS_Curve_HeaderFile

6
src/BOPDS/BOPDS_Curve.lxx
View File

@ -22,7 +22,8 @@
: :
myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()), myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
myPaveBlocks(myAllocator), myPaveBlocks(myAllocator),
myTechnoVertices(myAllocator) myTechnoVertices(myAllocator),
myTolerance(0.)
{ {
} }
//======================================================================= //=======================================================================
@ -33,7 +34,8 @@
: :
myAllocator(theAllocator), myAllocator(theAllocator),
myPaveBlocks(myAllocator), myPaveBlocks(myAllocator),
myTechnoVertices(myAllocator) myTechnoVertices(myAllocator),
myTolerance(0.)
{ {
} }
//======================================================================= //=======================================================================

78
src/BOPDS/BOPDS_Interf.hxx
View File

@ -494,9 +494,6 @@ class BOPDS_InterfFF : public BOPDS_Interf {
: :
BOPDS_Interf(), BOPDS_Interf(),
myTangentFaces(Standard_False), myTangentFaces(Standard_False),
myTolR3D(1.e-7),
myTolR2D(1.e-7),
myTolReal(1.e-7),
myCurves(0, myAllocator), myCurves(0, myAllocator),
myPoints(0, myAllocator) myPoints(0, myAllocator)
{ {
@ -518,26 +515,12 @@ class BOPDS_InterfFF : public BOPDS_Interf {
void Init(const Standard_Integer theNbCurves, void Init(const Standard_Integer theNbCurves,
const Standard_Integer theNbPoints) { const Standard_Integer theNbPoints) {
//modified by NIZNHY-PKV Mon Jan 26 09:01:06 2015f
if (theNbCurves>0) { if (theNbCurves>0) {
myCurves.SetIncrement(theNbCurves); myCurves.SetIncrement(theNbCurves);
} }
if (theNbPoints>0) { if (theNbPoints>0) {
myPoints.SetIncrement(theNbPoints); myPoints.SetIncrement(theNbPoints);
} }
/*
if (theNbCurves>0) {
myCurves.SetStartSize(theNbCurves);
myCurves.SetIncrement(theNbCurves);
myCurves.Init();
}
if (theNbPoints>0) {
myPoints.SetStartSize(theNbPoints);
myPoints.SetIncrement(theNbPoints);
myPoints.Init();
}
*/
//modified by NIZNHY-PKV Mon Jan 26 09:01:12 2015t
} }
/** /**
* Modifier * Modifier
@ -557,64 +540,6 @@ class BOPDS_InterfFF : public BOPDS_Interf {
Standard_Boolean TangentFaces()const { Standard_Boolean TangentFaces()const {
return myTangentFaces; return myTangentFaces;
} }
/**
* Modifier
* Sets the value of 3D tolerance
* @param theTol
* 3D tolerance
*/
void SetTolR3D(const Standard_Real theTol) {
myTolR3D=theTol;
}
//
/**
* Selector
* Returns the value of 3D tolerance
* @return
* 3D tolerance
*/
Standard_Real TolR3D()const {
return myTolR3D;
}
//
/**
* Modifier
* Sets the value of 2D tolerance
* @param theTol
* 2D tolerance
*/
void SetTolR2D(const Standard_Real theTol) {
myTolR2D=theTol;;
}
//
/**
* Selector
* Returns the value of 2D tolerance
* @return
* 2D tolerance
*/
Standard_Real TolR2D()const {
return myTolR2D;
}
/**
* Modifier
* Sets the value of real not increased 3D tolerance
* @param theTol
* 3D tolerance
*/
void SetTolReal(const Standard_Real theTol) {
myTolReal = theTol;
}
//
/**
* Selector
* Returns the value of real not increased 3D tolerance
* @return
* 3D tolerance
*/
Standard_Real TolReal()const {
return myTolReal;
}
// //
/** /**
* Selector * Selector
@ -658,9 +583,6 @@ class BOPDS_InterfFF : public BOPDS_Interf {
// //
protected: protected:
Standard_Boolean myTangentFaces; Standard_Boolean myTangentFaces;
Standard_Real myTolR3D;
Standard_Real myTolR2D;
Standard_Real myTolReal;
BOPDS_VectorOfCurve myCurves; BOPDS_VectorOfCurve myCurves;
BOPDS_VectorOfPoint myPoints; BOPDS_VectorOfPoint myPoints;
}; };

48
src/BOPTest/BOPTest_BOPCommands.cxx
View File

@ -104,7 +104,8 @@ static Standard_Integer mkvolume (Draw_Interpretor&, Standard_Integer, const c
theCommands.Add("bsection", "use bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]", theCommands.Add("bsection", "use bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]",
__FILE__, bsection, g); __FILE__, bsection, g);
// //
theCommands.Add("bopcurves", "use bopcurves F1 F2 [-2d/-2d1/-2d2] [-p u1 v1 u2 v2]", theCommands.Add("bopcurves", "use bopcurves F1 F2 [-2d/-2d1/-2d2] "
"[-p u1 v1 u2 v2 (to add start points] [-v (for extended output)]",
__FILE__, bopcurves, g); __FILE__, bopcurves, g);
theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-c] [-ni] [-ai]", theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-c] [-ni] [-ai]",
__FILE__, mkvolume , g); __FILE__, mkvolume , g);
@ -544,7 +545,8 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
const char** a) const char** a)
{ {
if (n<3) { if (n<3) {
di << " use bopcurves F1 F2 [-2d/-2d1/-2d2]\n"; di << "Usage: bopcurves F1 F2 [-2d/-2d1/-2d2] "
"[-p u1 v1 u2 v2 (to add start points] [-v (for extended output)]\n";
return 1; return 1;
} }
// //
@ -553,7 +555,7 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
TopAbs_ShapeEnum aType; TopAbs_ShapeEnum aType;
// //
if (S1.IsNull() || S2.IsNull()) { if (S1.IsNull() || S2.IsNull()) {
di << " Null shapes is not allowed \n"; di << " Null shapes are not allowed \n";
return 1; return 1;
} }
// //
@ -573,7 +575,7 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
// //
Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone; Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone;
Standard_Integer aNbCurves, aNbPoints; Standard_Integer aNbCurves, aNbPoints;
Standard_Real anAppTol, aTolR; Standard_Real anAppTol;
IntSurf_ListOfPntOn2S aListOfPnts; IntSurf_ListOfPntOn2S aListOfPnts;
TCollection_AsciiString aNm("c_"), aNp("p_"); TCollection_AsciiString aNm("c_"), aNp("p_");
// //
@ -583,6 +585,7 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
aToApproxC2dOnS2 = Standard_False; aToApproxC2dOnS2 = Standard_False;
// //
Standard_Boolean bExtOut = Standard_False;
for(Standard_Integer i = 3; i < n; i++) for(Standard_Integer i = 3; i < n; i++)
{ {
if (!strcasecmp(a[i],"-2d")) { if (!strcasecmp(a[i],"-2d")) {
@ -605,13 +608,17 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
aPt.SetValue(aU1, aV1, aU2, aV2); aPt.SetValue(aU1, aV1, aU2, aV2);
aListOfPnts.Append(aPt); aListOfPnts.Append(aPt);
} }
else if (!strcasecmp(a[i],"-v")) {
bExtOut = Standard_True;
}
else { else {
di << "Wrong key. To build 2d curves use: bopcurves F1 F2 [-2d/-2d1/-2d2] [-p u1 v1 u2 v2]\n"; di << "Wrong key.\n";
di << "To build 2d curves use one of the following keys: -2d/-2d1/-2d2\n";
di << "To add start points use the following key: -p u1 v1 u2 v2\n";
di << "For extended output use the following key: -v\n";
return 1; return 1;
} }
} }
// //
IntTools_FaceFace aFF; IntTools_FaceFace aFF;
// //
@ -625,7 +632,7 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
// //
anIsDone=aFF.IsDone(); anIsDone=aFF.IsDone();
if (!anIsDone) { if (!anIsDone) {
di << "Error: anIsDone=" << (Standard_Integer) anIsDone << "\n"; di << "Error: Intersection failed\n";
return 0; return 0;
} }
// //
@ -641,11 +648,20 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
return 0; return 0;
} }
// //
aTolR=aFF.TolReached3d();
di << "Tolerance Reached=" << aTolR << "\n";
//
// curves // curves
if (aNbCurves) { if (aNbCurves) {
Standard_Real aTolR = 0.;
if (!bExtOut) {
// find maximal tolerance
for (Standard_Integer i = 1; i <= aNbCurves; i++) {
const IntTools_Curve& anIC = aSCs(i);
if (aTolR < anIC.Tolerance()) {
aTolR = anIC.Tolerance();
}
}
di << "Tolerance Reached=" << aTolR << "\n";
}
//
di << aNbCurves << " curve(s) found.\n"; di << aNbCurves << " curve(s) found.\n";
// //
for (Standard_Integer i=1; i<=aNbCurves; i++) { for (Standard_Integer i=1; i<=aNbCurves; i++) {
@ -695,8 +711,16 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
} }
di << ") "; di << ") ";
} }
//
if (bExtOut) {
di << "\nTolerance: " << anIC.Tolerance() << "\n";
di << "Tangential tolerance: " << anIC.TangentialTolerance() << "\n";
di << "\n";
}
}
if (!bExtOut) {
di << "\n";
} }
di << "\n";
} }
// //
// points // points

1
src/IntTools/FILES
View File

@ -20,7 +20,6 @@ IntTools_Context.cxx
IntTools_Context.hxx IntTools_Context.hxx
IntTools_Curve.cxx IntTools_Curve.cxx
IntTools_Curve.hxx IntTools_Curve.hxx
IntTools_Curve.lxx
IntTools_CurveRangeLocalizeData.cxx IntTools_CurveRangeLocalizeData.cxx
IntTools_CurveRangeLocalizeData.hxx IntTools_CurveRangeLocalizeData.hxx
IntTools_CurveRangeLocalizeData.lxx IntTools_CurveRangeLocalizeData.lxx

86
src/IntTools/IntTools_Curve.cxx
View File

@ -12,105 +12,91 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <IntTools_Curve.hxx>
#include <Geom2d_Curve.hxx> #include <Geom2d_Curve.hxx>
#include <Geom_BoundedCurve.hxx> #include <Geom_BoundedCurve.hxx>
#include <Geom_Curve.hxx> #include <Geom_Curve.hxx>
#include <GeomAdaptor_Curve.hxx> #include <GeomAdaptor_Curve.hxx>
#include <gp_Pnt.hxx> #include <gp_Pnt.hxx>
#include <IntTools_Curve.hxx>
//======================================================================= //=======================================================================
//function : IntTools_Curve::IntTools_Curve //function : IntTools_Curve::IntTools_Curve
//purpose : //purpose :
//======================================================================= //=======================================================================
IntTools_Curve::IntTools_Curve() IntTools_Curve::IntTools_Curve()
:
myTolerance(0.0),
myTangentialTolerance(0.0)
{ {
} }
//======================================================================= //=======================================================================
//function : IntTools_Curve::IntTools_Curve //function : IntTools_Curve::IntTools_Curve
//purpose : //purpose :
//======================================================================= //=======================================================================
IntTools_Curve::IntTools_Curve(const Handle(Geom_Curve)& Curve3d, IntTools_Curve::IntTools_Curve(const Handle(Geom_Curve)& the3dCurve,
const Handle(Geom2d_Curve)& FirstCurve2d, const Handle(Geom2d_Curve)& the2dCurve1,
const Handle(Geom2d_Curve)& SecondCurve2d) const Handle(Geom2d_Curve)& the2dCurve2,
const Standard_Real theTolerance,
const Standard_Real theTangentialTolerance)
:
myTolerance(theTolerance),
myTangentialTolerance(theTangentialTolerance)
{ {
SetCurves(Curve3d, FirstCurve2d, SecondCurve2d); SetCurves(the3dCurve, the2dCurve1, the2dCurve2);
} }
//=======================================================================
//function : SetCurves
//purpose :
//=======================================================================
void IntTools_Curve::SetCurves(const Handle(Geom_Curve)& Curve3d,
const Handle(Geom2d_Curve)& FirstCurve2d,
const Handle(Geom2d_Curve)& SecondCurve2d)
{
SetCurve(Curve3d);
SetFirstCurve2d(FirstCurve2d);
SetSecondCurve2d(SecondCurve2d);
}
//======================================================================= //=======================================================================
//function : HasBounds //function : HasBounds
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Curve::HasBounds() const Standard_Boolean IntTools_Curve::HasBounds() const
{ {
Standard_Boolean bBounded;
Handle(Geom_BoundedCurve) aC3DBounded = Handle(Geom_BoundedCurve) aC3DBounded =
Handle(Geom_BoundedCurve)::DownCast(my3dCurve); Handle(Geom_BoundedCurve)::DownCast(my3dCurve);
Standard_Boolean bIsBounded = !aC3DBounded.IsNull();
bBounded=!aC3DBounded.IsNull(); return bIsBounded;
return bBounded ;
} }
//======================================================================= //=======================================================================
//function : Bounds //function : Bounds
//purpose : //purpose :
//======================================================================= //=======================================================================
void IntTools_Curve::Bounds(Standard_Real& aT1, Standard_Boolean IntTools_Curve::Bounds(Standard_Real& theFirst,
Standard_Real& aT2, Standard_Real& theLast,
gp_Pnt& aP1, gp_Pnt& theFirstPnt,
gp_Pnt& aP2) const gp_Pnt& theLastPnt) const
{ {
aT1=0.; Standard_Boolean bIsBounded = HasBounds();
aT2=0.; if (bIsBounded) {
aP1.SetCoord(0.,0.,0.); theFirst = my3dCurve->FirstParameter();
aP2.SetCoord(0.,0.,0.); theLast = my3dCurve->LastParameter();
if (HasBounds()) { my3dCurve->D0(theFirst, theFirstPnt);
aT1=my3dCurve->FirstParameter(); my3dCurve->D0(theLast, theLastPnt);
aT2=my3dCurve->LastParameter();
my3dCurve->D0(aT1, aP1);
my3dCurve->D0(aT2, aP2);
} }
return bIsBounded;
} }
//======================================================================= //=======================================================================
//function : D0 //function : D0
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Curve::D0(Standard_Real& aT, Standard_Boolean IntTools_Curve::D0(const Standard_Real& thePar,
gp_Pnt& aP) const gp_Pnt& thePnt) const
{ {
Standard_Real aF, aL; Standard_Boolean bInside = !(thePar < my3dCurve->FirstParameter() &&
thePar > my3dCurve->LastParameter());
aF=my3dCurve->FirstParameter(); if (bInside) {
aL=my3dCurve->LastParameter(); my3dCurve->D0(thePar, thePnt);
if (aT<aF || aT>aL) {
return Standard_False;
} }
my3dCurve->D0(aT, aP); return bInside;
return Standard_True;
} }
//======================================================================= //=======================================================================
//function : D0 //function : Type
//purpose : //purpose :
//======================================================================= //=======================================================================
GeomAbs_CurveType IntTools_Curve::Type() const GeomAbs_CurveType IntTools_Curve::Type() const
{ {
GeomAdaptor_Curve aGAC(my3dCurve); GeomAdaptor_Curve aGAC(my3dCurve);
GeomAbs_CurveType aType=aGAC.GetType(); GeomAbs_CurveType aType = aGAC.GetType();
return aType; return aType;
} }

166
src/IntTools/IntTools_Curve.hxx
View File

@ -27,103 +27,133 @@ class Geom_Curve;
class Geom2d_Curve; class Geom2d_Curve;
class gp_Pnt; class gp_Pnt;
//! The class is a container of one 3D curve, two 2D curves and two Tolerance values.<br>
//! class is a container of //! It is used in the Face/Face intersection algorithm to store the results
//! one 3d curve //! of intersection. In this context:<br>
//! two 2d curves //! **the 3D curve** is the intersection curve;<br>
class IntTools_Curve //! **the 2D curves** are the PCurves of the 3D curve on the intersecting faces;<br>
//! **the tolerance** is the valid tolerance for 3D curve computed as
//! maximal deviation between 3D curve and 2D curves (or surfaces in case there are no 2D curves);<br>
//! **the tangential tolerance** is the maximal distance from 3D curve to the
//! end of the tangential zone between faces in terms of their tolerance values.
class IntTools_Curve
{ {
public: public:
DEFINE_STANDARD_ALLOC DEFINE_STANDARD_ALLOC
//! Empty constructor //! Empty constructor
Standard_EXPORT IntTools_Curve(); Standard_EXPORT IntTools_Curve();
//! Initializes me by a 3d curve //! Constructor taking 3d curve, two 2d curves and two tolerance values
//! and two 2d curves Standard_EXPORT IntTools_Curve(const Handle(Geom_Curve)& the3dCurve3d,
Standard_EXPORT IntTools_Curve(const Handle(Geom_Curve)& Curve3d, const Handle(Geom2d_Curve)& FirstCurve2d, const Handle(Geom2d_Curve)& SecondCurve2d); const Handle(Geom2d_Curve)& the2dCurve1,
const Handle(Geom2d_Curve)& the2dCurve2,
const Standard_Real theTolerance = 0.0,
const Standard_Real theTangentialTolerance = 0.0);
//! Modifier //! Sets the curves
Standard_EXPORT void SetCurves (const Handle(Geom_Curve)& Curve3d, const Handle(Geom2d_Curve)& FirstCurve2d, const Handle(Geom2d_Curve)& SecondCurve2d); void SetCurves(const Handle(Geom_Curve)& the3dCurve,
const Handle(Geom2d_Curve)& the2dCurve1,
const Handle(Geom2d_Curve)& the2dCurve2)
{
my3dCurve = the3dCurve;
my2dCurve1 = the2dCurve1;
my2dCurve2 = the2dCurve2;
}
//! Modifier //! Sets the 3d curve
void SetCurve (const Handle(Geom_Curve)& Curve3d); void SetCurve(const Handle(Geom_Curve)& the3dCurve)
{
my3dCurve = the3dCurve;
}
//! Modifier //! Sets the first 2d curve
void SetFirstCurve2d (const Handle(Geom2d_Curve)& FirstCurve2d); void SetFirstCurve2d(const Handle(Geom2d_Curve)& the2dCurve1)
{
my2dCurve1 = the2dCurve1;
}
//! Modifier //! Sets the second 2d curve
void SetSecondCurve2d (const Handle(Geom2d_Curve)& SecondCurve2d); void SetSecondCurve2d(const Handle(Geom2d_Curve)& the2dCurve2)
{
my2dCurve2 = the2dCurve2;
}
//! Selector //! Sets the tolerance for the curve
const Handle(Geom_Curve)& Curve() const; void SetTolerance(const Standard_Real theTolerance)
{
myTolerance = theTolerance;
}
//! Selector //! Sets the tangential tolerance
const Handle(Geom2d_Curve)& FirstCurve2d() const; void SetTangentialTolerance(const Standard_Real theTangentialTolerance)
{
myTangentialTolerance = theTangentialTolerance;
}
//! Selector //! Returns 3d curve
const Handle(Geom2d_Curve)& SecondCurve2d() const; const Handle(Geom_Curve)& Curve() const
{
return my3dCurve;
}
//! Returns true if 3d curve is BoundedCurve from Geom //! Returns first 2d curve
const Handle(Geom2d_Curve)& FirstCurve2d() const
{
return my2dCurve1;
}
//! Returns second 2d curve
const Handle(Geom2d_Curve)& SecondCurve2d() const
{
return my2dCurve2;
}
//! Returns the tolerance
Standard_Real Tolerance() const
{
return myTolerance;
}
//! Returns the tangential tolerance
Standard_Real TangentialTolerance() const
{
return myTangentialTolerance;
}
//! Returns TRUE if 3d curve is BoundedCurve
Standard_EXPORT Standard_Boolean HasBounds() const; Standard_EXPORT Standard_Boolean HasBounds() const;
//! Returns boundary parameters //! If the 3d curve is bounded curve the method will return TRUE
//! and corresponded 3d point. //! and modify the output parameters with boundary parameters of
//! //! the curve and corresponded 3d points.<br>
//! Warning: //! If the curve does not have bounds, the method will return false
//! If HasBounds returns false //! and the output parameters will stay untouched.
//! the returned parameters are equal Standard_EXPORT Standard_Boolean Bounds(Standard_Real& theFirst,
//! to zero. Standard_Real& theLast,
Standard_EXPORT void Bounds (Standard_Real& aT1, Standard_Real& aT2, gp_Pnt& aP1, gp_Pnt& aP2) const; gp_Pnt& theFirstPnt,
gp_Pnt& theLastPnt) const;
//! Computes 3d point corresponded to parameter aT1 //! Computes 3d point corresponded to the given parameter if this
//! Returns true if given parameter aT1 //! parameter is inside the boundaries of the curve.
//! is inside the boundaries of the curve //! Returns TRUE in this case. <br>
Standard_EXPORT Standard_Boolean D0 (Standard_Real& aT1, gp_Pnt& aP1) const; //! Otherwise, the point will not be computed and the method will return FALSE.
Standard_EXPORT Standard_Boolean D0(const Standard_Real& thePar,
gp_Pnt& thePnt) const;
//! Returns the type of 3d curve //! Returns the type of the 3d curve
Standard_EXPORT GeomAbs_CurveType Type() const; Standard_EXPORT GeomAbs_CurveType Type() const;
protected: protected:
private: private:
Handle(Geom_Curve) my3dCurve; Handle(Geom_Curve) my3dCurve;
Handle(Geom2d_Curve) my2dCurve1; Handle(Geom2d_Curve) my2dCurve1;
Handle(Geom2d_Curve) my2dCurve2; Handle(Geom2d_Curve) my2dCurve2;
Standard_Real myTolerance;
Standard_Real myTangentialTolerance;
}; };
#include <IntTools_Curve.lxx>
#endif // _IntTools_Curve_HeaderFile #endif // _IntTools_Curve_HeaderFile

66
src/IntTools/IntTools_Curve.lxx
View File

@ -1,66 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
//function : SetCurve
//purpose :
//=======================================================================
inline void IntTools_Curve::SetCurve(const Handle(Geom_Curve)& Curve3d)
{
my3dCurve = Curve3d;
}
//=======================================================================
//function : SetFirstCurve2d
//purpose :
//=======================================================================
inline void IntTools_Curve::SetFirstCurve2d(const Handle(Geom2d_Curve)& FirstCurve2d)
{
my2dCurve1 = FirstCurve2d;
}
//=======================================================================
//function : SetSecondCurve2d
//purpose :
//=======================================================================
inline void IntTools_Curve::SetSecondCurve2d(const Handle(Geom2d_Curve)& SecondCurve2d)
{
my2dCurve2 = SecondCurve2d;
}
//=======================================================================
//function : Curve
//purpose :
//=======================================================================
inline const Handle(Geom_Curve)& IntTools_Curve::Curve() const
{
return my3dCurve;
}
//=======================================================================
//function : FirstCurve2d
//purpose :
//=======================================================================
inline const Handle(Geom2d_Curve)& IntTools_Curve::FirstCurve2d() const
{
return my2dCurve1;
}
//=======================================================================
//function : SecondCurve2d
//purpose :
//=======================================================================
inline const Handle(Geom2d_Curve)& IntTools_Curve::SecondCurve2d() const
{
return my2dCurve2;
}

430
src/IntTools/IntTools_FaceFace.cxx
View File

@ -55,11 +55,6 @@
#include <TopoDS_Edge.hxx> #include <TopoDS_Edge.hxx>
#include <gp_Elips.hxx> #include <gp_Elips.hxx>
static
void TolR3d(const Standard_Real aTolF1,
const Standard_Real aTolF2,
Standard_Real& myTolReached3d);
static static
void Parameters(const Handle(GeomAdaptor_HSurface)&, void Parameters(const Handle(GeomAdaptor_HSurface)&,
const Handle(GeomAdaptor_HSurface)&, const Handle(GeomAdaptor_HSurface)&,
@ -95,17 +90,16 @@ static
Standard_Boolean ApproxWithPCurves(const gp_Cylinder& theCyl, Standard_Boolean ApproxWithPCurves(const gp_Cylinder& theCyl,
const gp_Sphere& theSph); const gp_Sphere& theSph);
static void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1, static void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
const Handle(GeomAdaptor_HSurface)& theS2, const Handle(GeomAdaptor_HSurface)& theS2,
const Standard_Real TolF1, const Standard_Real TolF1,
const Standard_Real TolF2, const Standard_Real TolF2,
const Standard_Real TolAng, const Standard_Real TolAng,
const Standard_Real TolTang, const Standard_Real TolTang,
const Standard_Boolean theApprox1, const Standard_Boolean theApprox1,
const Standard_Boolean theApprox2, const Standard_Boolean theApprox2,
IntTools_SequenceOfCurves& theSeqOfCurve, IntTools_SequenceOfCurves& theSeqOfCurve,
Standard_Boolean& theTangentFaces, Standard_Boolean& theTangentFaces);
Standard_Real& TolReached3d);
static Standard_Boolean ClassifyLin2d(const Handle(GeomAdaptor_HSurface)& theS, static Standard_Boolean ClassifyLin2d(const Handle(GeomAdaptor_HSurface)& theS,
const gp_Lin2d& theLin2d, const gp_Lin2d& theLin2d,
@ -173,9 +167,6 @@ IntTools_FaceFace::IntTools_FaceFace()
// //
myHS1 = new GeomAdaptor_HSurface (); myHS1 = new GeomAdaptor_HSurface ();
myHS2 = new GeomAdaptor_HSurface (); myHS2 = new GeomAdaptor_HSurface ();
myTolReached2d=0.;
myTolReached3d=0.;
myTolReal = 0.;
myTolF1 = 0.; myTolF1 = 0.;
myTolF2 = 0.; myTolF2 = 0.;
myTol = 0.; myTol = 0.;
@ -239,22 +230,6 @@ Standard_Boolean IntTools_FaceFace::IsDone() const
return myIsDone; return myIsDone;
} }
//======================================================================= //=======================================================================
//function : TolReached3d
//purpose :
//=======================================================================
Standard_Real IntTools_FaceFace::TolReached3d() const
{
return myTolReached3d;
}
//=======================================================================
//function : TolReal
//purpose :
//=======================================================================
Standard_Real IntTools_FaceFace::TolReal() const
{
return myTolReal;
}
//=======================================================================
//function : Lines //function : Lines
//purpose : return lines of intersection //purpose : return lines of intersection
//======================================================================= //=======================================================================
@ -265,14 +240,6 @@ const IntTools_SequenceOfCurves& IntTools_FaceFace::Lines() const
"IntTools_FaceFace::Lines() => myIntersector NOT DONE"); "IntTools_FaceFace::Lines() => myIntersector NOT DONE");
return mySeqOfCurve; return mySeqOfCurve;
} }
//=======================================================================
//function : TolReached2d
//purpose :
//=======================================================================
Standard_Real IntTools_FaceFace::TolReached2d() const
{
return myTolReached2d;
}
// ======================================================================= // =======================================================================
// function: SetParameters // function: SetParameters
// //
@ -398,9 +365,6 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
} }
mySeqOfCurve.Clear(); mySeqOfCurve.Clear();
myTolReached2d=0.;
myTolReached3d=0.;
myTolReal = 0.;
myIsDone = Standard_False; myIsDone = Standard_False;
myNbrestr=0;//? myNbrestr=0;//?
@ -472,38 +436,24 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
// //
Standard_Real TolAng = 1.e-8; Standard_Real TolAng = 1.e-8;
// //
PerformPlanes(myHS1, myHS2, PerformPlanes(myHS1, myHS2,
myTolF1, myTolF2, TolAng, TolTang, myTolF1, myTolF2, TolAng, TolTang,
myApprox1, myApprox2, myApprox1, myApprox2,
mySeqOfCurve, myTangentFaces, myTolReached3d); mySeqOfCurve, myTangentFaces);
// //
myIsDone = Standard_True; myIsDone = Standard_True;
//
if(!myTangentFaces) { if (!myTangentFaces) {
const Standard_Integer NbLinPP = mySeqOfCurve.Length(); const Standard_Integer NbLinPP = mySeqOfCurve.Length();
if(NbLinPP) { if (NbLinPP && bReverse) {
Standard_Real aTolFMax; Handle(Geom2d_Curve) aC2D1, aC2D2;
aTolFMax=Max(myTolF1, myTolF2); const Standard_Integer aNbLin = mySeqOfCurve.Length();
myTolReal = Precision::Confusion(); for (Standard_Integer i = 1; i <= aNbLin; ++i) {
if (aTolFMax > myTolReal) { IntTools_Curve& aIC = mySeqOfCurve(i);
myTolReal = aTolFMax; aC2D1 = aIC.FirstCurve2d();
} aC2D2 = aIC.SecondCurve2d();
if (aTolFMax > myTolReached3d) { aIC.SetFirstCurve2d(aC2D2);
myTolReached3d = aTolFMax; aIC.SetSecondCurve2d(aC2D1);
}
//
myTolReached2d = myTolReal;
if (bReverse) {
Handle(Geom2d_Curve) aC2D1, aC2D2;
const Standard_Integer aNbLin = mySeqOfCurve.Length();
for (Standard_Integer i = 1; i <= aNbLin; ++i) {
IntTools_Curve& aIC=mySeqOfCurve(i);
aC2D1=aIC.FirstCurve2d();
aC2D2=aIC.SecondCurve2d();
aIC.SetFirstCurve2d(aC2D2);
aIC.SetSecondCurve2d(aC2D1);
}
} }
} }
} }
@ -712,121 +662,78 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
} }
//======================================================================= //=======================================================================
//function : ComputeTolerance //function :ComputeTolReached3d
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Real IntTools_FaceFace::ComputeTolerance() void IntTools_FaceFace::ComputeTolReached3d()
{ {
Standard_Integer i, j, aNbLin; Standard_Integer i, j, aNbLin = mySeqOfCurve.Length();
Standard_Real aFirst, aLast, aD, aDMax, aT; if (!aNbLin) {
Handle(Geom_Surface) aS1, aS2; return;
}
// //
aDMax = 0; // Minimal tangential tolerance for the curve
aNbLin = mySeqOfCurve.Length(); Standard_Real aTolFMax = Max(myTolF1, myTolF2);
// //
aS1 = myHS1->ChangeSurface().Surface(); const Handle(Geom_Surface)& aS1 = myHS1->ChangeSurface().Surface();
aS2 = myHS2->ChangeSurface().Surface(); const Handle(Geom_Surface)& aS2 = myHS2->ChangeSurface().Surface();
// //
for (i = 1; i <= aNbLin; ++i) for (i = 1; i <= aNbLin; ++i)
{ {
const IntTools_Curve& aIC = mySeqOfCurve(i); IntTools_Curve& aIC = mySeqOfCurve(i);
const Handle(Geom_Curve)& aC3D = aIC.Curve(); const Handle(Geom_Curve)& aC3D = aIC.Curve();
if (aC3D.IsNull()) if (aC3D.IsNull())
{ {
continue; continue;
} }
// //
aFirst = aC3D->FirstParameter(); Standard_Real aTolC = aIC.Tolerance();
aLast = aC3D->LastParameter(); Standard_Real aFirst = aC3D->FirstParameter();
Standard_Real aLast = aC3D->LastParameter();
// //
// Compute the tolerance for the curve
const Handle(Geom2d_Curve)& aC2D1 = aIC.FirstCurve2d(); const Handle(Geom2d_Curve)& aC2D1 = aIC.FirstCurve2d();
const Handle(Geom2d_Curve)& aC2D2 = aIC.SecondCurve2d(); const Handle(Geom2d_Curve)& aC2D2 = aIC.SecondCurve2d();
// //
for (j = 0; j < 2; ++j) for (j = 0; j < 2; ++j)
{ {
const Handle(Geom2d_Curve)& aC2D = !j ? aC2D1 : aC2D2; const Handle(Geom2d_Curve)& aC2D = !j ? aC2D1 : aC2D2;
const Handle(Geom_Surface)& aS = !j ? aS1 : aS2;
//
if (!aC2D.IsNull()) if (!aC2D.IsNull())
{ {
// Look for the maximal deviation between 3D and 2D curves
Standard_Real aD, aT;
const Handle(Geom_Surface)& aS = !j ? aS1 : aS2;
if (IntTools_Tools::ComputeTolerance if (IntTools_Tools::ComputeTolerance
(aC3D, aC2D, aS, aFirst, aLast, aD, aT)) (aC3D, aC2D, aS, aFirst, aLast, aD, aT))
{ {
if (aD > aDMax) if (aD > aTolC)
{ {
aDMax = aD; aTolC = aD;
} }
} }
} }
else else
{ {
// Look for the maximal deviation between 3D curve and surface
const TopoDS_Face& aF = !j ? myFace1 : myFace2; const TopoDS_Face& aF = !j ? myFace1 : myFace2;
aD = FindMaxDistance(aC3D, aFirst, aLast, aF, myContext); Standard_Real aD = FindMaxDistance(aC3D, aFirst, aLast, aF, myContext);
if (aD > aDMax) if (aD > aTolC)
{ {
aDMax = aD; aTolC = aD;
} }
} }
} }
} // Set the valid tolerance for the curve
// aIC.SetTolerance(aTolC);
return aDMax; //
} // Set the tangential tolerance for the curve.
// Note, that, currently, computation of the tangential tolerance is
//======================================================================= // implemented for the Plane/Plane case only.
//function :ComputeTolReached3d // Thus, set the tangential tolerance equal to maximal tolerance of faces.
//purpose : if (aIC.TangentialTolerance() < aTolFMax) {
//======================================================================= aIC.SetTangentialTolerance(aTolFMax);
void IntTools_FaceFace::ComputeTolReached3d()
{
Standard_Integer aNbLin;
GeomAbs_SurfaceType aType1, aType2;
//
aNbLin=myIntersector.NbLines();
if (!aNbLin) {
return;
}
//
aType1=myHS1->Surface().GetType();
aType2=myHS2->Surface().GetType();
//
if (aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder)
{
if (aNbLin==2)
{
Handle(IntPatch_Line) aIL1, aIL2;
IntPatch_IType aTL1, aTL2;
//
aIL1=myIntersector.Line(1);
aIL2=myIntersector.Line(2);
aTL1=aIL1->ArcType();
aTL2=aIL2->ArcType();
if (aTL1==IntPatch_Lin && aTL2==IntPatch_Lin) {
Standard_Real aD, aDTresh, dTol;
gp_Lin aL1, aL2;
//
dTol=1.e-8;
aDTresh=1.5e-6;
//
aL1=Handle(IntPatch_GLine)::DownCast(aIL1)->Line();
aL2=Handle(IntPatch_GLine)::DownCast(aIL2)->Line();
aD=aL1.Distance(aL2);
aD=0.5*aD;
if (aD<aDTresh)
{//In order to avoid creation too thin face
myTolReached3d=aD+dTol;
}
}
} }
}// if (aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder) {
//
Standard_Real aDMax = ComputeTolerance();
if (aDMax > myTolReached3d)
{
myTolReached3d = aDMax;
} }
myTolReal = myTolReached3d;
} }
//======================================================================= //=======================================================================
@ -931,11 +838,6 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
new Geom_Hyperbola (Handle(IntPatch_GLine)::DownCast(L)->Hyperbola()); new Geom_Hyperbola (Handle(IntPatch_GLine)::DownCast(L)->Hyperbola());
} }
// //
// myTolReached3d
if (typl == IntPatch_Lin) {
TolR3d (myTolF1, myTolF2, myTolReached3d);
}
//
aNbParts=myLConstruct.NbParts(); aNbParts=myLConstruct.NbParts();
for (i=1; i<=aNbParts; i++) { for (i=1; i<=aNbParts; i++) {
Standard_Boolean bFNIt, bLPIt; Standard_Boolean bFNIt, bLPIt;
@ -952,7 +854,8 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
Handle(Geom_TrimmedCurve) aCT3D=new Geom_TrimmedCurve(newc, fprm, lprm); Handle(Geom_TrimmedCurve) aCT3D=new Geom_TrimmedCurve(newc, fprm, lprm);
aCurve.SetCurve(aCT3D); aCurve.SetCurve(aCT3D);
if (typl == IntPatch_Parabola) { if (typl == IntPatch_Parabola) {
myTolReached3d=IntTools_Tools::CurveTolerance(aCT3D, myTol); Standard_Real aTolC = IntTools_Tools::CurveTolerance(aCT3D, myTol);
aCurve.SetTolerance(aTolC);
} }
// //
aCurve.SetCurve(new Geom_TrimmedCurve(newc, fprm, lprm)); aCurve.SetCurve(new Geom_TrimmedCurve(newc, fprm, lprm));
@ -960,33 +863,16 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc,
myHS1->ChangeSurface().Surface(), newc, C2d); myHS1->ChangeSurface().Surface(), newc, C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0.) { aCurve.SetFirstCurve2d(new Geom2d_TrimmedCurve(C2d, fprm, lprm));
myTolReached2d=Tolpc; }
}
//
aCurve.SetFirstCurve2d(new Geom2d_TrimmedCurve(C2d,fprm,lprm));
}
else {
Handle(Geom2d_BSplineCurve) H1;
//
aCurve.SetFirstCurve2d(H1);
}
// //
if(myApprox2) { if(myApprox2) {
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc,
myHS2->ChangeSurface().Surface(), newc, C2d); myHS2->ChangeSurface().Surface(), newc, C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0.) { aCurve.SetSecondCurve2d(new Geom2d_TrimmedCurve(C2d, fprm, lprm));
myTolReached2d=Tolpc;
}
//
aCurve.SetSecondCurve2d(new Geom2d_TrimmedCurve(C2d,fprm,lprm));
}
else {
Handle(Geom2d_BSplineCurve) H1;
//
aCurve.SetSecondCurve2d(H1);
} }
//
mySeqOfCurve.Append(aCurve); mySeqOfCurve.Append(aCurve);
} //if (!bFNIt && !bLPIt) { } //if (!bFNIt && !bLPIt) {
else { else {
@ -1053,9 +939,6 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
(Handle(IntPatch_GLine)::DownCast(L)->Ellipse()); (Handle(IntPatch_GLine)::DownCast(L)->Ellipse());
} }
// //
// myTolReached3d
TolR3d (myTolF1, myTolF2, myTolReached3d);
//
aNbParts=myLConstruct.NbParts(); aNbParts=myLConstruct.NbParts();
// //
Standard_Real aPeriod, aNul; Standard_Real aPeriod, aNul;
@ -1079,10 +962,8 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
else { else {
gp_Pnt P1 = newc->Value(fprm); gp_Pnt P1 = newc->Value(fprm);
gp_Pnt P2 = newc->Value(aPeriod); gp_Pnt P2 = newc->Value(aPeriod);
Standard_Real aTolDist = myTol;
aTolDist = (myTolReached3d > aTolDist) ? myTolReached3d : aTolDist;
if(P1.Distance(P2) > aTolDist) { if(P1.Distance(P2) > myTol) {
Standard_Real anewpar = fprm; Standard_Real anewpar = fprm;
if(ParameterOutOfBoundary(fprm, newc, myFace1, myFace2, if(ParameterOutOfBoundary(fprm, newc, myFace1, myFace2,
@ -1102,10 +983,8 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
else { else {
gp_Pnt P1 = newc->Value(aNul); gp_Pnt P1 = newc->Value(aNul);
gp_Pnt P2 = newc->Value(lprm); gp_Pnt P2 = newc->Value(lprm);
Standard_Real aTolDist = myTol;
aTolDist = (myTolReached3d > aTolDist) ? myTolReached3d : aTolDist;
if(P1.Distance(P2) > aTolDist) { if(P1.Distance(P2) > myTol) {
Standard_Real anewpar = lprm; Standard_Real anewpar = lprm;
if(ParameterOutOfBoundary(lprm, newc, myFace1, myFace2, if(ParameterOutOfBoundary(lprm, newc, myFace1, myFace2,
@ -1123,7 +1002,6 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
aSeqLprm.Append(lprm); aSeqLprm.Append(lprm);
} }
} }
// //
aNbParts=aSeqFprm.Length(); aNbParts=aSeqFprm.Length();
for (i=1; i<=aNbParts; i++) { for (i=1; i<=aNbParts; i++) {
@ -1145,39 +1023,17 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc,
myHS1->ChangeSurface().Surface(), newc, C2d); myHS1->ChangeSurface().Surface(), newc, C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0) {
myTolReached2d=Tolpc;
}
//
aCurve.SetFirstCurve2d(C2d); aCurve.SetFirstCurve2d(C2d);
} }
else { ////
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetFirstCurve2d(H1);
}
if(myApprox2) { if(myApprox2) {
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc, GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc,
myHS2->ChangeSurface().Surface(),newc,C2d); myHS2->ChangeSurface().Surface(),newc,C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0) {
myTolReached2d=Tolpc;
}
//
aCurve.SetSecondCurve2d(C2d); aCurve.SetSecondCurve2d(C2d);
} }
else {
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetSecondCurve2d(H1);
}
}
else {
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetFirstCurve2d(H1);
aCurve.SetSecondCurve2d(H1);
} }
//
mySeqOfCurve.Append(aCurve); mySeqOfCurve.Append(aCurve);
//============================================== //==============================================
} //if (Abs(fprm) > RealEpsilon() || Abs(lprm-2.*M_PI) > RealEpsilon()) } //if (Abs(fprm) > RealEpsilon() || Abs(lprm-2.*M_PI) > RealEpsilon())
@ -1198,31 +1054,16 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc, GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc,
myHS1->ChangeSurface().Surface(),newc,C2d); myHS1->ChangeSurface().Surface(),newc,C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0) {
myTolReached2d=Tolpc;
}
//
aCurve.SetFirstCurve2d(C2d); aCurve.SetFirstCurve2d(C2d);
} }
else { ////
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetFirstCurve2d(H1);
}
if(myApprox2) { if(myApprox2) {
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc, GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc,
myHS2->ChangeSurface().Surface(),newc,C2d); myHS2->ChangeSurface().Surface(),newc,C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0) {
myTolReached2d=Tolpc;
}
//
aCurve.SetSecondCurve2d(C2d); aCurve.SetSecondCurve2d(C2d);
} }
else { //
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetSecondCurve2d(H1);
}
mySeqOfCurve.Append(aCurve); mySeqOfCurve.Append(aCurve);
break; break;
} }
@ -1251,40 +1092,16 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc,
myHS1->ChangeSurface().Surface(), newc, C2d); myHS1->ChangeSurface().Surface(), newc, C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0) {
myTolReached2d=Tolpc;
}
//
aCurve.SetFirstCurve2d(C2d); aCurve.SetFirstCurve2d(C2d);
} }
else {
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetFirstCurve2d(H1);
}
if(myApprox2) { if(myApprox2) {
Handle (Geom2d_Curve) C2d; Handle (Geom2d_Curve) C2d;
GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc,
myHS2->ChangeSurface().Surface(), newc, C2d); myHS2->ChangeSurface().Surface(), newc, C2d);
if(Tolpc>myTolReached2d || myTolReached2d==0) {
myTolReached2d=Tolpc;
}
//
aCurve.SetSecondCurve2d(C2d); aCurve.SetSecondCurve2d(C2d);
} }
else {
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetSecondCurve2d(H1);
}
}// end of if (typl == IntPatch_Circle || typl == IntPatch_Ellipse) }// end of if (typl == IntPatch_Circle || typl == IntPatch_Ellipse)
else {
Handle(Geom2d_BSplineCurve) H1;
//
aCurve.SetFirstCurve2d(H1);
aCurve.SetSecondCurve2d(H1);
}
//============================================== //==============================================
// //
mySeqOfCurve.Append(aCurve); mySeqOfCurve.Append(aCurve);
@ -1410,14 +1227,13 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
aSeqOfL, aSeqOfL,
aReachedTol, aReachedTol,
myContext); myContext);
if ( bIsDecomposited && ( myTolReached3d < aReachedTol ) ) {
myTolReached3d = aReachedTol;
}
// //
aNbSeqOfL=aSeqOfL.Length(); aNbSeqOfL=aSeqOfL.Length();
// //
Standard_Real aTolC = 0.;
if (bIsDecomposited) { if (bIsDecomposited) {
nbiter=aNbSeqOfL; nbiter=aNbSeqOfL;
aTolC = aReachedTol;
} }
else { else {
nbiter=1; nbiter=1;
@ -1495,27 +1311,22 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
IntTools_Curve aIC(aBSp, H1, H2); IntTools_Curve aIC(aBSp, H1, H2);
mySeqOfCurve.Append(aIC); mySeqOfCurve.Append(aIC);
} }
else { else {
if(myApprox1 || myApprox2 || (typs1==GeomAbs_Plane || typs2==GeomAbs_Plane)) { if (typs1 == GeomAbs_Plane || typs2 == GeomAbs_Plane) {
if( theapp3d.TolReached2d()>myTolReached2d || myTolReached2d==0.) { if (aTolC < theapp3d.TolReached2d()) {
myTolReached2d = theapp3d.TolReached2d(); aTolC = theapp3d.TolReached2d();
} }
}
if(typs1==GeomAbs_Plane || typs2==GeomAbs_Plane) {
myTolReached3d = myTolReached2d;
// //
if (typs1==GeomAbs_Torus || typs2==GeomAbs_Torus) { if (typs1 == GeomAbs_Torus || typs2 == GeomAbs_Torus) {
if (myTolReached3d<1.e-6) { if (aTolC < 1.e-6) {
myTolReached3d = theapp3d.TolReached3d(); aTolC = 1.e-6;
myTolReached3d=1.e-6;
} }
} }
} }
else if( theapp3d.TolReached3d()>myTolReached3d || myTolReached3d==0.) { else if (aTolC < theapp3d.TolReached3d()) {
myTolReached3d = theapp3d.TolReached3d(); aTolC = theapp3d.TolReached3d();
} }
//
Standard_Integer aNbMultiCurves, nbpoles; Standard_Integer aNbMultiCurves, nbpoles;
aNbMultiCurves=theapp3d.NbMultiCurves(); aNbMultiCurves=theapp3d.NbMultiCurves();
for (j=1; j<=aNbMultiCurves; j++) { for (j=1; j<=aNbMultiCurves; j++) {
@ -1568,10 +1379,6 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
// ############################################ // ############################################
aCurve.SetFirstCurve2d(BS1); aCurve.SetFirstCurve2d(BS1);
} }
else {
Handle(Geom2d_BSplineCurve) H1;
aCurve.SetFirstCurve2d(H1);
}
if(myApprox2) { if(myApprox2) {
mbspc.Curve(2, tpoles2d); mbspc.Curve(2, tpoles2d);
@ -1595,11 +1402,8 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
// //
aCurve.SetSecondCurve2d(BS2); aCurve.SetSecondCurve2d(BS2);
} }
else { //
Handle(Geom2d_BSplineCurve) H2; aCurve.SetTolerance(aTolC);
//
aCurve.SetSecondCurve2d(H2);
}
// //
mySeqOfCurve.Append(aCurve); mySeqOfCurve.Append(aCurve);
@ -1633,6 +1437,7 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
// //
IntTools_Curve aCurve; IntTools_Curve aCurve;
aCurve.SetCurve(BS); aCurve.SetCurve(BS);
aCurve.SetTolerance(aTolC);
if(myApprox2) { if(myApprox2) {
Handle(Geom2d_BSplineCurve) BS1=new Geom2d_BSplineCurve(tpoles2d, Handle(Geom2d_BSplineCurve) BS1=new Geom2d_BSplineCurve(tpoles2d,
@ -1654,11 +1459,7 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
bPCurvesOk = CheckPCurve(BS1, myFace2, myContext); bPCurvesOk = CheckPCurve(BS1, myFace2, myContext);
aCurve.SetSecondCurve2d(BS1); aCurve.SetSecondCurve2d(BS1);
} }
else {
Handle(Geom2d_BSplineCurve) H2;
aCurve.SetSecondCurve2d(H2);
}
if(myApprox1) { if(myApprox1) {
mbspc.Curve(1,tpoles2d); mbspc.Curve(1,tpoles2d);
Handle(Geom2d_BSplineCurve) BS2=new Geom2d_BSplineCurve(tpoles2d, Handle(Geom2d_BSplineCurve) BS2=new Geom2d_BSplineCurve(tpoles2d,
@ -1680,11 +1481,6 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
bPCurvesOk = bPCurvesOk && CheckPCurve(BS2, myFace1, myContext); bPCurvesOk = bPCurvesOk && CheckPCurve(BS2, myFace1, myContext);
aCurve.SetFirstCurve2d(BS2); aCurve.SetFirstCurve2d(BS2);
} }
else {
Handle(Geom2d_BSplineCurve) H1;
//
aCurve.SetFirstCurve2d(H1);
}
// //
//if points of the pcurves are out of the faces bounds //if points of the pcurves are out of the faces bounds
//create 3d and 2d curves without approximation //create 3d and 2d curves without approximation
@ -1707,7 +1503,7 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
//if pcurves created without approximation are out of the //if pcurves created without approximation are out of the
//faces bounds, use approximated 3d and 2d curves //faces bounds, use approximated 3d and 2d curves
if (bPCurvesOk) { if (bPCurvesOk) {
IntTools_Curve aIC(aBSp, H1, H2); IntTools_Curve aIC(aBSp, H1, H2, aTolC);
mySeqOfCurve.Append(aIC); mySeqOfCurve.Append(aIC);
} else { } else {
mySeqOfCurve.Append(aCurve); mySeqOfCurve.Append(aCurve);
@ -1721,8 +1517,7 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
else { //typs2 != GeomAbs_Plane && typs1 != GeomAbs_Plane else { //typs2 != GeomAbs_Plane && typs1 != GeomAbs_Plane
Standard_Boolean bIsValid1, bIsValid2; Standard_Boolean bIsValid1, bIsValid2;
Handle(Geom_BSplineCurve) BS; Handle(Geom_BSplineCurve) BS;
Handle(Geom2d_BSplineCurve) aH2D; IntTools_Curve aCurve;
IntTools_Curve aCurve;
// //
bIsValid1=Standard_True; bIsValid1=Standard_True;
bIsValid2=Standard_True; bIsValid2=Standard_True;
@ -1737,10 +1532,9 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
mbspc.Degree()); mbspc.Degree());
GeomLib_CheckBSplineCurve Check(BS,TOLCHECK,TOLANGCHECK); GeomLib_CheckBSplineCurve Check(BS,TOLCHECK,TOLANGCHECK);
Check.FixTangent(Standard_True,Standard_True); Check.FixTangent(Standard_True,Standard_True);
// //
aCurve.SetCurve(BS); aCurve.SetCurve(BS);
aCurve.SetFirstCurve2d(aH2D); aCurve.SetTolerance(aTolC);
aCurve.SetSecondCurve2d(aH2D);
// //
if(myApprox1) { if(myApprox1) {
if(anApprox1) { if(anApprox1) {
@ -1749,9 +1543,9 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
mbspc.Curve(2,tpoles2d); mbspc.Curve(2,tpoles2d);
// //
BS1=new Geom2d_BSplineCurve(tpoles2d, BS1=new Geom2d_BSplineCurve(tpoles2d,
mbspc.Knots(), mbspc.Knots(),
mbspc.Multiplicities(), mbspc.Multiplicities(),
mbspc.Degree()); mbspc.Degree());
GeomLib_Check2dBSplineCurve newCheck(BS1,TOLCHECK,TOLANGCHECK); GeomLib_Check2dBSplineCurve newCheck(BS1,TOLCHECK,TOLANGCHECK);
newCheck.FixTangent(Standard_True,Standard_True); newCheck.FixTangent(Standard_True,Standard_True);
// //
@ -2241,24 +2035,6 @@ Handle(Geom_Curve) MakeBSpline (const Handle(IntPatch_WLine)& WL,
} }
} }
//=======================================================================
//function : TolR3d
//purpose :
//=======================================================================
void TolR3d(const Standard_Real aTolF1,
const Standard_Real aTolF2,
Standard_Real& myTolReached3d)
{
Standard_Real aTolFMax, aTolTresh;
aTolTresh=2.999999e-3;
aTolFMax=Max(aTolF1, aTolF2);
if (aTolFMax>aTolTresh) {
myTolReached3d=aTolFMax;
}
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// static function: ParameterOutOfBoundary // static function: ParameterOutOfBoundary
// purpose: Computes a new parameter for given curve. The corresponding 2d points // purpose: Computes a new parameter for given curve. The corresponding 2d points
@ -2443,17 +2219,16 @@ Standard_Boolean ApproxWithPCurves(const gp_Cylinder& theCyl,
//function : PerformPlanes //function : PerformPlanes
//purpose : //purpose :
//======================================================================= //=======================================================================
void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1, void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
const Handle(GeomAdaptor_HSurface)& theS2, const Handle(GeomAdaptor_HSurface)& theS2,
const Standard_Real TolF1, const Standard_Real TolF1,
const Standard_Real TolF2, const Standard_Real TolF2,
const Standard_Real TolAng, const Standard_Real TolAng,
const Standard_Real TolTang, const Standard_Real TolTang,
const Standard_Boolean theApprox1, const Standard_Boolean theApprox1,
const Standard_Boolean theApprox2, const Standard_Boolean theApprox2,
IntTools_SequenceOfCurves& theSeqOfCurve, IntTools_SequenceOfCurves& theSeqOfCurve,
Standard_Boolean& theTangentFaces, Standard_Boolean& theTangentFaces)
Standard_Real& TolReached3d)
{ {
gp_Pln aPln1 = theS1->Surface().Plane(); gp_Pln aPln1 = theS1->Surface().Plane();
@ -2534,10 +2309,13 @@ void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
Handle(Geom2d_Curve) H1; Handle(Geom2d_Curve) H1;
aCurve.SetFirstCurve2d(H1); aCurve.SetFirstCurve2d(H1);
} }
theSeqOfCurve.Append(aCurve);
// //
// computation of the tolerance reached // Valid tolerance for the intersection curve between planar faces
// is the maximal tolerance between tolerances of faces
Standard_Real aTolC = Max(TolF1, TolF2);
aCurve.SetTolerance(aTolC);
//
// Computation of the tangential tolerance
Standard_Real anAngle, aDt; Standard_Real anAngle, aDt;
gp_Dir aD1, aD2; gp_Dir aD1, aD2;
// //
@ -2546,7 +2324,11 @@ void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
anAngle = aD1.Angle(aD2); anAngle = aD1.Angle(aD2);
// //
aDt = IntTools_Tools::ComputeIntRange(TolF1, TolF2, anAngle); aDt = IntTools_Tools::ComputeIntRange(TolF1, TolF2, anAngle);
TolReached3d = sqrt(aDt*aDt + TolF1*TolF1); Standard_Real aTangTol = sqrt(aDt*aDt + TolF1*TolF1);
//
aCurve.SetTangentialTolerance(aTangTol);
//
theSeqOfCurve.Append(aCurve);
} }
//======================================================================= //=======================================================================

43
src/IntTools/IntTools_FaceFace.hxx
View File

@ -70,21 +70,6 @@ public:
//! Returns sequence of 3d curves as result of intersection //! Returns sequence of 3d curves as result of intersection
Standard_EXPORT const IntTools_SequenceOfPntOn2Faces& Points() const; Standard_EXPORT const IntTools_SequenceOfPntOn2Faces& Points() const;
//! Returns tolerance reached during approximation,
//! and possibly increased to cover more area due to a small angle between surfaces.
//! If approximation was not done, returns zero.
Standard_EXPORT Standard_Real TolReached3d() const;
//! Returns tolerance reached during approximation, without any increase.
//! If approximation was not done, returns zero.
Standard_EXPORT Standard_Real TolReal() const;
//! Returns tolerance reached during approximation.
//! If approximation was not done, returns zero.
Standard_EXPORT Standard_Real TolReached2d() const;
//! Returns first of processed faces //! Returns first of processed faces
Standard_EXPORT const TopoDS_Face& Face1() const; Standard_EXPORT const TopoDS_Face& Face1() const;
@ -121,37 +106,28 @@ public:
//! Gets the intersecton context //! Gets the intersecton context
Standard_EXPORT const Handle(IntTools_Context)& Context() const; Standard_EXPORT const Handle(IntTools_Context)& Context() const;
protected: protected:
//! Creates curves from the IntPatch_Line.
Standard_EXPORT void MakeCurve (const Standard_Integer Index, Standard_EXPORT void MakeCurve (const Standard_Integer Index,
const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_TopolTool)& D2, const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real theToler); const Standard_Real theToler);
//! Computes the valid tolerance for the intersection curves
//! as a maximal deviation between 3D curve and 2D curves on faces.<br>
//! If there are no 2D curves the maximal deviation between 3D curves
//! and surfaces is computed.
Standard_EXPORT void ComputeTolReached3d(); Standard_EXPORT void ComputeTolReached3d();
Standard_EXPORT Standard_Real ComputeTolerance();
private: private:
Standard_Boolean myIsDone; Standard_Boolean myIsDone;
IntPatch_Intersection myIntersector; IntPatch_Intersection myIntersector;
GeomInt_LineConstructor myLConstruct; GeomInt_LineConstructor myLConstruct;
Handle(GeomAdaptor_HSurface) myHS1; Handle(GeomAdaptor_HSurface) myHS1;
Handle(GeomAdaptor_HSurface) myHS2; Handle(GeomAdaptor_HSurface) myHS2;
Standard_Integer myNbrestr; Standard_Integer myNbrestr;
Standard_Real myTolReached2d;
Standard_Real myTolReached3d;
Standard_Real myTolReal;
Standard_Boolean myApprox; Standard_Boolean myApprox;
Standard_Boolean myApprox1; Standard_Boolean myApprox1;
Standard_Boolean myApprox2; Standard_Boolean myApprox2;
@ -168,13 +144,6 @@ private:
IntSurf_ListOfPntOn2S myListOfPnts; IntSurf_ListOfPntOn2S myListOfPnts;
Handle(IntTools_Context) myContext; Handle(IntTools_Context) myContext;
}; };
#endif // _IntTools_FaceFace_HeaderFile #endif // _IntTools_FaceFace_HeaderFile

48
src/IntTools/IntTools_Tools.cxx
View File

@ -252,10 +252,9 @@ static
aC2D2F=new Geom2d_TrimmedCurve (aC2D2, aF, aMid); aC2D2F=new Geom2d_TrimmedCurve (aC2D2, aF, aMid);
aC2D2L=new Geom2d_TrimmedCurve (aC2D2, aMid, aL); aC2D2L=new Geom2d_TrimmedCurve (aC2D2, aMid, aL);
} }
// //
IntTools_Curve aIC1(aC3DNewF, aC2D1F, aC2D2F, IC.Tolerance(), IC.TangentialTolerance());
IntTools_Curve aIC1(aC3DNewF, aC2D1F, aC2D2F); IntTools_Curve aIC2(aC3DNewL, aC2D1L, aC2D2L, IC.Tolerance(), IC.TangentialTolerance());
IntTools_Curve aIC2(aC3DNewL, aC2D1L, aC2D2L);
// //
aCvs.Append(aIC1); aCvs.Append(aIC1);
// //
@ -587,27 +586,32 @@ void ParabolaTolerance(const Handle(Geom_Curve)& aC3D,
//function : CheckCurve //function : CheckCurve
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean IntTools_Tools::CheckCurve(const Handle (Geom_Curve)& aC3D, Standard_Boolean IntTools_Tools::CheckCurve(const IntTools_Curve& theCurve,
const Standard_Real aTolR3D, Bnd_Box& theBox)
Bnd_Box& aBox)
{ {
Standard_Boolean bRet; const Handle(Geom_Curve)& aC3D = theCurve.Curve();
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dX, dY, dZ; Standard_Boolean bValid = !aC3D.IsNull();
Standard_Real dS, aTol; if (!bValid) {
GeomAdaptor_Curve aGAC; return bValid;
}
// //
aGAC.Load(aC3D); // Build bounding box for the curve
BndLib_Add3dCurve::Add(aGAC, aTolR3D, aBox); BndLib_Add3dCurve::Add(GeomAdaptor_Curve(aC3D),
// 910/B1 Max(theCurve.Tolerance(), theCurve.TangentialTolerance()),
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax); theBox);
dX=aXmax-aXmin;
dY=aYmax-aYmin;
dZ=aZmax-aZmin;
dS=1.e-12;
aTol=2.*aTolR3D+dS;
bRet=(dX>aTol || dY>aTol || dZ>aTol);
// //
return bRet; // Estimate the bounding box of the curve comparing it with the
// minimal length for the curve from which the valid edge can be built -
// 3*Precision::Confusion():
// - 2 vertices with the Precision::Confusion() tolerance;
// - plus Precision::Confusion() as the minimal distance between vertices.
Standard_Real aTolCmp = 3*Precision::Confusion();
//
// Check the size of the box using the Bnd_Box::IsThin() method
// which does not use the gap of the box.
bValid = !theBox.IsThin(aTolCmp);
//
return bValid;
} }
//======================================================================= //=======================================================================
//function : IsOnPave //function : IsOnPave

7
src/IntTools/IntTools_Tools.hxx
View File

@ -142,8 +142,11 @@ public:
//! if aC is trimmed curve and basis curve is parabola, //! if aC is trimmed curve and basis curve is parabola,
//! otherwise returns value of aTolBase //! otherwise returns value of aTolBase
Standard_EXPORT static Standard_Real CurveTolerance (const Handle(Geom_Curve)& aC, const Standard_Real aTolBase); Standard_EXPORT static Standard_Real CurveTolerance (const Handle(Geom_Curve)& aC, const Standard_Real aTolBase);
Standard_EXPORT static Standard_Boolean CheckCurve (const Handle(Geom_Curve)& theC, const Standard_Real theTol, Bnd_Box& theBox); //! Checks if the curve is not covered by the default tolerance (confusion).<br>
//! Builds bounding box for the curve and stores it into <theBox>.
Standard_EXPORT static Standard_Boolean CheckCurve(const IntTools_Curve& theCurve,
Bnd_Box& theBox);
Standard_EXPORT static Standard_Boolean IsOnPave (const Standard_Real theT, const IntTools_Range& theRange, const Standard_Real theTol); Standard_EXPORT static Standard_Boolean IsOnPave (const Standard_Real theT, const IntTools_Range& theRange, const Standard_Real theTol);

19
tests/bugs/modalg_6/bug28591 Normal file
View File

@ -0,0 +1,19 @@
puts "========"
puts "OCC28591"
puts "========"
puts ""
##########################################
## BOP Cut creates wrong result
##########################################
restore [locate_data_file bug28591_ToCut.brep] b1
restore [locate_data_file bug28591_vol_neg.brep] b2
bcut result b1 b2
checkshape result
checknbshapes result -face 38 -shell 9 -solid 9
checkprops result -s 0.0165593 -v 2.65628e-005
checkview -display result -2d -path ${imagedir}/${test_image}.png