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

0026619: Tolerances of operands are modified using bop

Browse Source 
0026796: The result of General Fuse operation is self-intersecting shape

The fix forces creation of new sub-shapes (vertex, edge) when the tolerance of some sub-shape of an argument is to be increased.

This new behavior is turned off by default. It can be turned on using two ways:
1) Setting 'locking' flag of the arguments.
2) Calling the method SetNonDestructive(Standard_True) of the API classes.

Various bug fixes in the algorithm:
- Compute correct tolerance values for intersections of type Line/Line, Line/Plane, Plane/Plane.
- In case of Line/Plane intersection check if line's vertices lie on the plane.
- Do not allow decreasing of the tolerance value of the Line/Line intersection vertex.
- In IntTools_EdgeEdge, call the method FindParameters with proper 3D tolerance of the curve.
- Force making copy of a degenerated edge if its vertex is touched but no 2D intersection with other curves is found.
- Remove pave blocks both ends of which became referring to the same vertex after vertices substitution.
- Avoid exception in IntTools_Context::IsVertexOnLine if Extrema is not done.
- Reduce tolerance of vertex/edge using actual distances to interfered shapes if it was increased due to line/line, line/plane, or plane/plane small intersection angle.
- Update tolerance of edges to reach all representations in a common block.
- In V-E intersections, check if a vertex hits beyond shrunk range, in such case create V-V interference.
- Do not put a section edge to the result if it becomes to be a micro edge after updating its vertex.
- Correctly make vertices same-domain during the work of MakeBlocks.
- Decrease shrunk range at least on a Precision::Confusion() in addition to vertex tolerance.
- Add Confusion to bounding boxes of new shapes in DS
- Add tolerance Precision::Confusion() to compare distances of touching cases to fix regressions.

TODO marks have been removed from (or modified in) the following test cases (Improvements):
boolean bsection M3 N2 R2
boolean gdml_private B6 C2 C6 G7 I6 F6 J1 J4 M7 N1 N8 N9 O3 O4 O6 O8 O9 P1 P2 P5 Q1 Q3 Q5 S9 T2 U4 U5 U9 ZB5 ZB6 ZC1 ZC5 ZD3 ZD6 ZD7 ZH2 ZH5 ZI2 ZI5 ZI7 ZI9 ZJ3 ZJ4 ZJ7 F8 I6 G1
boolean volumemaker A5 A6 B3 B4 B7 B9 D3 D4 D7 F1
boolean bopcut_2d D5
bugs modalg_5 bug25043
bugs modalg_2 bug472_1 bug472_2 bug472_3

Test cases updated because they are still bad but can be accepted as non-regression:
boolean volumemaker C4 A3 A7 E6
bugs modalg_1 bug10232
boolean bsection N2

Put new TODO in the scripts:
bugs modalg_5 bug25232_9
bugs modalg_6 bug26619
bugs modalg_1 buc60462_2
bugs modalg_4 bug772

For the following tests the result in fix became better, so take fix result as the reference:
bugs modalg_5 bug24628
bugs modalg_6 bug26954_3
boolean volumemaker A4 B5 B6 C3 C8 D2 D5 F2
bugs modalg_2 bug472_2
bugs modalg_1 buc60776_1

- Add the method SetNonDestructive to API classes of user level
This commit is contained in:
msv 2015-10-21 12:36:03 +03:00 committed by bugmaster
parent 6435b9c7fa
commit 3510db6201
144 changed files with 2242 additions and 925 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/BOPAlgo/BOPAlgo_BOP.cxx
View File

@ -375,6 +375,7 @@ void BOPAlgo_BOP::Perform()
pPF->SetRunParallel(myRunParallel);
pPF->SetProgressIndicator(myProgressIndicator);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
//
pPF->Perform();
//

62
src/BOPAlgo/BOPAlgo_Builder.cxx
View File

@ -24,9 +24,17 @@
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Shape.hxx>
#include <BRep_Builder.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_DS.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
//=======================================================================
//function :
//purpose :
@ -43,7 +51,8 @@ BOPAlgo_Builder::BOPAlgo_Builder()
myShapesSD(100, myAllocator),
mySplits(100, myAllocator),
myOrigins(100, myAllocator),
myFuzzyValue(0.)
myFuzzyValue(0.),
myNonDestructive(Standard_False)
{
}
//=======================================================================
@ -63,7 +72,8 @@ BOPAlgo_Builder::BOPAlgo_Builder
myShapesSD(100, myAllocator),
mySplits(100, myAllocator),
myOrigins(100, myAllocator),
myFuzzyValue(0.)
myFuzzyValue(0.),
myNonDestructive(Standard_False)
{
}
//=======================================================================
@ -192,6 +202,22 @@ Standard_Real BOPAlgo_Builder::FuzzyValue() const
return myFuzzyValue;
}
//=======================================================================
//function : SetNonDestructive
//purpose :
//=======================================================================
void BOPAlgo_Builder::SetNonDestructive(const Standard_Boolean theFlag)
{
myNonDestructive = theFlag;
}
//=======================================================================
//function : NonDestructive
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_Builder::NonDestructive() const
{
return myNonDestructive;
}
//=======================================================================
// function: CheckData
// purpose:
//=======================================================================
@ -259,6 +285,7 @@ void BOPAlgo_Builder::Perform()
pPF->SetRunParallel(myRunParallel);
pPF->SetProgressIndicator(myProgressIndicator);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
//
pPF->Perform();
//
@ -272,6 +299,8 @@ void BOPAlgo_Builder::Perform()
void BOPAlgo_Builder::PerformWithFiller(const BOPAlgo_PaveFiller& theFiller)
{
myEntryPoint=0;
myNonDestructive = theFiller.NonDestructive();
myFuzzyValue = theFiller.FuzzyValue();
PerformInternal(theFiller);
}
//=======================================================================
@ -406,17 +435,30 @@ void BOPAlgo_Builder::PerformInternal1(const BOPAlgo_PaveFiller& theFiller)
PostTreat();
}
//
// myErrorStatus
//
// 0 - Ok
//
//=======================================================================
//function : PostTreat
//purpose :
//=======================================================================
void BOPAlgo_Builder::PostTreat()
{
BOPTools_AlgoTools::CorrectTolerances(myShape, 0.05, myRunParallel);
BOPTools_AlgoTools::CorrectShapeTolerances(myShape, myRunParallel);
Standard_Integer i, aNbS;
TopAbs_ShapeEnum aType;
BOPCol_IndexedMapOfShape aMA;
if (myPaveFiller->NonDestructive()) {
// MapToAvoid
aNbS=myDS->NbSourceShapes();
for (i=0; i<aNbS; ++i) {
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
aType=aSI.ShapeType();
if (aType==TopAbs_VERTEX ||
aType==TopAbs_EDGE||
aType==TopAbs_FACE) {
const TopoDS_Shape& aS=aSI.Shape();
aMA.Add(aS);
}
}
}
//
BOPTools_AlgoTools::CorrectTolerances(myShape, aMA, 0.05, myRunParallel);
BOPTools_AlgoTools::CorrectShapeTolerances(myShape, aMA, myRunParallel);
}

15
src/BOPAlgo/BOPAlgo_Builder.hxx
View File

@ -64,7 +64,7 @@ Standard_EXPORT virtual ~BOPAlgo_Builder();
Standard_EXPORT virtual void SetArguments (const BOPCol_ListOfShape& theLS);
Standard_EXPORT const BOPCol_ListOfShape& Arguments() const;
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
Standard_EXPORT virtual void PerformWithFiller (const BOPAlgo_PaveFiller& theFiller);
@ -99,7 +99,18 @@ Standard_EXPORT virtual ~BOPAlgo_Builder();
//! Returns the additional tolerance
Standard_EXPORT Standard_Real FuzzyValue() const;
//! Sets the flag that defines the mode of treatment.
//! In non-destructive mode the argument shapes are not modified. Instead
//! a copy of a sub-shape is created in the result if it is needed to be updated.
//! This flag is taken into account if internal PaveFiller is used only.
//! In the case of calling PerformWithFiller the corresponding flag of that PaveFiller
//! is in force.
Standard_EXPORT void SetNonDestructive(const Standard_Boolean theFlag);
//! Returns the flag that defines the mode of treatment.
//! In non-destructive mode the argument shapes are not modified. Instead
//! a copy of a sub-shape is created in the result if it is needed to be updated.
Standard_EXPORT Standard_Boolean NonDestructive() const;
protected:
@ -162,7 +173,7 @@ protected:
BOPCol_DataMapOfShapeListOfShape mySplits;
BOPCol_DataMapOfShapeShape myOrigins;
Standard_Real myFuzzyValue;
Standard_Boolean myNonDestructive;
private:

2
src/BOPAlgo/BOPAlgo_Builder_1.cxx
View File

@ -86,7 +86,7 @@
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
const Handle(BOPDS_PaveBlock)& aPBR=myDS->RealPaveBlock(aPB);
Handle(BOPDS_PaveBlock) aPBR=myDS->RealPaveBlock(aPB);
//
nSpR=aPBR->Edge();
const TopoDS_Shape& aSpR=myDS->Shape(nSpR);

10
src/BOPAlgo/BOPAlgo_Builder_2.cxx
View File

@ -208,10 +208,10 @@ class BOPAlgo_VFI : public BOPAlgo_Algo {
}
//
virtual void Perform() {
Standard_Real aT1, aT2;
Standard_Real aT1, aT2, dummy;
//
BOPAlgo_Algo::UserBreak();
myFlag=myContext->ComputeVF(myV, myF, aT1, aT2);
myFlag = myContext->ComputeVF(myV, myF, aT1, aT2, dummy);
}
//
protected:
@ -405,8 +405,10 @@ void BOPAlgo_Builder::BuildSplitFaces()
aLE.Append(aSp);
}
//
BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
//
if (!myPaveFiller->NonDestructive()) {
// speed up for planar faces
BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane (aLE, aFF);
}
// 3 Build split faces
BOPAlgo_BuilderFace& aBF=aVBF.Append1();
aBF.SetFace(aF);

1
src/BOPAlgo/BOPAlgo_Builder_3.cxx
View File

@ -581,6 +581,7 @@ void BOPAlgo_Builder::FillIn3DParts
}
Bnd_Box aBox;
BRepBndLib::Add(aSx, aBox);
aBox.SetGap(aBox.GetGap() + Precision::Confusion());
//
BOPAlgo_ShapeBox& aSB=aVSB.Append1();
aSB.SetShape(aSx);

16
src/BOPAlgo/BOPAlgo_CheckerSI.cxx
View File

@ -70,22 +70,6 @@ void BOPAlgo_CheckerSI::SetLevelOfCheck(const Standard_Integer theLevel)
}
}
//=======================================================================
//function : SetNonDestructive
//purpose :
//=======================================================================
void BOPAlgo_CheckerSI::SetNonDestructive(const Standard_Boolean theFlag)
{
myNonDestructive=theFlag;
}
//=======================================================================
//function : NonDestructive
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_CheckerSI::NonDestructive() const
{
return myNonDestructive;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================

16
src/BOPAlgo/BOPAlgo_CheckerSI.hxx
View File

@ -50,21 +50,6 @@ Standard_EXPORT virtual ~BOPAlgo_CheckerSI();
//! 4 - V/V, V/E, E/E, V/F and E/F;
//! 5 - all interferences, default value.
Standard_EXPORT void SetLevelOfCheck (const Standard_Integer theLevel);
//! Sets the flag <theFlag> that defines
//! the mode of the treatment:
//! the copy of the argument when theFlag is true
//! the argument itself when theFlag is false
Standard_EXPORT void SetNonDestructive (const Standard_Boolean theFlag);
//! Returns the flag that defines the
//! mode of the treatment:
//! true when the copy of the argument is used
//! false when the argument itself is used
Standard_EXPORT Standard_Boolean NonDestructive() const;
protected:
@ -81,7 +66,6 @@ protected:
Standard_Integer myLevelOfCheck;
Standard_Boolean myNonDestructive;
BOPCol_DataMapOfShapeShape myNewOldMap;

1
src/BOPAlgo/BOPAlgo_MakerVolume.cxx
View File

@ -100,6 +100,7 @@ void BOPAlgo_MakerVolume::Perform()
pPF->SetRunParallel(myRunParallel);
pPF->SetProgressIndicator(myProgressIndicator);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->Perform();
//
myEntryPoint = 1;

58
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
View File

@ -42,6 +42,8 @@ BOPAlgo_PaveFiller::BOPAlgo_PaveFiller()
{
myDS=NULL;
myIterator=NULL;
myNonDestructive=Standard_False;
myIsPrimary=Standard_True;
}
//=======================================================================
//function :
@ -55,6 +57,8 @@ BOPAlgo_PaveFiller::BOPAlgo_PaveFiller
{
myDS=NULL;
myIterator=NULL;
myNonDestructive=Standard_False;
myIsPrimary=Standard_True;
}
//=======================================================================
//function : ~
@ -65,6 +69,38 @@ BOPAlgo_PaveFiller::~BOPAlgo_PaveFiller()
Clear();
}
//=======================================================================
//function : SetNonDestructive
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetNonDestructive(const Standard_Boolean bFlag)
{
myNonDestructive=bFlag;
}
//=======================================================================
//function : NonDestructive
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::NonDestructive()const
{
return myNonDestructive;
}
//=======================================================================
//function : SetIsPrimary
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetIsPrimary(const Standard_Boolean bFlag)
{
myIsPrimary=bFlag;
}
//=======================================================================
//function : IsPrimary
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::IsPrimary()const
{
return myIsPrimary;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
@ -175,6 +211,9 @@ void BOPAlgo_PaveFiller::Init()
// 3 myContext
myContext=new IntTools_Context;
//
// 4 NonDestructive flag
SetNonDestructive();
//
myErrorStatus=0;
}
//=======================================================================
@ -224,27 +263,26 @@ void BOPAlgo_PaveFiller::PerformInternal()
return;
}
//
UpdatePaveBlocksWithSDVertices();
myDS->UpdatePaveBlocks();
// 11
PerformEE();
if (myErrorStatus) {
return;
}
UpdatePaveBlocksWithSDVertices();
// 02
PerformVF();
if (myErrorStatus) {
return;
}
UpdatePaveBlocksWithSDVertices();
// 12
PerformEF();
if (myErrorStatus) {
return;
}
//
MakeSplitEdges();
if (myErrorStatus) {
return;
}
UpdatePaveBlocksWithSDVertices();
//
// 22
PerformFF();
@ -252,6 +290,15 @@ void BOPAlgo_PaveFiller::PerformInternal()
return;
}
//
UpdateBlocksWithSharedVertices();
//
MakeSplitEdges();
if (myErrorStatus) {
return;
}
//
UpdatePaveBlocksWithSDVertices();
//
MakeBlocks();
if (myErrorStatus) {
return;
@ -268,7 +315,6 @@ void BOPAlgo_PaveFiller::PerformInternal()
if (myErrorStatus) {
return;
}
//
// 03
PerformVZ();
if (myErrorStatus) {

52
src/BOPAlgo/BOPAlgo_PaveFiller.hxx
View File

@ -50,13 +50,13 @@ class IntTools_Context;
class BOPDS_DS;
class BOPAlgo_SectionAttribute;
class BOPDS_PaveBlock;
class BOPDS_CommonBlock;
class TopoDS_Vertex;
class gp_Pnt;
class BOPDS_Curve;
class TopoDS_Face;
class BOPAlgo_PaveFiller : public BOPAlgo_Algo
{
public:
@ -65,7 +65,8 @@ public:
Standard_EXPORT BOPAlgo_PaveFiller();
Standard_EXPORT virtual ~BOPAlgo_PaveFiller();
Standard_EXPORT virtual ~BOPAlgo_PaveFiller();
Standard_EXPORT BOPAlgo_PaveFiller(const BOPCol_BaseAllocator& theAllocator);
@ -83,6 +84,16 @@ Standard_EXPORT virtual ~BOPAlgo_PaveFiller();
Standard_EXPORT void SetSectionAttribute (const BOPAlgo_SectionAttribute& theSecAttr);
//! Sets the flag that defines the mode of treatment.
//! In non-destructive mode the argument shapes are not modified. Instead
//! a copy of a sub-shape is created in the result if it is needed to be updated.
Standard_EXPORT void SetNonDestructive(const Standard_Boolean theFlag);
//! Returns the flag that defines the mode of treatment.
//! In non-destructive mode the argument shapes are not modified. Instead
//! a copy of a sub-shape is created in the result if it is needed to be updated.
Standard_EXPORT Standard_Boolean NonDestructive() const;
Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
//! Sets the additional tolerance
@ -96,7 +107,14 @@ Standard_EXPORT virtual ~BOPAlgo_PaveFiller();
protected:
//! Sets non-destructive mode automatically if an argument
//! contains a locked sub-shape (see TopoDS_Shape::Locked()).
Standard_EXPORT void SetNonDestructive();
Standard_EXPORT void SetIsPrimary(const Standard_Boolean theFlag);
Standard_EXPORT Standard_Boolean IsPrimary() const;
Standard_EXPORT virtual void PerformInternal();
Standard_EXPORT virtual void Clear();
@ -134,6 +152,8 @@ protected:
Standard_EXPORT void MakeBlocks();
Standard_EXPORT void MakePCurves();
Standard_EXPORT void MakeSDVertices(const BOPCol_ListOfInteger& theVertIndices);
Standard_EXPORT void ProcessDE();
@ -231,7 +251,7 @@ protected:
//! Treatment of vertices that were created in EE intersections.
Standard_EXPORT void TreatNewVertices (const BOPCol_IndexedDataMapOfShapeInteger& theMVI, BOPCol_IndexedDataMapOfShapeListOfShape& theImages);
Standard_EXPORT void TreatNewVertices(const BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB, BOPCol_IndexedDataMapOfShapeListOfShape& theImages);
//! Put paves on the curve <aBC> in case when <aBC>
@ -276,6 +296,28 @@ protected:
//! in the map <theDMI>.
Standard_EXPORT void UpdatePaveBlocks (const BOPCol_DataMapOfIntegerInteger& theDMI);
//! Updates tolerance vertex nV due to V/E interference.
//! It always creates new vertex if nV is from arguments.
//! @return DS index of updated vertex.
Standard_EXPORT Standard_Integer UpdateVertex(const Standard_Integer nV,
const Standard_Real aTolNew);
Standard_EXPORT void UpdatePaveBlocksWithSDVertices();
Standard_EXPORT void UpdateCommonBlocksWithSDVertices();
Standard_EXPORT void UpdateBlocksWithSharedVertices();
Standard_EXPORT Standard_Boolean EstimatePaveOnCurve(const Standard_Integer nV,
const BOPDS_Curve& theNC,
const Standard_Real theTolR3D);
Standard_EXPORT void UpdateEdgeTolerance(const Standard_Integer nE,
const Standard_Real aTolNew);
Standard_EXPORT void RemovePaveBlocks(const BOPCol_MapOfInteger theEdges);
Standard_EXPORT void CorrectToleranceOfSE();
BOPCol_ListOfShape myArguments;
BOPDS_PDS myDS;
@ -283,6 +325,8 @@ protected:
Handle(IntTools_Context) myContext;
BOPAlgo_SectionAttribute mySectionAttribute;
Standard_Real myFuzzyValue;
Standard_Boolean myNonDestructive;
Standard_Boolean myIsPrimary;
private:

122
src/BOPAlgo/BOPAlgo_PaveFiller_1.cxx
View File

@ -20,6 +20,7 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfInteger.hxx>
@ -31,9 +32,13 @@
#include <BOPDS_VectorOfInterfVV.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BRepBndLib.hxx>
#include <BRep_TVertex.hxx>
#include <BRep_Tool.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Precision.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
@ -44,11 +49,8 @@
void BOPAlgo_PaveFiller::PerformVV()
{
Standard_Boolean bWithSubShape;
Standard_Integer n1, n2, iFlag, nX, n, aSize, i, j, k, aNbBlocks;
Standard_Integer n1, n2, iFlag, aSize, k, aNbBlocks;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfInteger aItLI, aItLI2;
TopoDS_Vertex aVn;
BOPDS_ShapeInfo aSIn;
//
myErrorStatus=0;
//
@ -58,8 +60,6 @@ void BOPAlgo_PaveFiller::PerformVV()
return;
}
//
aSIn.SetShapeType(TopAbs_VERTEX);
BOPDS_VectorOfInterfVV& aVVs=myDS->InterfVV();
aVVs.SetIncrement(aSize);
//
@ -68,7 +68,6 @@ void BOPAlgo_PaveFiller::PerformVV()
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfIntegerListOfInteger aMILI(100, aAllocator);
BOPCol_DataMapOfIntegerListOfInteger aMBlocks(100, aAllocator);
BOPCol_ListOfShape aLV(aAllocator);
//
// 1. Map V/LV
for (; myIterator->More(); myIterator->Next()) {
@ -91,47 +90,80 @@ void BOPAlgo_PaveFiller::PerformVV()
for (k=0; k<aNbBlocks; ++k) {
const BOPCol_ListOfInteger& aLI=aMBlocks.Find(k);
//
aLV.Clear();
aItLI.Initialize(aLI);
for (; aItLI.More(); aItLI.Next()) {
nX=aItLI.Value();
const TopoDS_Shape& aV=myDS->Shape(nX);
aLV.Append(aV);
}
//
BOPTools_AlgoTools::MakeVertex(aLV, aVn);
//
// Appennd new vertex to the DS
aSIn.SetShape(aVn);
n=myDS->Append(aSIn);
//
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(n);
Bnd_Box& aBox=aSIDS.ChangeBox();
BRepBndLib::Add(aVn, aBox);
//
// Fill ShapesSD
aItLI.Initialize(aLI);
for (i=0; aItLI.More(); aItLI.Next(), ++i) {
n1=aItLI.Value();
myDS->AddShapeSD(n1, n);
//
aItLI2.Initialize(aLI);
for (j=0; aItLI2.More(); aItLI2.Next(), ++j) {
if (j>i) {
n2=aItLI2.Value();
//
myDS->AddInterf(n1, n2);
BOPDS_InterfVV& aVV=aVVs.Append1();
//
aVV.SetIndices(n1, n2);
aVV.SetIndexNew(n);
}
}
}
MakeSDVertices(aLI);
}
//
BOPCol_DataMapIteratorOfDataMapOfIntegerInteger aItDMII;
//
BOPCol_DataMapOfIntegerInteger& aDMII=myDS->ShapesSD();
aItDMII.Initialize(aDMII);
for (; aItDMII.More(); aItDMII.Next()) {
n1=aItDMII.Key();
myDS->InitPaveBlocksForVertex(n1);
}
//
//-----------------------------------------------------scope t
aLV.Clear();
aMBlocks.Clear();
aMILI.Clear();
}
//=======================================================================
// function: PerformVV
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::MakeSDVertices(const BOPCol_ListOfInteger& theVertIndices)
{
TopoDS_Vertex aVSD, aVn;
BOPCol_ListIteratorOfListOfInteger aItLI(theVertIndices);
BOPCol_ListOfShape aLV;
for (; aItLI.More(); aItLI.Next()) {
Standard_Integer nX = aItLI.Value();
Standard_Integer nSD;
if (myDS->HasShapeSD(nX, nSD)) {
aVSD = TopoDS::Vertex(myDS->Shape(nSD));
}
const TopoDS_Shape& aV = myDS->Shape(nX);
aLV.Append(aV);
}
BOPTools_AlgoTools::MakeVertex(aLV, aVn);
if (!aVSD.IsNull()) {
// update old SD vertex with new value
Handle(BRep_TVertex)& aTVertex =
reinterpret_cast<Handle(BRep_TVertex)&>(const_cast<Handle(TopoDS_TShape)&>(aVSD.TShape()));
aTVertex->Pnt(BRep_Tool::Pnt(aVn));
aTVertex->Tolerance(BRep_Tool::Tolerance(aVn));
}
//
// Append new vertex to the DS
BOPDS_ShapeInfo aSIn;
aSIn.SetShapeType(TopAbs_VERTEX);
aSIn.SetShape(aVn);
Standard_Integer n = myDS->Append(aSIn);
//
BOPDS_ShapeInfo& aSIDS = myDS->ChangeShapeInfo(n);
Bnd_Box& aBox = aSIDS.ChangeBox();
BRepBndLib::Add(aVn, aBox);
aBox.SetGap(aBox.GetGap() + Precision::Confusion());
//
// Fill ShapesSD
BOPDS_VectorOfInterfVV& aVVs = myDS->InterfVV();
aVVs.SetIncrement(theVertIndices.Extent());
//
aItLI.Initialize(theVertIndices);
for (; aItLI.More(); aItLI.Next()) {
Standard_Integer n1 = aItLI.Value();
myDS->AddShapeSD(n1, n);
//
BOPCol_ListIteratorOfListOfInteger aItLI2 = aItLI;
aItLI2.Next();
for (; aItLI2.More(); aItLI2.Next()) {
Standard_Integer n2 = aItLI2.Value();
//
myDS->AddInterf(n1, n2);
BOPDS_InterfVV& aVV = aVVs.Append1();
//
aVV.SetIndices(n1, n2);
aVV.SetIndexNew(n);
}
}
}

232
src/BOPAlgo/BOPAlgo_PaveFiller_11.cxx Normal file
View File

@ -0,0 +1,232 @@
// Created by: Peter KURNEV
// Copyright (c) 2010-2014 OPEN CASCADE SAS
// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// 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 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.
#include <BOPAlgo_PaveFiller.hxx>
#include <Precision.hxx>
#include <gp_Pnt.hxx>
#include <Bnd_Box.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Edge.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
#include <BRepBndLib.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_VectorOfListOfPaveBlock.hxx>
#include <BOPDS_MapOfCommonBlock.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DS.hxx>
//=======================================================================
//function : SetNonDestructive
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetNonDestructive()
{
if (!myIsPrimary || myNonDestructive) {
return;
}
//
Standard_Boolean bFlag;
BOPCol_ListIteratorOfListOfShape aItLS;
//
bFlag=Standard_False;
aItLS.Initialize(myArguments);
for(; aItLS.More() && (!bFlag); aItLS.Next()) {
const TopoDS_Shape& aS=aItLS.Value();
bFlag=aS.Locked();
}
myNonDestructive=bFlag;
}
//=======================================================================
//function : UpdateEdgeTolerance
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdateEdgeTolerance (const Standard_Integer nE,
const Standard_Real aTol)
{
Standard_Boolean bIsNewShape, bHasShapeSD;
Standard_Integer nV, nVx;
Standard_Real aTolV;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfInteger aIt;
//
BOPDS_ShapeInfo& aSIE=myDS->ChangeShapeInfo(nE);
const BOPCol_ListOfInteger& aLI=aSIE.SubShapes();
//
if (myNonDestructive) {
bIsNewShape=myDS->IsNewShape(nE);
if (!bIsNewShape) {
return;
}
//
aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) {
nV = aIt.Value();
bHasShapeSD=myDS->HasShapeSD(nV, nVx);
if (bHasShapeSD) {
continue;
}
bIsNewShape=myDS->IsNewShape(nV);
if (!bIsNewShape) {
return;
}
}
}
//
const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(nE);
aBB.UpdateEdge(aE, aTol);
Bnd_Box& aBoxE=aSIE.ChangeBox();
BRepBndLib::Add(aE, aBoxE);
aBoxE.SetGap(aBoxE.GetGap() + Precision::Confusion());
//
aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) {
nV = aIt.Value();
bHasShapeSD=myDS->HasShapeSD(nV, nVx);
if (bHasShapeSD) {
nV=nVx;
}
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV);
aTolV = BRep_Tool::Tolerance(aV);
if (aTolV < aTol) {
aBB.UpdateVertex(aV, aTol);
BOPDS_ShapeInfo& aSIV = myDS->ChangeShapeInfo(nV);
Bnd_Box& aBoxV = aSIV.ChangeBox();
BRepBndLib::Add(aV, aBoxV);
aBoxV.SetGap(aBoxV.GetGap() + Precision::Confusion());
}
}
}
//=======================================================================
//function : UpdateVertex
//purpose :
//=======================================================================
Standard_Integer BOPAlgo_PaveFiller::UpdateVertex
(const Standard_Integer nV,
const Standard_Real aTolNew)
{
Standard_Integer nVNew;
Standard_Real aTolV;
BRep_Builder aBB;
nVNew = nV;
if (myDS->IsNewShape(nVNew) ||
myDS->HasShapeSD(nV, nVNew) ||
!myNonDestructive) {
// nV is a new vertex, it has SD or non-destructive mode is not in force
const TopoDS_Vertex& aVSD = *(TopoDS_Vertex*)&myDS->Shape(nVNew);
aTolV = BRep_Tool::Tolerance(aVSD);
if (aTolV < aTolNew) {
aBB.UpdateVertex(aVSD, aTolNew);
BOPDS_ShapeInfo& aSIV = myDS->ChangeShapeInfo(nVNew);
Bnd_Box& aBoxV = aSIV.ChangeBox();
BRepBndLib::Add(aVSD, aBoxV);
aBoxV.SetGap(aBoxV.GetGap() + Precision::Confusion());
}
return nVNew;
}
//
// nV is old vertex
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV);
aTolV = BRep_Tool::Tolerance(aV);
//
// create new vertex
TopoDS_Vertex aVNew;
gp_Pnt aPV = BRep_Tool::Pnt(aV);
aBB.MakeVertex(aVNew, aPV, Max(aTolV, aTolNew));
//
// append new vertex to DS
BOPDS_ShapeInfo aSIV;
aSIV.SetShapeType(TopAbs_VERTEX);
aSIV.SetShape(aVNew);
nVNew = myDS->Append(aSIV);
//
// bounding box for the new vertex
BOPDS_ShapeInfo& aSIDS = myDS->ChangeShapeInfo(nVNew);
Bnd_Box& aBoxDS = aSIDS.ChangeBox();
BRepBndLib::Add(aVNew, aBoxDS);
aBoxDS.SetGap(aBoxDS.GetGap() + Precision::Confusion());
//
// add vertex to SD map
myDS->AddShapeSD(nV, nVNew);
//
myDS->InitPaveBlocksForVertex(nV);
//
return nVNew;
}
//=======================================================================
//function : UpdatePaveBlocksWithSDVertices
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdatePaveBlocksWithSDVertices()
{
myDS->UpdatePaveBlocksWithSDVertices();
}
//=======================================================================
//function : UpdateCommonBlocksWithSDVertices
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdateCommonBlocksWithSDVertices()
{
if (!myNonDestructive) {
UpdatePaveBlocksWithSDVertices();
return;
}
Standard_Integer aNbPBP;
//
BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
aNbPBP=aPBP.Extent();
if(!aNbPBP) {
return;
}
//
Standard_Integer i, nV1, nV2;
Standard_Real aTolV;
BOPDS_MapOfCommonBlock aMCB;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
Handle(BOPDS_PaveBlock) aPB;
//
aTolV = Precision::Confusion();
//
for (i=0; i<aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
aPB=aItPB.Value();
const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
if (aCB.IsNull()) {
continue;
}
//
if (aMCB.Add(aCB)) {
myDS->SortPaveBlocks(aCB);
aPB->Indices(nV1, nV2);
UpdateVertex(nV1, aTolV);
UpdateVertex(nV2, aTolV);
myDS->UpdateCommonBlockWithSDVertices(aCB);
}
}
}
UpdatePaveBlocksWithSDVertices();
}

82
src/BOPAlgo/BOPAlgo_PaveFiller_2.cxx
View File

@ -28,14 +28,17 @@
#include <BOPDS_PassKey.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_VectorOfInterfVE.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_Tools.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
#include <Precision.hxx>
//=======================================================================
//class : BOPAlgo_VertexEdgeEdge
@ -48,7 +51,7 @@ class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
BOPAlgo_VertexEdge() :
BOPAlgo_Algo(),
myIV(-1), myIE(-1), myIVx(-1), myFlag(-1), myT(-1.) {
myIV(-1), myIE(-1), myIVx(-1), myFlag(-1), myT(-1.), myTolVNew(-1.) {
};
//
virtual ~BOPAlgo_VertexEdge(){
@ -74,15 +77,15 @@ class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
myV=aV;
}
//
const TopoDS_Vertex& Vertex()const {
return myV;
}
//
void SetEdge(const TopoDS_Edge& aE) {
myE=aE;
}
//
const TopoDS_Edge& Edge()const {
const TopoDS_Vertex& Vertex() const {
return myV;
}
//
const TopoDS_Edge& Edge() const {
return myE;
}
//
@ -94,6 +97,10 @@ class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
return myT;
}
//
Standard_Real VertexNewTolerance()const {
return myTolVNew;
}
//
void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext;
}
@ -104,7 +111,7 @@ class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
//
virtual void Perform() {
BOPAlgo_Algo::UserBreak();
myFlag=myContext->ComputeVE (myV, myE, myT);
myFlag=myContext->ComputeVE (myV, myE, myT, myTolVNew);
};
//
protected:
@ -113,6 +120,7 @@ class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
Standard_Integer myIVx;
Standard_Integer myFlag;
Standard_Real myT;
Standard_Real myTolVNew;
TopoDS_Vertex myV;
TopoDS_Edge myE;
Handle(IntTools_Context) myContext;
@ -140,15 +148,16 @@ void BOPAlgo_PaveFiller::PerformVE()
{
Standard_Boolean bJustAdd;
Standard_Integer iSize, nV, nE, nVSD, iFlag, nVx, k, aNbVE;
Standard_Real aT, aTolE, aTolV;
Standard_Real aT, aT1, aT2, aTS1, aTS2;
BOPDS_Pave aPave;
BOPDS_PassKey aPK;
BOPDS_MapOfPassKey aMPK;
BRep_Builder aBB;
BOPAlgo_VectorOfVertexEdge aVVE;
//
myErrorStatus=0;
//
FillShrunkData(TopAbs_VERTEX, TopAbs_EDGE);
//
myIterator->Initialize(TopAbs_VERTEX, TopAbs_EDGE);
iSize=myIterator->ExpectedLength();
if (!iSize) {
@ -188,6 +197,12 @@ void BOPAlgo_PaveFiller::PerformVE()
continue;
}
//
const BOPDS_ListOfPaveBlock& aLPB = myDS->PaveBlocks(nE);
if (aLPB.IsEmpty() || !aLPB.First()->HasShrunkData()) {
// this is a micro edge, ignore it
continue;
}
//
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aSIE.Shape()));
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nVx)));
//
@ -211,29 +226,50 @@ void BOPAlgo_PaveFiller::PerformVE()
if (!iFlag) {
aVESolver.Indices(nV, nE, nVx);
aT=aVESolver.Parameter();
const TopoDS_Vertex& aV=aVESolver.Vertex();
const TopoDS_Edge& aE=aVESolver.Edge();
//
// check if vertex hits beyond shrunk range, in such case create V-V interf
const BOPDS_ListOfPaveBlock& aLPB = myDS->PaveBlocks(nE);
const Handle(BOPDS_PaveBlock)& aPB = aLPB.First();
Bnd_Box aBox;
aPB->Range(aT1, aT2);
aPB->ShrunkData(aTS1, aTS2, aBox);
IntTools_Range aPaveR[2] = { IntTools_Range(aT1, aTS1), IntTools_Range(aTS2, aT2) };
Standard_Real aTol = Precision::Confusion();
Standard_Boolean isOnPave = Standard_False;
for (Standard_Integer i = 0; i < 2; i++) {
if (IntTools_Tools::IsOnPave1(aT, aPaveR[i], aTol)) {
Standard_Integer nV1 = (i == 0 ? aPB->Pave1().Index() : aPB->Pave2().Index());
if (!myDS->HasInterf(nV, nV1)) {
BOPCol_ListOfInteger aLI;
aLI.Append(nV);
aLI.Append(nV1);
MakeSDVertices(aLI);
}
isOnPave = Standard_True;
break;
}
}
if (isOnPave)
continue;
//
// 1
BOPDS_InterfVE& aVE=aVEs.Append1();
aVE.SetIndices(nV, nE);
aVE.SetParameter(aT);
// 2
myDS->AddInterf(nV, nE);
// 3
BOPDS_ListOfPaveBlock& aLPB=myDS->ChangePaveBlocks(nE);
Handle(BOPDS_PaveBlock)& aPB=*((Handle(BOPDS_PaveBlock)*)&aLPB.First());
//
//
// 3 update vertex V/E if necessary
Standard_Real aTolVNew = aVESolver.VertexNewTolerance();
nVx=UpdateVertex(nV, aTolVNew);
//4
if (myDS->IsNewShape(nVx)) {
aVE.SetIndexNew(nVx);
}
//5 append ext pave to pave block
aPave.SetIndex(nVx);
aPave.SetParameter(aT);
aPB->AppendExtPave(aPave);
aTolV = BRep_Tool::Tolerance(aV);
aTolE = BRep_Tool::Tolerance(aE);
if ( aTolV < aTolE) {
aBB.UpdateVertex(aV, aTolE);
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVx);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBoxDS);
}
}
}//for (k=0; k < aNbVE; ++k) {
}

158
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
View File

@ -40,10 +40,11 @@
#include <BOPDS_PaveBlock.hxx>
#include <BOPDS_VectorOfInterfEE.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
#include <BRepTools.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_CommonPrt.hxx>
@ -61,12 +62,6 @@
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
//
//
//
//
//
//
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//class : BOPAlgo_EdgeEdge
@ -239,7 +234,8 @@ class BOPAlgo_PVE {
}
//
void Perform() {
myFlag=myContext->ComputeVE (myV, myE, myT);
Standard_Real dummy;
myFlag = myContext->ComputeVE(myV, myE, myT, dummy);
};
//
protected:
@ -392,7 +388,19 @@ void BOPAlgo_PaveFiller::PerformEE()
aR21(aT21, aTS21), aR22(aTS22, aT22);
//
const IntTools_SequenceOfCommonPrts& aCPrts = anEdgeEdge.CommonParts();
aNbCPrts=aCPrts.Length();
aNbCPrts = aCPrts.Length();
//
Standard_Boolean bLineLine = Standard_False;
if (aNbCPrts) {
const TopoDS_Edge& aOE1 = *(TopoDS_Edge*)&myDS->Shape(nE1);
const TopoDS_Edge& aOE2 = *(TopoDS_Edge*)&myDS->Shape(nE2);
//
BRepAdaptor_Curve aBAC1(aOE1), aBAC2(aOE2);
//
bLineLine = (aBAC1.GetType() == GeomAbs_Line &&
aBAC2.GetType() == GeomAbs_Line);
}
//
for (i=1; i<=aNbCPrts; ++i) {
const IntTools_CommonPrt& aCPart=aCPrts(i);
//
@ -448,10 +456,19 @@ void BOPAlgo_PaveFiller::PerformEE()
}
//
BOPTools_AlgoTools::MakeNewVertex(aE1, aT1, aE2, aT2, aVnew);
Standard_Real aTolVnew = BRep_Tool::Tolerance(aVnew);
if (bLineLine) {
// increase tolerance for Line/Line intersection, but do not update
// the vertex till its intersection with some other shape
Standard_Real aTol = (aCR1.Last() - aCR1.First()) / 2.;
if (aTol > aTolVnew) {
aTolVnew = aTol;
}
}
// <-LXBR
{
Standard_Integer nVS[2], iFound;
Standard_Real aTolVx, aTolVnew, aD2, aDT2;
Standard_Real aTolVx, aD2, aDT2;
BOPCol_MapOfInteger aMV;
gp_Pnt aPnew, aPx;
//
@ -469,7 +486,6 @@ void BOPAlgo_PaveFiller::PerformEE()
nVS[j]=nV[3];
}
//
aTolVnew=BRep_Tool::Tolerance(aVnew);
aPnew=BRep_Tool::Pnt(aVnew);
//
for (Standard_Integer k1=0; k1<=j; ++k1) {
@ -503,6 +519,7 @@ void BOPAlgo_PaveFiller::PerformEE()
//
aCPB.SetPaveBlocks(aPB1, aPB2);
aCPB.SetIndexInterf(iX);
aCPB.SetTolerance(aTolVnew);
aMVCPB.Add(aVnew, aCPB);
}//case TopAbs_VERTEX:
break;
@ -571,7 +588,7 @@ void BOPAlgo_PaveFiller::PerformEE()
aMPBToUpdate.Clear();
}
//=======================================================================
//function : PerformVertices
//function : PerformVerticesEE
//purpose :
//=======================================================================
Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEE
@ -603,17 +620,8 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEE
BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
//
// 1 prepare arguments
//
// <- DEB
for (i=1; i<=aNbV; ++i) {
const TopoDS_Shape& aS=theMVCPB.FindKey(i);
const BOPDS_CoupleOfPaveBlocks& aCPB=theMVCPB.FindFromIndex(i);
iV=aCPB.IndexInterf();
aMVI.Add(aS, iV);
}
//
// 2 Fuse vertices
TreatNewVertices(aMVI, aImages);
TreatNewVertices(theMVCPB, aImages);
//
// 3 Add new vertices to myDS;
// connect indices to CPB structure
@ -628,6 +636,7 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEE
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(iV);
Bnd_Box& aBox=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBox);
aBox.SetGap(aBox.GetGap() + Precision::Confusion());
//
aItLS.Initialize(aLVSD);
for (; aItLS.More(); aItLS.Next()) {
@ -729,33 +738,30 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEE
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::TreatNewVertices
(const BOPCol_IndexedDataMapOfShapeInteger& aMapVI,
(const BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
BOPCol_IndexedDataMapOfShapeListOfShape& myImages)
{
Standard_Integer i, aNbV;//, aNbVSD;
Standard_Real aTol;
TopoDS_Vertex aVnew;
TopoDS_Shape aVF;
BOPCol_IndexedMapOfShape aMVProcessed;
BOPCol_MapOfInteger aMFence;
BOPCol_ListIteratorOfListOfInteger aIt;
BOPCol_IndexedDataMapOfShapeListOfShape aDMVLV;
NCollection_Vector<BOPCol_ListOfShape> aVecOfLVSD;
//
BOPCol_BoxBndTreeSelector aSelector;
BOPCol_BoxBndTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer,
Bnd_Box> aTreeFiller(aBBTree);
BOPAlgo_VectorOfTNV aVTNV;
//
aNbV = aMapVI.Extent();
aNbV = theMVCPB.Extent();
for (i=1; i<=aNbV; ++i) {
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMapVI.FindKey(i));
const TopoDS_Vertex& aV = *((TopoDS_Vertex*)&theMVCPB.FindKey(i));
Bnd_Box aBox;
//
aTol=BRep_Tool::Tolerance(aV);
aBox.SetGap(aTol);
aTol = theMVCPB.FindFromIndex(i).Tolerance();
aBox.Add(BRep_Tool::Pnt(aV));
aBox.Enlarge(aTol);
aBox.SetGap(aTol);
//
aTreeFiller.Add(i, aBox);
//
@ -806,14 +812,8 @@ void BOPAlgo_PaveFiller::TreatNewVertices
break; // from for(;;)
}
//
aLIP.Clear();
aItLIP.Initialize(aLIP1);
for(; aItLIP.More(); aItLIP.Next()) {
aIP=aItLIP.Value();
aLIP.Append(aIP);
aLIPC.Append(aIP);
}
aLIP1.Clear();
aLIP = aLIP1;
aLIPC.Append(aLIP1); // items of aLIP1 are moved to aLIPC
}// for(;;) {
//
aItLIP.Initialize(aLIPC);
@ -822,23 +822,15 @@ void BOPAlgo_PaveFiller::TreatNewVertices
const TopoDS_Vertex& aVP=aVTNV(aIP-1).Vertex();
aLVSD.Append(aVP);
}
aVF=aLVSD.First();
aDMVLV.Add(aVF, aLVSD);
aVecOfLVSD.Append(aLVSD);
}// for (i=1; i<=aNbV; ++i) {
// Make new vertices
aNbV = aDMVLV.Extent();
for (i = 1; i <= aNbV; ++i) {
const TopoDS_Shape& aV = aDMVLV.FindKey(i);
const BOPCol_ListOfShape& aLVSD = aDMVLV(i);
if (aLVSD.IsEmpty()) {
myImages.Add(aV, aLVSD);
}
else {
BOPCol_ListOfShape* pLVSD=(BOPCol_ListOfShape*)&aLVSD;
BOPTools_AlgoTools::MakeVertex(*pLVSD, aVnew);
myImages.Add(aVnew, aLVSD);
}
aNbV = aVecOfLVSD.Size();
for (i = 0; i < aNbV; ++i) {
const BOPCol_ListOfShape& aLVSD = aVecOfLVSD(i);
BOPTools_AlgoTools::MakeVertex(aLVSD, aVnew);
myImages.Add(aVnew, aLVSD);
}
}
//=======================================================================
@ -891,8 +883,8 @@ void BOPAlgo_PaveFiller::ForceInterfVE(const Standard_Integer nV,
Handle(BOPDS_PaveBlock)& aPB,
BOPDS_MapOfPaveBlock& aMPBToUpdate)
{
Standard_Integer aNbPnt, nE;
gp_Pnt aP;
Standard_Integer nE, nVx, nVSD, iFlag;
Standard_Real aT, aTolVNew;
//
nE = aPB->OriginalEdge();
//
@ -909,60 +901,44 @@ void BOPAlgo_PaveFiller::ForceInterfVE(const Standard_Integer nV,
return;
}
//
if (aPB->Pave1().Index() == nV || aPB->Pave2().Index() == nV) {
if (aPB->Pave1().Index() == nV ||
aPB->Pave2().Index() == nV) {
return;
}
//
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV);
nVx = nV;
if (myDS->HasShapeSD(nV, nVSD)) {
nVx = nVSD;
}
//
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nVx);
const TopoDS_Edge& aE = *(TopoDS_Edge*) &myDS->Shape(nE);
aP=BRep_Tool::Pnt(aV);
//
GeomAPI_ProjectPointOnCurve& aProjector=myContext->ProjPC(aE);
aProjector.Perform(aP);
//
aNbPnt = aProjector.NbPoints();
if (aNbPnt) {
Standard_Real aT, aDist;
//Standard_Integer i;
BRep_Builder aBB;
iFlag = myContext->ComputeVE(aV, aE, aT, aTolVNew);
if (iFlag == 0 || iFlag == -4) {
BOPDS_Pave aPave;
//
aDist=aProjector.LowerDistance();
aT=aProjector.LowerDistanceParameter();
//
BOPDS_VectorOfInterfVE& aVEs=myDS->InterfVE();
aVEs.SetIncrement(10);
// 1
BOPDS_InterfVE& aVE=aVEs.Append1();
aVE.SetIndices(nV, nE);
aVE.SetParameter(aT);
//
// 2
myDS->AddInterf(nV, nE);
//
aBB.UpdateVertex(aV, aDist);
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV);
Bnd_Box& aBox=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBox);
//
aPave.SetIndex(nV);
// 3 update vertex V/E if necessary
nVx=UpdateVertex(nV, aTolVNew);
// 4
if (myDS->IsNewShape(nVx)) {
aVE.SetIndexNew(nVx);
}
// 5 append ext pave to pave block
aPave.SetIndex(nVx);
aPave.SetParameter(aT);
aPB->AppendExtPave(aPave);
//
aMPBToUpdate.Add(aPB);
}
}
/*
// DEBf
{
TopoDS_Compound aCx;
BRep_Builder aBBx;
aBBx.MakeCompound(aCx);
aItMVCPB.Initialize(theMVCPB);
for (; aItMVCPB.More(); aItMVCPB.Next()) {
const TopoDS_Shape& aS=aItMVCPB.Key();
aBBx.Add(aCx, aS);
}
BRepTools::Write(aCx, "cx");
}
// DEBt
*/

38
src/BOPAlgo/BOPAlgo_PaveFiller_4.cxx
View File

@ -54,7 +54,7 @@ class BOPAlgo_VertexFace : public BOPAlgo_Algo {
BOPAlgo_VertexFace() :
BOPAlgo_Algo(),
myIV(-1), myIF(-1), myIVx(-1),
myFlag(-1), myT1(-1.), myT2(-1.) {
myFlag(-1), myT1(-1.), myT2(-1.), myTolVNew(-1.) {
}
//
virtual ~BOPAlgo_VertexFace(){
@ -102,6 +102,10 @@ class BOPAlgo_VertexFace : public BOPAlgo_Algo {
aT2=myT2;
}
//
Standard_Real VertexNewTolerance()const {
return myTolVNew;
}
//
void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext;
}
@ -112,7 +116,7 @@ class BOPAlgo_VertexFace : public BOPAlgo_Algo {
//
virtual void Perform() {
BOPAlgo_Algo::UserBreak();
myFlag=myContext->ComputeVF(myV, myF, myT1, myT2);
myFlag=myContext->ComputeVF(myV, myF, myT1, myT2, myTolVNew);
}
//
protected:
@ -122,6 +126,7 @@ class BOPAlgo_VertexFace : public BOPAlgo_Algo {
Standard_Integer myFlag;
Standard_Real myT1;
Standard_Real myT2;
Standard_Real myTolVNew;
TopoDS_Vertex myV;
TopoDS_Face myF;
Handle(IntTools_Context) myContext;
@ -149,8 +154,7 @@ void BOPAlgo_PaveFiller::PerformVF()
{
Standard_Boolean bJustAdd;
Standard_Integer iSize, nV, nF, nVSD, iFlag, nVx, aNbVF, k;
Standard_Real aT1, aT2, aTolF, aTolV;
BRep_Builder aBB;
Standard_Real aT1, aT2;
BOPAlgo_VectorOfVertexFace aVVF;
//
myErrorStatus=0;
@ -214,27 +218,25 @@ void BOPAlgo_PaveFiller::PerformVF()
//
aVertexFace.Indices(nV, nF, nVx);
aVertexFace.Parameters(aT1, aT2);
const TopoDS_Vertex& aV=aVertexFace.Vertex();
const TopoDS_Face& aF=aVertexFace.Face();
// 1
BOPDS_InterfVF& aVF=aVFs.Append1();
aVF.SetIndices(nVx, nF);
aVF.SetUV(aT1, aT2);
// 2
myDS->AddInterf(nVx, nF);
// 3
//
// 3 update vertex V/F if necessary
Standard_Real aTolVNew = aVertexFace.VertexNewTolerance();
nVx=UpdateVertex(nVx, aTolVNew);
//
// 4
if (myDS->IsNewShape(nVx)) {
aVF.SetIndexNew(nVx);
}
// 5 update FaceInfo
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
aMVIn.Add(nVx);
// 4
aTolV = BRep_Tool::Tolerance(aV);
aTolF = BRep_Tool::Tolerance(aF);
if (aTolV < aTolF) {
aBB.UpdateVertex(aV, aTolF);
BOPDS_ShapeInfo& aSIV = myDS->ChangeShapeInfo(nVx);
Bnd_Box& aBoxV = aSIV.ChangeBox();
BRepBndLib::Add(aV, aBoxV);
}
}//for (k=0; k < aNbVF; ++k) {
}// if (iSize) {
else {
@ -252,7 +254,7 @@ void BOPAlgo_PaveFiller::PerformVF()
void BOPAlgo_PaveFiller::TreatVerticesEE()
{
Standard_Integer i, aNbS,aNbEEs, nF, nV, iFlag;
Standard_Real aT1, aT2;
Standard_Real aT1, aT2, dummy;
BOPCol_ListIteratorOfListOfInteger aItLI;
Handle(NCollection_BaseAllocator) aAllocator;
//
@ -313,7 +315,7 @@ void BOPAlgo_PaveFiller::TreatVerticesEE()
if (!aMVOn.Contains(nV)) {
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nV)));
const TopoDS_Face& aF=(*(TopoDS_Face *)(&myDS->Shape(nF)));
iFlag=myContext->ComputeVF(aV, aF, aT1, aT2);
iFlag = myContext->ComputeVF(aV, aF, aT1, aT2, dummy);
if (!iFlag) {
// 1
BOPDS_InterfVF& aVF=aVFs.Append1();

204
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
View File

@ -16,6 +16,8 @@
// commercial license or contractual agreement.
#include <Precision.hxx>
#include <Bnd_Box.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
@ -23,6 +25,7 @@
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
#include <BOPCol_DataMapOfShapeReal.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_CoupleOfPaveBlocks.hxx>
#include <BOPDS_Curve.hxx>
@ -46,19 +49,11 @@
#include <IntTools_Range.hxx>
#include <IntTools_SequenceOfCommonPrts.hxx>
#include <IntTools_Tools.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
//
//
//
//
//
//
//
//
//
//=======================================================================
//class : BOPAlgo_EdgeFace
//purpose :
@ -159,7 +154,6 @@ void BOPAlgo_PaveFiller::PerformEF()
TopAbs_ShapeEnum aType;
BOPDS_ListIteratorOfListOfPaveBlock aIt;
BOPAlgo_VectorOfEdgeFace aVEdgeFace;
BRep_Builder aBB;
//-----------------------------------------------------scope f
//
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
@ -272,7 +266,17 @@ void BOPAlgo_PaveFiller::PerformEF()
const BOPCol_MapOfInteger& aMIFIn=aFI.VerticesIn();
//~~~
const IntTools_SequenceOfCommonPrts& aCPrts=aEdgeFace.CommonParts();
aNbCPrts=aCPrts.Length();
aNbCPrts = aCPrts.Length();
//
Standard_Boolean bLinePlane = Standard_False;
if (aNbCPrts) {
BRepAdaptor_Curve aBAC(aE);
BRepAdaptor_Surface aBAS(aF, Standard_False);
//
bLinePlane = (aBAC.GetType() == GeomAbs_Line &&
aBAS.GetType() == GeomAbs_Plane);
}
for (i=1; i<=aNbCPrts; ++i) {
const IntTools_CommonPrt& aCPart=aCPrts(i);
aType=aCPart.Type();
@ -294,7 +298,8 @@ void BOPAlgo_PaveFiller::PerformEF()
bIsOnPave[0]=IntTools_Tools::IsInRange(aR1, aR, aTolToDecide);
bIsOnPave[1]=IntTools_Tools::IsInRange(aR2, aR, aTolToDecide);
//
if (bIsOnPave[0] && bIsOnPave[1]) {
if ((bIsOnPave[0] && bIsOnPave[1]) ||
(bLinePlane && (bIsOnPave[0] || bIsOnPave[1]))) {
bV[0]=CheckFacePaves(nV[0], aMIFOn, aMIFIn);
bV[1]=CheckFacePaves(nV[1], aMIFOn, aMIFIn);
if (bV[0] && bV[1]) {
@ -318,10 +323,23 @@ void BOPAlgo_PaveFiller::PerformEF()
if (bV[j]) {
const TopoDS_Vertex& aV=
(*(TopoDS_Vertex *)(&myDS->Shape(nV[j])));
BOPTools_AlgoTools::UpdateVertex(aE, aT, aV);
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV[j]);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBoxDS);
//
Standard_Real f, l, aTolVnew, aDistPP, aTolPC, aTolV;
//
const Handle(Geom_Curve)& aCur = BRep_Tool::Curve(aE, f, l);
//
gp_Pnt aP1 = BRep_Tool::Pnt(aV);
gp_Pnt aP2 = aCur->Value(aT);
//
aDistPP=aP1.Distance(aP2);
aTolPC=Precision::PConfusion();
aTolV=BRep_Tool::Tolerance(aV);
if (aDistPP > (aTolV+aTolPC)) {
aTolVnew=Max(aTolE, aDistPP);
UpdateVertex(nV[j], aTolVnew);
}
}
else {
bIsOnPave[j] = ForceInterfVF(nV[j], nF);
@ -334,15 +352,21 @@ void BOPAlgo_PaveFiller::PerformEF()
continue;
}
//
const gp_Pnt& aPnew = BRep_Tool::Pnt(aVnew);
Standard_Real aTolV = BRep_Tool::Tolerance(aVnew);
aTolV = Max(aTolV, Max(aTolE, aTolF));
//
if (!myContext->IsPointInFace(aPnew, aF, aTolV)) {
continue;
Standard_Real aTolVnew = BRep_Tool::Tolerance(aVnew);
aTolVnew = Max(aTolVnew, Max(aTolE, aTolF));
BRep_Builder().UpdateVertex(aVnew, aTolVnew);
if (bLinePlane) {
// increase tolerance for Line/Plane intersection, but do not update
// the vertex till its intersection with some other shape
IntTools_Range aCR = aCPart.Range1();
aTolVnew = Max(aTolVnew, (aCR.Last() - aCR.First()) / 2.);
}
//
aBB.UpdateVertex(aVnew, aTolV);
const gp_Pnt& aPnew = BRep_Tool::Pnt(aVnew);
//
if (!myContext->IsPointInFace(aPnew, aF, aTolVnew)) {
continue;
}
//
aMIEFC.Add(nF);
// 1
@ -357,6 +381,7 @@ void BOPAlgo_PaveFiller::PerformEF()
//
aCPB.SetPaveBlocks(aPB, aPB);
aCPB.SetIndexInterf(iX);
aCPB.SetTolerance(aTolVnew);
aMVCPB.Add(aVnew, aCPB);
}
}
@ -375,11 +400,6 @@ void BOPAlgo_PaveFiller::PerformEF()
myDS->AddInterf(nE, nF);
break;
}
//update tolerance of edge if needed
if (aTolE < aTolF) {
myDS->UpdateEdgeTolerance(nE, aTolF);
aTolE = aTolF;
}
aEF.SetCommonPart(aCPart);
// 2
myDS->AddInterf(nE, nF);
@ -417,7 +437,7 @@ void BOPAlgo_PaveFiller::PerformEF()
////aAllocator.Nullify();
}
//=======================================================================
//function : PerformVertices1
//function : PerformVerticesEF
//purpose :
//=======================================================================
Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
@ -433,7 +453,7 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
}
//
Standard_Integer nVx, nVSD, iV, iErr, nE, iFlag, iX, i, aNbPBLI;
Standard_Real aT;
Standard_Real aT, dummy;
TopoDS_Shape aV;
BOPCol_ListIteratorOfListOfShape aItLS;
BOPCol_ListIteratorOfListOfInteger aItLI;
@ -445,17 +465,28 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
BOPCol_DataMapOfShapeInteger aMVI(100, theAllocator);
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, theAllocator);
BOPAlgo_PaveFiller aPF(theAllocator);
BOPCol_DataMapOfShapeReal aMVIniTol;
//
aSI.SetShapeType(TopAbs_VERTEX);
BOPDS_VectorOfInterfEF& aEFs=myDS->InterfEF();
//
// 1 prepare arguments
for (i=1; i<=aNbV; ++i) {
const TopoDS_Shape& aS=theMVCPB.FindKey(i);
aLS.Append(aS);
const TopoDS_Vertex& aV = TopoDS::Vertex(theMVCPB.FindKey(i));
aLS.Append(aV);
// if an enlarged tolerance is associated with the vertex then update it
// remembering its initial tolerance
Standard_Real aTolEnlarged = theMVCPB.FindFromIndex(i).Tolerance();
Standard_Real aIniTol = BRep_Tool::Tolerance(aV);
if (aTolEnlarged > aIniTol) {
aMVIniTol.Bind(aV, aIniTol);
BRep_Builder().UpdateVertex(aV, aTolEnlarged);
}
}
//
// 2 Fuse vertices
aPF.SetIsPrimary(Standard_False);
aPF.SetNonDestructive(myNonDestructive);
aPF.SetArguments(aLS);
aPF.Perform();
iErr=aPF.ErrorStatus();
@ -465,7 +496,58 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
}
aPDS=aPF.PDS();
//
// Recompute common vertex for each SD group containing enlarged vertex;
// for that first fill in the map of SD vertex -> its counterparts
BOPCol_IndexedDataMapOfShapeListOfShape aImages;
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aVx = aItLS.Value();
nVx = aPDS->Index(aVx);
//
if (aPDS->HasShapeSD(nVx, nVSD)) {
aV = aPDS->Shape(nVSD);
}
else {
aV = aVx;
}
BOPCol_ListOfShape* pLst = aImages.ChangeSeek(aV);
if (!pLst) {
pLst = &aImages.ChangeFromIndex(aImages.Add(aV, BOPCol_ListOfShape()));
}
pLst->Append(aVx);
}
// 3 Add new vertices to theDS;
for (i = 1; i <= aImages.Extent(); i++) {
TopoDS_Vertex aV = TopoDS::Vertex(aImages.FindKey(i));
const BOPCol_ListOfShape& aLVSD = aImages.FindFromIndex(i);
Standard_Boolean isReset = Standard_False;
BOPCol_ListIteratorOfListOfShape it(aLVSD);
for (; it.More(); it.Next()) {
const TopoDS_Vertex& aVx = TopoDS::Vertex(it.Value());
const Standard_Real* pTolIni = aMVIniTol.Seek(aVx);
if (pTolIni) {
// reset enlarged vertex tolerance to the initial value
reinterpret_cast<BRep_TVertex*>(aVx.TShape().operator->())->Tolerance(*pTolIni);
isReset = Standard_True;
}
}
TopoDS_Vertex aVnew = aV;
if (isReset && aLVSD.Extent() > 1) {
// make new vertex again
BOPTools_AlgoTools::MakeVertex(aLVSD, aVnew);
}
// index of new vertex in theDS -> iV
aSI.SetShape(aVnew);
iV = myDS->Append(aSI);
//
BOPDS_ShapeInfo& aSIDS = myDS->ChangeShapeInfo(iV);
Bnd_Box& aBox = aSIDS.ChangeBox();
BRepBndLib::Add(aVnew, aBox);
aBox.SetGap(aBox.GetGap() + Precision::Confusion());
//
aMVI.Bind(aV, iV);
}
//
// 4 Map PaveBlock/ListOfVertices to add to this PaveBlock ->aMPBLI
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next()) {
@ -478,20 +560,7 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
else {
aV=aVx;
}
// index of new vertex in theDS -> iV
if (!aMVI.IsBound(aV)) {
aSI.SetShape(aV);
iV=myDS->Append(aSI);
//
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(iV);
Bnd_Box& aBox=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBox);
//
aMVI.Bind(aV, iV);
}
else {
iV=aMVI.Find(aV);
}
iV = aMVI.Find(aV);
//
BOPDS_CoupleOfPaveBlocks &aCPB=theMVCPB.ChangeFromKey(aVx);
aCPB.SetIndex(iV);
@ -527,7 +596,7 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
nVx=aItLI.Value();
const TopoDS_Vertex& aVx=(*(TopoDS_Vertex *)(&myDS->Shape(nVx)));
//
iFlag=myContext->ComputeVE (aVx, aE, aT);
iFlag=myContext->ComputeVE (aVx, aE, aT, dummy);
if (!iFlag) {
aPave.SetIndex(nVx);
aPave.SetParameter(aT);
@ -535,7 +604,7 @@ Standard_Integer BOPAlgo_PaveFiller::PerformVerticesEF
}
}
}
// 6 Split PaveBlocksa
// 6 Split PaveBlocks
for (i=1; i<=aNbPBLI; ++i) {
Handle(BOPDS_PaveBlock) aPB=aMPBLI.FindKey(i);
nE=aPB->OriginalEdge();
@ -620,46 +689,37 @@ Standard_Boolean BOPAlgo_PaveFiller::ForceInterfVF
const Standard_Integer nF)
{
Standard_Boolean bRet;
Standard_Integer iFlag, nVx;
Standard_Real U, V, aTolVNew;
//
bRet = Standard_False;
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&myDS->Shape(nV);
const TopoDS_Face& aF = *(TopoDS_Face*) &myDS->Shape(nF);
//
GeomAPI_ProjectPointOnSurf& aProj = myContext->ProjPS(aF);
const gp_Pnt& aP = BRep_Tool::Pnt(aV);
aProj.Perform(aP);
if (!aProj.IsDone()) {
return bRet;
}
Standard_Real aDist, U, V;
iFlag = myContext->ComputeVF(aV, aF, U, V, aTolVNew);
if (iFlag == 0 || iFlag == -2) {
bRet=!bRet;
//
aDist=aProj.LowerDistance();
aProj.LowerDistanceParameters(U, V);
//
gp_Pnt2d aP2d(U, V);
bRet = myContext->IsPointInFace (aF, aP2d);
if (bRet) {
//Standard_Integer i;
BRep_Builder aBB;
//
BOPDS_VectorOfInterfVF& aVFs=myDS->InterfVF();
aVFs.SetIncrement(10);
// 1
BOPDS_InterfVF& aVF=aVFs.Append1();
//
aVF.SetIndices(nV, nF);
aVF.SetUV(U, V);
//
// 2
myDS->AddInterf(nV, nF);
//
aBB.UpdateVertex(aV, aDist);
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBoxDS);
// 3 update vertex V/F if necessary
nVx=UpdateVertex(nV, aTolVNew);
// 4
if (myDS->IsNewShape(nVx)) {
aVF.SetIndexNew(nVx);
}
//
BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
BOPCol_MapOfInteger& aMVIn=aFI.ChangeVerticesIn();
aMVIn.Add(nV);
aMVIn.Add(nVx);
}
//
return bRet;
}

503
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -42,10 +42,12 @@
#include <BOPDS_ShapeInfo.hxx>
#include <BOPDS_VectorOfCurve.hxx>
#include <BOPDS_VectorOfPoint.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRep_TEdge.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBndLib.hxx>
@ -58,6 +60,7 @@
#include <gp_Pnt.hxx>
#include <IntSurf_ListOfPntOn2S.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <IntTools.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_Curve.hxx>
#include <IntTools_EdgeFace.hxx>
@ -70,6 +73,7 @@
#include <Precision.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
@ -181,7 +185,7 @@ void BOPAlgo_PaveFiller::PerformFF()
Standard_Boolean bToSplit, bTangentFaces;
Standard_Integer nF1, nF2, aNbCurves, aNbPoints, i, aNbLP;
Standard_Integer aNbFaceFace, k;
Standard_Real aApproxTol, aTolR3D, aTolR2D, aTolFF;
Standard_Real aApproxTol, aTolR3D, aTolR2D, aTolFF, aTolReal;
BRepAdaptor_Surface aBAS1, aBAS2;
BOPCol_MapOfInteger aMI;
BOPAlgo_VectorOfFaceFace aVFaceFace;
@ -204,22 +208,21 @@ void BOPAlgo_PaveFiller::PerformFF()
const TopoDS_Face& aF1=(*(TopoDS_Face *)(&myDS->Shape(nF1)));
const TopoDS_Face& aF2=(*(TopoDS_Face *)(&myDS->Shape(nF2)));
//
if (aMI.Add(nF1)) {
myDS->UpdateFaceInfoOn(nF1);
myDS->UpdateFaceInfoIn(nF1);
}
if (aMI.Add(nF2)) {
myDS->UpdateFaceInfoOn(nF2);
myDS->UpdateFaceInfoIn(nF2);
}
//
aBAS1.Initialize(aF1, Standard_False);
aBAS2.Initialize(aF2, Standard_False);
//
if (aBAS1.GetType() == GeomAbs_Plane &&
aBAS2.GetType() == GeomAbs_Plane) {
Standard_Boolean bToIntersect;
//
if (aMI.Add(nF1)) {
myDS->UpdateFaceInfoOn(nF1);
myDS->UpdateFaceInfoIn(nF1);
}
if (aMI.Add(nF2)) {
myDS->UpdateFaceInfoOn(nF2);
myDS->UpdateFaceInfoIn(nF2);
}
//
bToIntersect = CheckPlanes(nF1, nF2);
if (!bToIntersect) {
myDS->AddInterf(nF1, nF2);
@ -264,11 +267,15 @@ void BOPAlgo_PaveFiller::PerformFF()
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;
}
@ -290,6 +297,7 @@ void BOPAlgo_PaveFiller::PerformFF()
//
aFF.SetTolR3D(aTolR3D);
aFF.SetTolR2D(aTolR2D);
aFF.SetTolReal(aTolReal);
aFF.SetTangentFaces(bTangentFaces);
//
// Curves, Points
@ -525,10 +533,11 @@ void BOPAlgo_PaveFiller::MakeBlocks()
const TopoDS_Edge& aE = *(TopoDS_Edge*)&myDS->Shape(nE);
aTolE = BRep_Tool::Tolerance(aE);
if (aTolR3D > aTolE) {
myDS->UpdateEdgeTolerance(nE, aTolR3D);
UpdateEdgeTolerance(nE, aTolR3D);
}
bInBothFaces = Standard_False;
} else {
}
else {
bInBothFaces = (aFI1.PaveBlocksOn().Contains(aPBOut) ||
aFI1.PaveBlocksIn().Contains(aPBOut))&&
(aFI2.PaveBlocksOn().Contains(aPBOut) ||
@ -594,6 +603,8 @@ void BOPAlgo_PaveFiller::MakeBlocks()
if (myErrorStatus) {
return;
}
// reduce tolerances of section edges where it is appropriate
CorrectToleranceOfSE();
//
// update face info
UpdateFaceInfo(aDMExEdges, aDMI);
@ -630,19 +641,20 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
//
Standard_Boolean bHasPaveBlocks, bOld;
Standard_Integer iErr, nSx, nVSD, iX, iP, iC, j, nV, iV = 0, iE, k;
Standard_Integer jx, aNbLPBx;
Standard_Real aT;
Standard_Integer aNbLPBx;
TopAbs_ShapeEnum aType;
TopoDS_Shape aV, aE;
BOPCol_ListIteratorOfListOfShape aItLS;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPDS_PDS aPDS;
Handle(BOPDS_PaveBlock) aPB1;
BOPDS_Pave aPave[2], aPave1[2];
BOPDS_Pave aPave[2];
BOPDS_ShapeInfo aSI;
//
BOPCol_ListOfShape aLS(theAllocator);
BOPAlgo_PaveFiller aPF(theAllocator);
aPF.SetIsPrimary(Standard_False);
aPF.SetNonDestructive(myNonDestructive);
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
//
@ -756,7 +768,7 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
else {
aSI.SetShapeType(aType);
aSI.SetShape(aSx);
iE=myDS->Append(aSI);
iE = myDS->Append(aSI);
//
aPB1->SetEdge(iE);
}
@ -767,8 +779,21 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
BOPDS_Curve& aNC=aVNC(iC);
BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
//
const BOPDS_ListOfPaveBlock& aLPBx=aPDS->PaveBlocks(nSx);
aNbLPBx=aLPBx.Extent();
// check if edge occured to be micro edge;
// note we check not the edge aSx itself, but its image in aPDS
const BOPDS_ListOfPaveBlock& aLPBx = aPDS->PaveBlocks(nSx);
aNbLPBx = aLPBx.Extent();
if (aPDS->HasPaveBlocks(nSx) &&
(aNbLPBx == 0 || (aNbLPBx == 1 && !aLPBx.First()->HasShrunkData()))) {
BOPDS_ListIteratorOfListOfPaveBlock it(aLPBC);
for (; it.More(); it.Next()) {
if (it.Value() == aPB1) {
aLPBC.Remove(it);
break;
}
}
continue;
}
//
if (bOld && !aNbLPBx) {
aDMExEdges.ChangeFind(aPB1).Append(aPB1);
@ -805,10 +830,6 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
//
else {
aItLPB.Initialize(aLPBx);
if (bOld) {
aPave1[0] = aPB1->Pave1();
aPave1[1] = aPB1->Pave2();
}
for (; aItLPB.More(); aItLPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
const Handle(BOPDS_PaveBlock) aPBRx=aPDS->RealPaveBlock(aPBx);
@ -817,33 +838,18 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
aPave[0]=aPBx->Pave1();
aPave[1]=aPBx->Pave2();
for (j=0; j<2; ++j) {
jx = 0;
if (bOld) {
aT = aPave[j].Parameter();
if (aT == aPave1[0].Parameter()) {
jx = 1;
} else if (aT == aPave1[1].Parameter()) {
jx = 2;
}
//
if (jx) {
iV = aPave1[jx-1].Index();
}
}
if (!jx) {
nV=aPave[j].Index();
aV=aPDS->Shape(nV);
//
if (!aMVI.IsBound(aV)) {
// index of new vertex in theDS -> iV
aSI.SetShapeType(TopAbs_VERTEX);
aSI.SetShape(aV);
iV=myDS->Append(aSI);
aMVI.Bind(aV, iV);
}
else {
iV=aMVI.Find(aV);
}
nV = aPave[j].Index();
aV = aPDS->Shape(nV);
//
if (!aMVI.IsBound(aV)) {
// index of new vertex in theDS -> iV
aSI.SetShapeType(TopAbs_VERTEX);
aSI.SetShape(aV);
iV = myDS->Append(aSI);
aMVI.Bind(aV, iV);
}
else {
iV = aMVI.Find(aV);
}
const BOPDS_Pave& aP1 = !j ? aPB1->Pave1() : aPB1->Pave2();
if (aP1.Parameter() == aPave[j].Parameter() &&
@ -863,6 +869,14 @@ Standard_Integer BOPAlgo_PaveFiller::PostTreatFF
aSI.SetShape(aE);
iE=myDS->Append(aSI);
aMVI.Bind(aE, iE);
// update real edge tolerance according to distances in common block if any
if (aPDS->IsCommonBlock(aPBx)) {
const Handle(BOPDS_CommonBlock)& aCB = aPDS->CommonBlock(aPBx);
Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, aPDS, aPF.Context());
if (aFF.TolReal() < aTol) {
aFF.SetTolReal(aTol);
}
}
}
else {
iE=aMVI.Find(aE);
@ -1035,14 +1049,13 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
//function : IsExistingVertex
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::IsExistingVertex
(const gp_Pnt& aP,
const Standard_Real theTolR3D,
const BOPCol_MapOfInteger& aMVOnIn)const
Standard_Boolean BOPAlgo_PaveFiller::IsExistingVertex
(const gp_Pnt& aP,
const Standard_Real theTolR3D,
const BOPCol_MapOfInteger& aMVOnIn)const
{
Standard_Boolean bRet;
Standard_Integer nV, iFlag;
Standard_Real aTolV;
gp_Pnt aPV;
Bnd_Box aBoxP;
BOPCol_MapIteratorOfMapOfInteger aIt;
@ -1054,14 +1067,10 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
//
aIt.Initialize(aMVOnIn);
for (; aIt.More(); aIt.Next()) {
Bnd_Box aBoxV;
//
nV=aIt.Value();
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&myDS->Shape(nV)));
aPV=BRep_Tool::Pnt(aV);
aTolV=BRep_Tool::Tolerance(aV);
aBoxV.Add(aP);
aBoxV.Enlarge(aTolV);
const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
const TopoDS_Vertex& aV=(*(TopoDS_Vertex *)(&aSIV.Shape()));
const Bnd_Box& aBoxV=aSIV.Box();
//
if (!aBoxP.IsOut(aBoxV)) {
iFlag=BOPTools_AlgoTools::ComputeVV(aV, aP, theTolR3D);
@ -1076,11 +1085,11 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
//function : IsExistingPaveBlock
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
(const Handle(BOPDS_PaveBlock)& thePB,
const BOPDS_Curve& theNC,
const Standard_Real theTolR3D,
const BOPCol_ListOfInteger& theLSE)
Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
(const Handle(BOPDS_PaveBlock)& thePB,
const BOPDS_Curve& theNC,
const Standard_Real theTolR3D,
const BOPCol_ListOfInteger& theLSE)
{
Standard_Boolean bRet=Standard_True;
//
@ -1103,6 +1112,8 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
aItLI.Initialize(theLSE);
for (; aItLI.More(); aItLI.Next()) {
nE=aItLI.Value();
if (nE < 0)
continue;
const BOPDS_ShapeInfo& aSIE=myDS->ChangeShapeInfo(nE);
const Bnd_Box& aBoxE=aSIE.Box();
if (!aBoxE.IsOut(aBoxPm)) {
@ -1159,6 +1170,8 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
const Handle(BOPDS_PaveBlock)& aPB = theMPBOnIn(i);
aPB->Indices(nV21, nV22);
nSp=aPB->Edge();
if (nSp < 0)
continue;
const BOPDS_ShapeInfo& aSISp=myDS->ChangeShapeInfo(nSp);
const TopoDS_Edge& aSp=(*(TopoDS_Edge *)(&aSISp.Shape()));
const Bnd_Box& aBoxSp=aSISp.Box();
@ -1288,6 +1301,7 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVn);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aVn, aBoxDS);
aBoxDS.SetGap(aBoxDS.GetGap() + Precision::Confusion());
//
aLVB.Append(nVn);
}
@ -1418,9 +1432,10 @@ Standard_Boolean BOPAlgo_PaveFiller::ExtendedTolerance
//function : GetEFPnts
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::GetEFPnts(const Standard_Integer nF1,
const Standard_Integer nF2,
IntSurf_ListOfPntOn2S& aListOfPnts)
void BOPAlgo_PaveFiller::GetEFPnts
(const Standard_Integer nF1,
const Standard_Integer nF2,
IntSurf_ListOfPntOn2S& aListOfPnts)
{
Standard_Integer nE, nF, nFOpposite, aNbEFs, i;
Standard_Real U1, U2, V1, V2, f, l;
@ -1625,11 +1640,11 @@ Standard_Boolean BOPAlgo_PaveFiller::ExtendedTolerance
//function : GetStickVertices
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
const Standard_Integer nF2,
BOPCol_MapOfInteger& aMVStick,
BOPCol_MapOfInteger& aMVEF,
BOPCol_MapOfInteger& aMI)
void BOPAlgo_PaveFiller::GetStickVertices(const Standard_Integer nF1,
const Standard_Integer nF2,
BOPCol_MapOfInteger& aMVStick,
BOPCol_MapOfInteger& aMVEF,
BOPCol_MapOfInteger& aMI)
{
Standard_Integer nS1, nS2, nVNew, aTypeInt, i;
//
@ -1799,6 +1814,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVToUpdate);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aVToUpdate, aBoxDS);
aBoxDS.SetGap(aBoxDS.GetGap() + Precision::Confusion());
}
}
}
@ -1807,7 +1823,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
//function : ProcessOldPaveBlocks
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
(const Standard_Integer theInt,
const BOPDS_IndexedMapOfPaveBlock& aMPBOnIn,
const BOPCol_DataMapOfIntegerListOfInteger& aDMBV,
@ -1819,7 +1835,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
return;
}
//
Standard_Real aT;
Standard_Real aT, dummy;
Standard_Integer i, nV, nE, iC, aNbPB, iFlag;
BOPCol_ListIteratorOfListOfInteger aItLI;
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItBV;
@ -1857,6 +1873,9 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
if (aMPB.Contains(aPB)) {
continue;
}
if (myDS->ShapeInfo(aPB->OriginalEdge()).HasFlag()) { // skip degenerated edges
continue;
}
//
nE = aPB->Edge();
const BOPDS_ShapeInfo& aSIE = myDS->ShapeInfo(nE);
@ -1868,7 +1887,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
//
const TopoDS_Edge& aE = *(TopoDS_Edge*)&aSIE.Shape();
//
iFlag = myContext->ComputeVE(aV, aE, aT);
iFlag = myContext->ComputeVE(aV, aE, aT, dummy);
if (!iFlag) {
aMPB.Add(aPB);
PreparePostTreatFF(theInt, iC, aPB, aMSCPB, aMVI, aLPBC);
@ -1881,11 +1900,11 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
//function : UpdateExistingPaveBlocks
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdateExistingPaveBlocks
(const Handle(BOPDS_PaveBlock)& aPBf,
BOPDS_ListOfPaveBlock& aLPB,
const Standard_Integer nF1,
const Standard_Integer nF2)
void BOPAlgo_PaveFiller::UpdateExistingPaveBlocks
(const Handle(BOPDS_PaveBlock)& aPBf,
BOPDS_ListOfPaveBlock& aLPB,
const Standard_Integer nF1,
const Standard_Integer nF2)
{
Standard_Integer nE;
Standard_Boolean bCB;
@ -1967,7 +1986,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
myDS->SetCommonBlock(aPB2n, aCB);
myDS->ChangePaveBlocks(nE).Append(aPB2n);
}
aCB->AddFaces(aFaces);
aCB->SetFaces(aFaces);
myDS->SortPaveBlocks(aCB);
//
const Handle(BOPDS_PaveBlock)& aPBNew = aCB->PaveBlocks().First();
@ -2043,7 +2062,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
// function: PutClosingPaveOnCurve
// purpose:
//=======================================================================
void BOPAlgo_PaveFiller::PutClosingPaveOnCurve(BOPDS_Curve& aNC)
void BOPAlgo_PaveFiller::PutClosingPaveOnCurve(BOPDS_Curve& aNC)
{
Standard_Boolean bIsClosed, bHasBounds, bAdded;
Standard_Integer nVC, j;
@ -2098,7 +2117,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
//function : PreparePostTreatFF
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::PreparePostTreatFF
void BOPAlgo_PaveFiller::PreparePostTreatFF
(const Standard_Integer aInt,
const Standard_Integer aCur,
const Handle(BOPDS_PaveBlock)& aPB,
@ -2170,7 +2189,7 @@ Standard_Boolean BOPAlgo_PaveFiller::CheckPlanes
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdatePaveBlocks
(const BOPCol_DataMapOfIntegerInteger& aDMI)
(const BOPCol_DataMapOfIntegerInteger& aDMI)
{
if (aDMI.IsEmpty()) {
return;
@ -2181,25 +2200,28 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
Standard_Boolean bCB, bRebuild;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
BOPDS_MapOfPaveBlock aMPB;
BOPCol_MapOfInteger aMicroEdges;
//
BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
aNbPBP = aPBP.Extent();
for (i=0; i<aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
for (i = 0; i < aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
//
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
Handle(BOPDS_PaveBlock) aPB=aItPB.Value();
const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
Handle(BOPDS_PaveBlock) aPB = aItPB.Value();
const Handle(BOPDS_CommonBlock)& aCB = myDS->CommonBlock(aPB);
bCB = !aCB.IsNull();
if (bCB) {
aPB=aCB->PaveBlock1();
aPB = aCB->PaveBlock1();
}
//
if (aMPB.Add(aPB)) {
bRebuild = Standard_False;
aPB->Indices(nV[0], nV[1]);
aPB->Range(aT[0], aT[1]);
// remember the fact if the edge had different vertices before substitution
Standard_Boolean wasRegularEdge = (nV[0] != nV[1]);
//
for (j = 0; j < 2; ++j) {
if (aDMI.IsBound(nV[j])) {
@ -2212,13 +2234,28 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
bRebuild = Standard_True;
if (!j) {
aPB->SetPave1(aPave);
} else {
}
else {
aPB->SetPave2(aPave);
}
}
}
//
if (bRebuild) {
Standard_Boolean isDegEdge = myDS->ShapeInfo(aPB->Edge()).HasFlag();
if (wasRegularEdge && !isDegEdge && nV[0] == nV[1]) {
// now edge has the same vertex on both ends;
// check if it is not a regular closed curve.
const TopoDS_Edge& aE = TopoDS::Edge(myDS->Shape(aPB->Edge()));
const TopoDS_Vertex& aV = TopoDS::Vertex(myDS->Shape(nV[0]));
Standard_Real aLength = IntTools::Length(aE);
Standard_Real aTolV = BRep_Tool::Tolerance(aV);
if (aLength <= aTolV * 2.) {
// micro edge, so mark it for removal
aMicroEdges.Add(aPB->Edge());
continue;
}
}
nSp = SplitEdge(aPB->OriginalEdge(), nV[0], aT[0], nV[1], aT[1]);
if (bCB) {
aCB->SetEdge(nSp);
@ -2231,7 +2268,87 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
}// for (; aItPB.More(); aItPB.Next()) {
}// for (i=0; i<aNbPBP; ++i) {
aMPB.Clear();
if (aMicroEdges.Extent())
RemovePaveBlocks(aMicroEdges);
}
//=======================================================================
//function : RemovePaveBlocks
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::RemovePaveBlocks(const BOPCol_MapOfInteger theEdges)
{
// Remove all pave blocks referring to input edges:
//
// 1. from the Pave Blocks Pool
BOPDS_VectorOfListOfPaveBlock& aPBP = myDS->ChangePaveBlocksPool();
Standard_Integer aNbPBP = aPBP.Extent(), i;
for (i = 0; i < aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
//
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPB);
while (aItPB.More()) {
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
if (theEdges.Contains(aPB->Edge()))
aLPB.Remove(aItPB);
else
aItPB.Next();
}
}
// 2. from Face Info and section curves
BOPCol_MapOfInteger aMPassed;
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
Standard_Integer aNbFF = aFFs.Extent(), j;
for (i = 0; i < aNbFF; ++i) {
BOPDS_InterfFF& aFF = aFFs(i);
Standard_Integer nF1, nF2;
aFF.Indices(nF1, nF2);
//
// rebuild pave block maps of face info
for (j = 0; j < 2; j++) {
Standard_Integer nF = (j == 0 ? nF1 : nF2);
if (!aMPassed.Add(nF))
continue;
BOPDS_FaceInfo& aFI = myDS->ChangeFaceInfo(nF);
BOPDS_IndexedMapOfPaveBlock* aIMPB[] = { &aFI.ChangePaveBlocksIn(),
&aFI.ChangePaveBlocksOn(), &aFI.ChangePaveBlocksSc() };
for (Standard_Integer k = 0; k < 3; k++) {
Standard_Integer aNbPB = aIMPB[k]->Extent(), m;
for (m = 1; m <= aNbPB; ++m) {
const Handle(BOPDS_PaveBlock)& aPB = aIMPB[k]->FindKey(m);
if (theEdges.Contains(aPB->Edge()))
break;
}
if (m <= aNbPB) {
BOPDS_IndexedMapOfPaveBlock aMPBCopy = *aIMPB[k];
aIMPB[k]->Clear();
for (m = 1; m <= aNbPB; ++m) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBCopy(m);
if (!theEdges.Contains(aPB->Edge()))
aIMPB[k]->Add(aPB);
}
}
}
}
// remove from Section pave blocks
BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves();
Standard_Integer aNbC = aVNC.Extent();
for (j = 0; j < aNbC; ++j) {
BOPDS_Curve& aNC = aVNC(j);
BOPDS_ListOfPaveBlock& aLPB = aNC.ChangePaveBlocks();
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPB);
while (aItPB.More()) {
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
if (theEdges.Contains(aPB->Edge()))
aLPB.Remove(aItPB);
else
aItPB.Next();
}
}
}
}
//=======================================================================
//function : ToleranceFF
//purpose : Computes the TolFF according to the tolerance value and
@ -2264,3 +2381,201 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
aTolFF = Max(aTolFF, 5.e-6);
}
}
//=======================================================================
//function : UpdateBlocksWithSharedVertices
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::UpdateBlocksWithSharedVertices()
{
if (!myNonDestructive) {
return;
}
//
myErrorStatus=0;
//
Standard_Integer aNbFF;
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aNbFF=aFFs.Extent();
if (!aNbFF) {
return;
}
//
Standard_Boolean bOnCurve, bHasShapeSD;
Standard_Integer i, nF1, nF2, aNbC, j, nV, nVSD;
Standard_Real aTolR3D, aTolV;
BOPCol_MapOfInteger aMF;
//
for (i=0; i<aNbFF; ++i) {
BOPDS_InterfFF& aFF=aFFs(i);
//
BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
aNbC=aVC.Extent();
if (!aNbC) {
continue;
}
//
aFF.Indices(nF1, nF2);
aTolR3D=aFF.TolR3D();
//
if (aMF.Add(nF1)) {
myDS->UpdateFaceInfoOn(nF1);
}
if (aMF.Add(nF2)) {
myDS->UpdateFaceInfoOn(nF2);
}
//
// Collect old vertices that are shared for nF1, nF2 ->aMI;
BOPCol_MapOfInteger aMI;
BOPCol_MapIteratorOfMapOfInteger aItMI;
//
BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
//
const BOPCol_MapOfInteger& aMVOn1=aFI1.VerticesOn();
const BOPCol_MapOfInteger& aMVIn1=aFI1.VerticesIn();
const BOPCol_MapOfInteger& aMVOn2=aFI2.VerticesOn();
const BOPCol_MapOfInteger& aMVIn2=aFI2.VerticesIn();
//
for (j=0; j<2; ++j) {
const BOPCol_MapOfInteger& aMV1=(!j) ? aMVOn1 : aMVIn1;
aItMI.Initialize(aMV1);
for (; aItMI.More(); aItMI.Next()) {
nV=aItMI.Value();
if (myDS->IsNewShape(nV)) {
continue;
}
if (aMVOn2.Contains(nV) || aMVIn2.Contains(nV)) {
aMI.Add(nV);
}
}
}
//
// Try to put vertices aMI on curves
for (j=0; j<aNbC; ++j) {
BOPDS_Curve& aNC=aVC.ChangeValue(j);
//const IntTools_Curve& aIC=aNC.Curve();
//
aItMI.Initialize(aMI);
for (; aItMI.More(); aItMI.Next()) {
nV=aItMI.Value();
//
bHasShapeSD=myDS->HasShapeSD(nV, nVSD);
if (bHasShapeSD) {
continue;
}
//
bOnCurve=EstimatePaveOnCurve(nV, aNC, aTolR3D);
if (!bOnCurve) {
continue;
}
//
const TopoDS_Vertex& aV=*((TopoDS_Vertex *)&myDS->Shape(nV));
aTolV=BRep_Tool::Tolerance(aV);
//
UpdateVertex(nV, aTolV);
}
}//for (j=0; j<aNbC; ++j) {
}//for (i=0; i<aNbFF; ++i) {
//
UpdateCommonBlocksWithSDVertices();
}
//=======================================================================
//function : EstimatePaveOnCurve
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_PaveFiller::EstimatePaveOnCurve
(const Standard_Integer nV,
const BOPDS_Curve& aNC,
const Standard_Real aTolR3D)
{
Standard_Boolean bIsVertexOnLine;
Standard_Real aT;
//
const TopoDS_Vertex& aV=*((TopoDS_Vertex *)&myDS->Shape(nV));
const IntTools_Curve& aIC=aNC.Curve();
//
bIsVertexOnLine=myContext->IsVertexOnLine(aV, aIC, aTolR3D, aT);
return bIsVertexOnLine;
}
//=======================================================================
//function : CorrectToleranceOfSE
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::CorrectToleranceOfSE()
{
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
NCollection_IndexedDataMap<Standard_Integer,BOPDS_ListOfPaveBlock> aMVIPBs;
//
// iterate on all sections F-F
Standard_Integer aNb = aFFs.Extent(), i;
for (i = 0; i < aNb; ++i) {
const BOPDS_InterfFF& aFF = aFFs(i);
Standard_Real aTolR3D = aFF.TolR3D();
Standard_Real aTolReal = aFF.TolReal();
if (aTolReal < aTolR3D) {
// tolerance of intersection has been increased, so process this intersection
const BOPDS_VectorOfCurve& aVNC = aFF.Curves();
Standard_Integer aNbC = aVNC.Extent(), k;
for (k = 0; k < aNbC; ++k) {
const BOPDS_Curve& aNC = aVNC(k);
const BOPDS_ListOfPaveBlock& aLPB = aNC.PaveBlocks();
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
Standard_Integer nE;
if (!aPB->HasEdge(nE)) {
continue;
}
const TopoDS_Edge& aE = TopoDS::Edge(myDS->Shape(nE));
Standard_Real aTolE = BRep_Tool::Tolerance(aE);
if (aTolReal < aTolE) {
// reduce edge tolerance
reinterpret_cast<BRep_TEdge*>(aE.TShape().operator->())->Tolerance(aTolReal);
}
// fill in the map vertex index - pave blocks
Handle(BOPDS_PaveBlock) aPBR = myDS->RealPaveBlock(aPB);
for (Standard_Integer j=0; j < 2; j++) {
Standard_Integer nV = (j == 0 ? aPBR->Pave1().Index() : aPBR->Pave2().Index());
BOPDS_ListOfPaveBlock *pPBList = aMVIPBs.ChangeSeek(nV);
if (!pPBList) {
pPBList = &aMVIPBs.ChangeFromIndex(aMVIPBs.Add(nV, BOPDS_ListOfPaveBlock()));
}
pPBList->Append(aPBR);
}
}
}
}
}
// try to reduce tolerances of connected vertices
aNb = aMVIPBs.Extent();
for (i = 1; i <= aNb; ++i) {
Standard_Integer nV = aMVIPBs.FindKey(i);
const TopoDS_Vertex& aV = TopoDS::Vertex(myDS->Shape(nV));
gp_Pnt aP = BRep_Tool::Pnt(aV);
//
// compute the maximal distance from the vertex to the adjacent edges
Standard_Real aMaxTol = 0.;
const BOPDS_ListOfPaveBlock& aLPB = aMVIPBs.FindFromIndex(i);
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
Standard_Integer nE = aPB->Edge();
const TopoDS_Edge& aE = TopoDS::Edge(myDS->Shape(nE));
const BOPDS_Pave& aPave = (aPB->Pave1().Index() == nV ? aPB->Pave1() : aPB->Pave2());
BRepAdaptor_Curve aC(aE);
gp_Pnt aPonE = aC.Value(aPave.Parameter());
Standard_Real aDist = aP.Distance(aPonE);
aDist += BRep_Tool::Tolerance(aE);
if (aDist > aMaxTol) {
aMaxTol = aDist;
}
}
Standard_Real aTolV = BRep_Tool::Tolerance(aV);
if (aMaxTol < aTolV) {
reinterpret_cast<BRep_TVertex*>(aV.TShape().operator->())->Tolerance(aMaxTol);
}
}
}

79
src/BOPAlgo/BOPAlgo_PaveFiller_7.cxx
View File

@ -17,6 +17,7 @@
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPAlgo_Tools.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
@ -45,10 +46,14 @@
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Surface.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_Tools.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
@ -74,6 +79,7 @@ class BOPAlgo_SplitEdge : public BOPAlgo_Algo {
BOPAlgo_Algo() {
myT1=0.;
myT2=0.;
myTol = 0.;
}
//
virtual ~BOPAlgo_SplitEdge() {
@ -116,13 +122,27 @@ class BOPAlgo_SplitEdge : public BOPAlgo_Algo {
return myBox;
}
//
Standard_Real Tolerance() const {
return myTol;
}
//
void SetDS(const BOPDS_PDS theDS) {
myDS = theDS;
}
//
void SetContext(const Handle(IntTools_Context)& aContext) {
myContext = aContext;
}
//
virtual void Perform () {
BOPAlgo_Algo::UserBreak();
myTol = BOPAlgo_Tools::ComputeToleranceOfCB(myCB, myDS, myContext);
BOPTools_AlgoTools::MakeSplitEdge(myE,
myV1, myT1,
myV2, myT2,
myESp);
BRepBndLib::Add(myESp, myBox);
BRepBndLib::Add(myESp, myBox);
myBox.SetGap(myBox.GetGap() + Precision::Confusion());
}
//
protected:
@ -138,19 +158,26 @@ class BOPAlgo_SplitEdge : public BOPAlgo_Algo {
// <-
TopoDS_Edge myESp;
Bnd_Box myBox;
Standard_Real myTol;
//
BOPDS_PDS myDS;
Handle(IntTools_Context) myContext;
};
//
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_SplitEdge> BOPAlgo_VectorOfSplitEdge;
//
typedef BOPCol_Functor
typedef BOPCol_ContextFunctor
<BOPAlgo_SplitEdge,
BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeFunctor;
BOPAlgo_VectorOfSplitEdge,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_SplitEdgeFunctor;
//
typedef BOPCol_Cnt
typedef BOPCol_ContextCnt
<BOPAlgo_SplitEdgeFunctor,
BOPAlgo_VectorOfSplitEdge> BOPAlgo_SplitEdgeCnt;
BOPAlgo_VectorOfSplitEdge,
Handle(IntTools_Context)> BOPAlgo_SplitEdgeCnt;
//
//=======================================================================
//class : BOPAlgo_MPC
@ -342,13 +369,17 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
Standard_Boolean bCB, bV1, bV2;
Standard_Integer i, nE, nV1, nV2, nSp, aNbPB, aNbVBSE, k;
Standard_Real aT1, aT2;
BOPDS_ListIteratorOfListOfPaveBlock aItPB, aItPBCB;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
Handle(BOPDS_PaveBlock) aPB;
BOPDS_MapOfPaveBlock aMPB(100);
TopoDS_Vertex aV1, aV2;
TopoDS_Edge aE;
BOPAlgo_VectorOfSplitEdge aVBSE;
//
UpdateCommonBlocksWithSDVertices();
//
aNbPBP=aPBP.Extent();
//
for (i=0; i<aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
@ -359,17 +390,31 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
aPB->Indices(nV1, nV2);
bV1=myDS->IsNewShape(nV1);
bV2=myDS->IsNewShape(nV2);
bCB=myDS->IsCommonBlock(aPB);
//
if (!(bV1 || bV2)) {
nE=aPB->OriginalEdge();
aPB->SetEdge(nE);
continue;
if (!(bV1 || bV2)) { // no new vertices here
if (!myNonDestructive || (myNonDestructive && !bCB)) {
nE = aPB->OriginalEdge();
aPB->SetEdge(nE);
if (!myNonDestructive && bCB) {
const Handle(BOPDS_CommonBlock)& aCB = myDS->CommonBlock(aPB);
Standard_Real aTol = BOPAlgo_Tools::ComputeToleranceOfCB(aCB, myDS, myContext);
myDS->UpdateEdgeTolerance(nE, aTol);
}
continue;
}
}
}
//
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
aPB=aItPB.Value();
nE=aPB->OriginalEdge();
const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
if (aSIE.HasFlag()){
continue;
}
//
const Handle(BOPDS_CommonBlock)& aCB=myDS->CommonBlock(aPB);
bCB=!aCB.IsNull();
if (bCB) {
@ -398,6 +443,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
if (bCB) {
aBSE.SetCommonBlock(aCB);
}
aBSE.SetDS(myDS);
aBSE.SetProgressIndicator(myProgressIndicator);
}
} // for (; aItPB.More(); aItPB.Next()) {
@ -405,7 +451,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
//
aNbVBSE=aVBSE.Extent();
//======================================================
BOPAlgo_SplitEdgeCnt::Perform(myRunParallel, aVBSE);
BOPAlgo_SplitEdgeCnt::Perform(myRunParallel, aVBSE, myContext);
//======================================================
//
BOPDS_ShapeInfo aSI;
@ -427,6 +473,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
nSp=myDS->Append(aSI);
//
if (!aCBk.IsNull()) {
myDS->UpdateEdgeTolerance(nSp, aBSE.Tolerance());
aCBk->SetEdge(nSp);
}
else {
@ -434,6 +481,7 @@ void BOPAlgo_PaveFiller::MakeSplitEdges()
}
}
}
//=======================================================================
// function: SplitEdge
// purpose:
@ -466,6 +514,7 @@ Standard_Integer BOPAlgo_PaveFiller::SplitEdge(const Standard_Integer nE,
//
Bnd_Box& aBox=aSI.ChangeBox();
BRepBndLib::Add(aSp, aBox);
aBox.SetGap(aBox.GetGap() + Precision::Confusion());
//
nSp=myDS->Append(aSI);
return nSp;
@ -659,6 +708,10 @@ void BOPAlgo_PaveFiller::RefineFaceInfoOn()
if (!myDS->IsCommonBlock(aPB)) {
// the PB seems to be untouced
aLPB.Clear();
Standard_Integer nE = aPB->OriginalEdge();
if (nE >= 0) {
myDS->ChangeShapeInfo(nE).SetReference(-1);
}
continue;
}
}//if (!(bV1 || bV2)) {
@ -715,6 +768,10 @@ void UpdateVertices(const TopoDS_Edge& aE,
//=======================================================================
void BOPAlgo_PaveFiller::Prepare()
{
if (myNonDestructive) {
// do not allow storing pcurves in original edges if non-destructive mode is on
return;
}
TopAbs_ShapeEnum aType[] = {
TopAbs_VERTEX,
TopAbs_EDGE,

21
src/BOPAlgo/BOPAlgo_PaveFiller_8.cxx
View File

@ -88,18 +88,17 @@ void BOPAlgo_PaveFiller::ProcessDE()
// 1. Find PaveBlocks that are go through nV for nF
FindPaveBlocks(nV, nF, aLPBOut);
aNbPB=aLPBOut.Extent();
if (!aNbPB) {
continue;
if (aNbPB) {
//
// 2.
BOPDS_ListOfPaveBlock& aLPBD = myDS->ChangePaveBlocks(nE);
aPBD = aLPBD.First();
//
FillPaves(nV, nE, nF, aLPBOut, aPBD);
//
myDS->UpdatePaveBlock(aPBD);
}
//
// 2.
BOPDS_ListOfPaveBlock& aLPBD=myDS->ChangePaveBlocks(nE);
aPBD=aLPBD.First();
//
FillPaves(nV, nE, nF, aLPBOut, aPBD);
//
myDS->UpdatePaveBlock(aPBD);
//
MakeSplitEdge(nE, nF);
//
aLPBOut.Clear();
@ -330,8 +329,6 @@ void BOPAlgo_PaveFiller::ProcessDE()
aPBD->AppendExtPave1(aPave);
}
}//for (; aItLPB.More(); aItLPB.Next()) {
//
myDS->UpdatePaveBlock(aPBD);
}
//=======================================================================
// function: MakeSplitEdge1

9
src/BOPAlgo/BOPAlgo_PaveFiller_9.cxx
View File

@ -108,13 +108,12 @@ void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
}
//
Standard_Boolean bJustAdd;
Standard_Integer i, iEnd, nS[2], nE, nV1, nV2, aNbVSD, k, iWrn;
Standard_Integer i, nS[2], nE, nV1, nV2, aNbVSD, k, iWrn;
Standard_Real aT1, aT2, aTS1, aTS2;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPCol_MapOfInteger aMI;
BOPAlgo_VectorOfShrunkRange aVSD;
//
iEnd=(aType2==TopAbs_EDGE) ? 2 : 1;
TopAbs_ShapeEnum aType[2] = { aType1, aType2 };
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nS[0], nS[1], bJustAdd);
@ -122,9 +121,9 @@ void BOPAlgo_PaveFiller::FillShrunkData(const TopAbs_ShapeEnum aType1,
continue;
}
//
for (i=0; i<iEnd; ++i) {
for (i=0; i < 2; ++i) {
nE=nS[i];
if (!aMI.Add(nE)) {
if (aType[i] != TopAbs_EDGE || !aMI.Add(nE)) {
continue;
}
//

166
src/BOPAlgo/BOPAlgo_Tools.cxx
View File

@ -21,14 +21,18 @@
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <IntTools_Context.hxx>
#include <BRep_Tool.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
//=======================================================================
//function : MakeBlocksCnx
//purpose :
//=======================================================================
void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
const Handle(NCollection_BaseAllocator)& aAllocator)
void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
Standard_Integer aNbV, nV, aNbVS, nVP, nVx, aNbVP, aNbEC, k, i, j;
BOPCol_ListIteratorOfListOfInteger aItLI;
@ -107,10 +111,10 @@
//function : FillMap
//purpose :
//=======================================================================
void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
const Standard_Integer n2,
BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
const Handle(NCollection_BaseAllocator)& aAllocator)
void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
const Standard_Integer n2,
BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
if (aMILI.Contains(n1)) {
BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n1);
@ -135,10 +139,10 @@
//function : FillMap
//purpose :
//=======================================================================
void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
const Handle(BOPDS_PaveBlock)& aPB2,
BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
const Handle(NCollection_BaseAllocator)& aAllocator)
void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
const Handle(BOPDS_PaveBlock)& aPB2,
BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
if (aMPBLPB.Contains(aPB1)) {
BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB1);
@ -163,10 +167,10 @@
//function : FillMap
//purpose :
//=======================================================================
void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
const Standard_Integer nF,
BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
const Handle(NCollection_BaseAllocator)& aAllocator)
void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
const Standard_Integer nF,
BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
if (aMPBLI.Contains(aPB)) {
BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
@ -182,9 +186,9 @@
//function : MakeBlocks
//purpose :
//=======================================================================
void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
const Handle(NCollection_BaseAllocator)& aAllocator)
void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
const Handle(NCollection_BaseAllocator)& aAllocator)
{
Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
BOPDS_ListIteratorOfListOfPaveBlock aItLI;
@ -263,9 +267,9 @@
//function : PerformCommonBlocks
//purpose :
//=======================================================================
void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
const Handle(NCollection_BaseAllocator)& aAllocator,
BOPDS_PDS& pDS)
void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
const Handle(NCollection_BaseAllocator)& aAllocator,
BOPDS_PDS& pDS)
{
Standard_Integer aNbCB;
//
@ -306,9 +310,9 @@
//function : PerformCommonBlocks
//purpose :
//=======================================================================
void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
const Handle(NCollection_BaseAllocator)& ,//aAllocator
BOPDS_PDS& pDS)
void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
const Handle(NCollection_BaseAllocator)& ,//aAllocator
BOPDS_PDS& pDS)
{
Standard_Integer nF, i, aNb;
BOPCol_ListIteratorOfListOfInteger aItLI;
@ -327,11 +331,123 @@
}
//
const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
BOPCol_ListOfInteger aNewFaces;
const BOPCol_ListOfInteger& anOldFaces = aCB->Faces();
aItLI.Initialize(aLI);
for (; aItLI.More(); aItLI.Next()) {
nF=aItLI.Value();
aCB->AddFace(nF);
// the both lists aLI and anOldFaces are expected to be short,
// so we can allow to run nested loop here
BOPCol_ListIteratorOfListOfInteger it(anOldFaces);
for (; it.More(); it.Next()) {
if (it.Value() == nF)
break;
}
if (!it.More()) {
aNewFaces.Append(nF);
}
}
aCB->AppendFaces(aNewFaces);
pDS->SetCommonBlock(aPB, aCB);
}
}
//=======================================================================
//function : ComputeToleranceOfCB
//purpose :
//=======================================================================
Standard_Real BOPAlgo_Tools::ComputeToleranceOfCB
(const Handle(BOPDS_CommonBlock)& theCB,
const BOPDS_PDS theDS,
const Handle(IntTools_Context)& theContext)
{
Standard_Real aTolMax = 0.;
if (theCB.IsNull()) {
return aTolMax;
}
//
const Handle(BOPDS_PaveBlock)& aPBR = theCB->PaveBlock1();
Standard_Integer nE = aPBR->OriginalEdge();
const TopoDS_Edge& aEOr = *(TopoDS_Edge*)&theDS->Shape(nE);
aTolMax = BRep_Tool::Tolerance(aEOr);
//
const BOPDS_ListOfPaveBlock& aLPB = theCB->PaveBlocks();
const BOPCol_ListOfInteger& aLFI = theCB->Faces();
//
if ((aLPB.Extent() < 2) && aLFI.IsEmpty()) {
return aTolMax;
}
//
const Standard_Integer aNbPnt = 11;
Standard_Real aTol, aT, aT1, aT2, aDt;
gp_Pnt aP;
//
const Handle(Geom_Curve)& aC3D = BRep_Tool::Curve(aEOr, aT1, aT2);
//
aPBR->Range(aT1, aT2);
aDt = (aT2 - aT1) / (aNbPnt + 1);
//
// compute max tolerance for common blocks on edges
if (aLPB.Extent() > 1) {
// compute max distance between edges
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
GeomAPI_ProjectPointOnCurve aProjPC;
//
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
if (aPB == aPBR) {
continue;
}
//
nE = aPB->OriginalEdge();
const TopoDS_Edge& aE = *(TopoDS_Edge*)&theDS->Shape(nE);
aTol = BRep_Tool::Tolerance(aE);
//
aProjPC = theContext->ProjPC(aE);
//
aT = aT1;
for (Standard_Integer i=1; i <= aNbPnt; i++) {
aT += aDt;
aC3D->D0(aT, aP);
aProjPC.Perform(aP);
if (aProjPC.NbPoints()) {
Standard_Real aTolNew = aTol + aProjPC.LowerDistance();
if (aTolNew > aTolMax) {
aTolMax = aTolNew;
}
}
}
}
}
//
// compute max tolerance for common blocks on faces
if (aLFI.Extent()) {
Standard_Integer nF;
GeomAPI_ProjectPointOnSurf aProjPS;
BOPCol_ListIteratorOfListOfInteger aItLI;
//
aItLI.Initialize(aLFI);
for (; aItLI.More(); aItLI.Next()) {
nF = aItLI.Value();
const TopoDS_Face& aF = *(TopoDS_Face*)&theDS->Shape(nF);
aTol = BRep_Tool::Tolerance(aF);
//
aProjPS = theContext->ProjPS(aF);
//
aT = aT1;
for (Standard_Integer i=1; i <= aNbPnt; i++) {
aT += aDt;
aC3D->D0(aT, aP);
aProjPS.Perform(aP);
if (aProjPS.NbPoints()) {
Standard_Real aTolNew = aTol + aProjPS.LowerDistance();
if (aTolNew > aTolMax) {
aTolMax = aTolNew;
}
}
}
}
}
//
return aTolMax;
}

7
src/BOPAlgo/BOPAlgo_Tools.hxx
View File

@ -29,6 +29,8 @@
#include <BOPDS_IndexedDataMapOfPaveBlockListOfInteger.hxx>
class BOPDS_PaveBlock;
class BOPDS_CommonBlock;
class IntTools_Context;
class BOPAlgo_Tools
{
@ -51,6 +53,11 @@ public:
Standard_EXPORT static void PerformCommonBlocks (const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theMBlocks, const BOPCol_BaseAllocator& theAllocator, BOPDS_PDS& pDS);
Standard_EXPORT static Standard_Real ComputeToleranceOfCB
(const Handle(BOPDS_CommonBlock)& theCB,
const BOPDS_PDS theDS,
const Handle(IntTools_Context)& theContext);
};
#endif // _BOPAlgo_Tools_HeaderFile

2
src/BOPAlgo/BOPAlgo_WireSplitter_1.cxx
View File

@ -160,8 +160,6 @@ void BOPAlgo_WireSplitter::SplitBlock(const TopoDS_Face& myFace,
const BOPCol_ListOfShape& myEdges=aCB.Shapes();
//
// 1.Filling mySmartMap
BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane(myEdges, myFace);
//
aIt.Initialize(myEdges);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Edge& aE=(*(TopoDS_Edge *)&aIt.Value());

3
src/BOPAlgo/FILES
View File

@ -42,6 +42,7 @@ BOPAlgo_PaveFiller_7.cxx
BOPAlgo_PaveFiller_8.cxx
BOPAlgo_PaveFiller_9.cxx
BOPAlgo_PaveFiller_10.cxx
BOPAlgo_PaveFiller_11.cxx
BOPAlgo_PBOP.hxx
BOPAlgo_PBuilder.hxx
BOPAlgo_PPaveFiller.hxx
@ -64,4 +65,4 @@ BOPAlgo_WireSplitter.hxx
BOPAlgo_WireSplitter.lxx
BOPAlgo_WireSplitter_1.cxx
BOPAlgo_CellsBuilder.cxx
BOPAlgo_CellsBuilder.hxx
BOPAlgo_CellsBuilder.hxx

10
src/BOPDS/BOPDS_CommonBlock.cxx
View File

@ -72,11 +72,19 @@ IMPLEMENT_STANDARD_RTTIEXT(BOPDS_CommonBlock,MMgt_TShared)
// function: AddFaces
// purpose:
//=======================================================================
void BOPDS_CommonBlock::AddFaces(const BOPCol_ListOfInteger& aLF)
void BOPDS_CommonBlock::SetFaces(const BOPCol_ListOfInteger& aLF)
{
myFaces=aLF;
}
//=======================================================================
// function: AppendFaces
// purpose:
//=======================================================================
void BOPDS_CommonBlock::AppendFaces(BOPCol_ListOfInteger& aLF)
{
myFaces.Append(aLF);
}
//=======================================================================
// function: Faces
// purpose:
//=======================================================================

13
src/BOPDS/BOPDS_CommonBlock.hxx
View File

@ -73,11 +73,16 @@ public:
//! Modifier
//! Adds the list of indices of faces <aLF>
//! to the list of indices of faces
//! Sets the list of indices of faces <aLF>
//! of the common block
Standard_EXPORT void AddFaces (const BOPCol_ListOfInteger& aLF);
Standard_EXPORT void SetFaces (const BOPCol_ListOfInteger& aLF);
//! Modifier
//! Appends the list of indices of faces <aLF>
//! to the list of indices of faces
//! of the common block (the input list is emptied)
Standard_EXPORT void AppendFaces(BOPCol_ListOfInteger& aLF);
//! Selector
//! Returns the list of pave blocks

32
src/BOPDS/BOPDS_CoupleOfPaveBlocks.hxx
View File

@ -32,10 +32,11 @@ class BOPDS_CoupleOfPaveBlocks {
/**
* Constructor
*/
BOPDS_CoupleOfPaveBlocks() {
myIndex=-1;
myIndexInterf=-1;
}
BOPDS_CoupleOfPaveBlocks() :
myIndexInterf(-1),
myIndex(-1),
myTolerance(0)
{}
//
/**
* Constructor
@ -45,9 +46,11 @@ class BOPDS_CoupleOfPaveBlocks {
* secondt pave block
*/
BOPDS_CoupleOfPaveBlocks(const Handle(BOPDS_PaveBlock)& thePB1,
const Handle(BOPDS_PaveBlock)& thePB2) {
myIndex=-1;
myIndexInterf=-1;
const Handle(BOPDS_PaveBlock)& thePB2) :
myIndexInterf(-1),
myIndex(-1),
myTolerance(0)
{
SetPaveBlocks(thePB1, thePB2);
}
//
@ -153,11 +156,26 @@ class BOPDS_CoupleOfPaveBlocks {
const Handle(BOPDS_PaveBlock)& PaveBlock2()const {
return myPB[1];
}
/**
* Sets the tolerance associated with this couple
*/
void SetTolerance(const Standard_Real theTol) {
myTolerance = theTol;
}
//
/**
* Returns the tolerance associated with this couple
*/
Standard_Real Tolerance()const {
return myTolerance;
}
protected:
Standard_Integer myIndexInterf;
Standard_Integer myIndex;
Handle(BOPDS_PaveBlock) myPB[2];
Standard_Real myTolerance;
};
//
#endif

234
src/BOPDS/BOPDS_DS.cxx
View File

@ -48,25 +48,16 @@
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <algorithm>
//
//
//
//
//
//
//
//
static
inline void ResetShape(const TopoDS_Shape& aS);
static
inline void ResetShapes(const TopoDS_Shape& aS);
static
void TotalShapes(const TopoDS_Shape& aS,
Standard_Integer& aNbS);
Standard_Integer& aNbS,
BOPCol_MapOfShape& aMS);
static
Standard_Real ComputeParameter(const TopoDS_Vertex& aV,
@ -97,6 +88,7 @@ BOPDS_DS::BOPDS_DS()
myMapPBCB(100, myAllocator),
myFaceInfoPool(0, myAllocator),
myShapesSD(100, myAllocator),
myMapVE(100, myAllocator),
myInterfTB(100, myAllocator),
myInterfVV(0, myAllocator),
myInterfVE(0, myAllocator),
@ -129,6 +121,7 @@ BOPDS_DS::BOPDS_DS(const Handle(NCollection_BaseAllocator)& theAllocator)
myMapPBCB(100, myAllocator),
myFaceInfoPool(0, myAllocator),
myShapesSD(100, myAllocator),
myMapVE(100, myAllocator),
myInterfTB(100, myAllocator),
myInterfVV(0, myAllocator),
myInterfVE(0, myAllocator),
@ -171,6 +164,7 @@ void BOPDS_DS::Clear()
myPaveBlocksPool.Clear();
myFaceInfoPool.Clear();
myShapesSD.Clear();
myMapVE.Clear();
myMapPBCB.Clear();
myInterfTB.Clear();
myInterfVV.Clear();
@ -338,7 +332,6 @@ Standard_Integer BOPDS_DS::Index(const TopoDS_Shape& theS)const
}
return iRet;
}
//=======================================================================
//function : Init
//purpose :
@ -347,13 +340,14 @@ void BOPDS_DS::Init()
{
Standard_Integer i1, i2, j, aI, aNb, aNbS, aNbE, aNbSx;
Standard_Integer n1, n2, n3, nV, nW, nE, aNbF;
Standard_Real aTol, aFuzz;
Standard_Real aTol, aFuzz, aTolAdd;
TopAbs_ShapeEnum aTS;
TopoDS_Iterator aItS;
BOPCol_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
BOPCol_ListIteratorOfListOfShape aIt;
BOPDS_IndexRange aR;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_MapOfShape aMS;
//
// 1 Append Source Shapes
aNb=myArguments.Extent();
@ -363,21 +357,17 @@ void BOPDS_DS::Init()
//
myRanges.SetIncrement(aNb);
//
aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
ResetShapes(aSx);
}
//
aNbS=0;
aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
//
aNbSx=0;
TotalShapes(aSx, aNbSx);
TotalShapes(aSx, aNbSx, aMS);
//
aNbS=aNbS+aNbSx;
}
aMS.Clear();
//
myLines.SetIncrement(2*aNbS);
//-----------------------------------------------------scope_1 f
@ -406,7 +396,8 @@ void BOPDS_DS::Init()
}
//
aFuzz = myFuzzyValue / 2.;
myNbSourceShapes=NbShapes();
aTolAdd = Precision::Confusion();
myNbSourceShapes = NbShapes();
//
// 2 Bounding Boxes
//
@ -415,7 +406,6 @@ void BOPDS_DS::Init()
BOPDS_ShapeInfo& aSI=ChangeShapeInfo(j);
//
const TopoDS_Shape& aS=aSI.Shape();
ResetShape(aS);
//
aTS=aSI.ShapeType();
//
@ -427,12 +417,12 @@ void BOPDS_DS::Init()
const Handle(BRep_TVertex)& TV =
*((Handle(BRep_TVertex)*)&aV.TShape());
aTol = TV->Tolerance();
//
// TODO: non-destructive
myToleranceMap.Bind(j, aTol);
aTol += aFuzz;
TV->Tolerance(aTol);
//
aBox.SetGap(aTol);
aBox.SetGap(aTol + aTolAdd);
aBox.Add(aP);
}
}
@ -449,7 +439,7 @@ void BOPDS_DS::Init()
const Handle(BRep_TEdge)& TE =
*((Handle(BRep_TEdge)*)&aE.TShape());
aTol = TE->Tolerance();
//
// TODO: non-destructive
myToleranceMap.Bind(j, aTol);
aTol += aFuzz;
TE->Tolerance(aTol);
@ -514,6 +504,7 @@ void BOPDS_DS::Init()
Bnd_Box& aBx=aSIV.ChangeBox();
aBox.Add(aBx);
}
aBox.SetGap(aBox.GetGap() + aTolAdd);
++aNbE;
}
}
@ -533,7 +524,7 @@ void BOPDS_DS::Init()
const Handle(BRep_TFace)& TF =
*((Handle(BRep_TFace)*)&aF.TShape());
aTol = TF->Tolerance();
//
// TODO: non-destructive
myToleranceMap.Bind(j, aTol);
aTol += aFuzz;
TF->Tolerance(aTol);
@ -589,6 +580,7 @@ void BOPDS_DS::Init()
aLW.Append(nV);
}
aMI.Clear();
aBox.SetGap(aBox.GetGap() + aTolAdd);
++aNbF;
}//if (aTS==TopAbs_FACE) {
}//for (j=0; j<myNbSourceShapes; ++j) {
@ -647,6 +639,54 @@ void BOPDS_DS::Init()
}//for (j=0; j<myNbSourceShapes; ++j) {
//
aMI.Clear();
//-----------------------------------------------------
//
for (nE=0; nE<myNbSourceShapes; ++nE) {
BOPDS_ShapeInfo& aSI=ChangeShapeInfo(nE);
if (aSI.ShapeType()!=TopAbs_EDGE) {
continue;
}
//
const BOPCol_ListOfInteger& aLV=aSI.SubShapes();
aIt1.Initialize(aLV);
for (; aIt1.More(); aIt1.Next()) {
nV=aIt1.Value();
if (myMapVE.IsBound(nV)) {
BOPCol_ListOfInteger& aLE=myMapVE.ChangeFind(nV);
aLE.Append(nE);
}
else {
BOPCol_ListOfInteger aLE(myAllocator);
//
aLE.Append(nE);
myMapVE.Bind(nV, aLE);
}
}
}
//
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItDMILI;
aItDMILI.Initialize(myMapVE);
for(; aItDMILI.More(); aItDMILI.Next()) {
BOPCol_MapOfInteger aMFence;
BOPCol_ListOfInteger aLEx;
//
nV=aItDMILI.Key();
BOPCol_ListOfInteger& aLE=aItDMILI.ChangeValue();
aIt1.Initialize(aLE);
for (; aIt1.More(); aIt1.Next()) {
nE=aIt1.Value();
if(aMFence.Add(nE)) {
aLEx.Append(nE);
}
}
//
aLE.Clear();
aIt1.Initialize(aLEx);
for (; aIt1.More(); aIt1.Next()) {
nE=aIt1.Value();
aLE.Append(nE);
}
}
//-----------------------------------------------------scope_1 t
// 3 myPaveBlocksPool
// 4. myFaceInfoPool
@ -822,6 +862,7 @@ const BOPDS_ListOfPaveBlock& BOPDS_DS::PaveBlocks
}
return sLPB;
}
//=======================================================================
//function : ChangePaveBlocks
//purpose :
@ -993,12 +1034,7 @@ void BOPDS_DS::UpdatePaveBlock(const Handle(BOPDS_PaveBlock)& thePB)
aPB=aItPB.ChangeValue();
if (aPB==thePB) {
aPB->Update(aLPBN);
//
aItPBN.Initialize(aLPBN);
for (; aItPBN.More(); aItPBN.Next()) {
Handle(BOPDS_PaveBlock)& aPBN=aItPBN.ChangeValue();
aLPB.Append(aPBN);
}
aLPB.Append(aLPBN);
aLPB.Remove(aItPB);
break;
}
@ -1113,7 +1149,7 @@ void BOPDS_DS::UpdateCommonBlock(const Handle(BOPDS_CommonBlock)& theCB)
//
aCBx=new BOPDS_CommonBlock;
aCBx->AddPaveBlocks(aLPBxN);
aCBx->AddFaces(aLF);
aCBx->SetFaces(aLF);
//
aItPB.Initialize(aLPBxN);
for (; aItPB.More(); aItPB.Next()) {
@ -1375,6 +1411,9 @@ void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
BOPDS_InterfVF& aVF=aVFs(i);
if(aVF.Contains(theF)) {
nV=aVF.OppositeIndex(theF);
if (HasShapeSD(nV, nVSD)) {
nV=nVSD;
}
theMI.Add(nV);
}
}
@ -1808,7 +1847,6 @@ Standard_Boolean BOPDS_DS::IsSubShape
return bRet;
}
//=======================================================================
// function: Paves
// purpose:
@ -1854,7 +1892,6 @@ void BOPDS_DS::Paves(const Standard_Integer theEdge,
theLP.Append(pPaves(i));
}
}
//=======================================================================
// function: UpdateTolerance
// purpose:
@ -1872,6 +1909,7 @@ void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
BOPDS_ShapeInfo& aSIE=ChangeShapeInfo(nE);
Bnd_Box& aBoxE=aSIE.ChangeBox();
BRepBndLib::Add(aE, aBoxE);
aBoxE.SetGap(aBoxE.GetGap() + Precision::Confusion());
//
const BOPCol_ListOfInteger& aLI = aSIE.SubShapes();
aIt.Initialize(aLI);
@ -1884,58 +1922,29 @@ void BOPDS_DS::UpdateEdgeTolerance(const Standard_Integer nE,
BOPDS_ShapeInfo& aSIV = ChangeShapeInfo(nV);
Bnd_Box& aBoxV = aSIV.ChangeBox();
BRepBndLib::Add(aV, aBoxV);
aBoxV.SetGap(aBoxV.GetGap() + Precision::Confusion());
}
}
}
//=======================================================================
//function : TotalShapes
//purpose :
//=======================================================================
void TotalShapes(const TopoDS_Shape& aS,
Standard_Integer& aNbS)
Standard_Integer& aNbS,
BOPCol_MapOfShape& aMS)
{
TopoDS_Shape *pS;
//
pS=(TopoDS_Shape *)&aS;
if (!pS->Checked()) {
if (aMS.Add(aS)) {
TopoDS_Iterator aIt;
//
pS->Checked(1);
++aNbS;
aIt.Initialize(aS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
TotalShapes(aSx, aNbS);
TotalShapes(aSx, aNbS, aMS);
}
}
}
//=======================================================================
//function : ResetShape
//purpose :
//=======================================================================
void ResetShape(const TopoDS_Shape& aS)
{
TopoDS_Shape *pS;
//
pS=(TopoDS_Shape *)&aS;
pS->Checked(0);
}
//=======================================================================
//function : ResetShape
//purpose :
//=======================================================================
void ResetShapes(const TopoDS_Shape& aS)
{
TopoDS_Iterator aIt;
//
ResetShape(aS);
aIt.Initialize(aS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
ResetShape(aSx);
}
}
//=======================================================================
//function : ComputeParameter
//purpose :
@ -2283,3 +2292,84 @@ void CollectEdges(const BOPDS_DS& theDS,
}
}
}
//=======================================================================
//function : UpdatePaveBlocksWithSDVertices
//purpose :
//=======================================================================
void BOPDS_DS::UpdatePaveBlocksWithSDVertices()
{
Standard_Integer i, aNbPBP;
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
//
BOPDS_VectorOfListOfPaveBlock& aPBP=myPaveBlocksPool;
//
aNbPBP=aPBP.Size();
for (i = 0; i < aNbPBP; ++i) {
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
//
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
Handle(BOPDS_PaveBlock)& aPB = aItPB.ChangeValue();
UpdatePaveBlockWithSDVertices(aPB);
}// for (; aItPB.More(); aItPB.Next()) {
}// for (i = 0; i < aNbPBP; ++i) {
}
//=======================================================================
//function : UpdatePaveBlockWithSDVertices
//purpose :
//=======================================================================
void BOPDS_DS::UpdatePaveBlockWithSDVertices
(const Handle(BOPDS_PaveBlock)& thePB)
{
Standard_Integer nV1, nV2;
BOPDS_Pave aPave1, aPave2;
//
aPave1 = thePB->Pave1();
aPave2 = thePB->Pave2();
//
nV1 = aPave1.Index();
nV2 = aPave2.Index();
//
if (HasShapeSD(nV1, nV1)) {
aPave1.SetIndex(nV1);
thePB->SetPave1(aPave1);
}
//
if (HasShapeSD(nV2, nV2)) {
aPave2.SetIndex(nV2);
thePB->SetPave2(aPave2);
}
}
//=======================================================================
//function : UpdateCommonBlockWithSDVertices
//purpose :
//=======================================================================
void BOPDS_DS::UpdateCommonBlockWithSDVertices
(const Handle(BOPDS_CommonBlock)& theCB)
{
const BOPDS_ListOfPaveBlock& aLPB = theCB->PaveBlocks();
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPB);
for (; aItPB.More(); aItPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
UpdatePaveBlockWithSDVertices(aPB);
}
}
//=======================================================================
//function : InitPaveBlocksForVertex
//purpose :
//=======================================================================
void BOPDS_DS::InitPaveBlocksForVertex(const Standard_Integer theNV)
{
Standard_Integer nE;
BOPCol_ListIteratorOfListOfInteger aItLE;
//
if (myMapVE.IsBound(theNV)) {
const BOPCol_ListOfInteger& aLE=myMapVE.Find(theNV);
aItLE.Initialize(aLE);
for (; aItLE.More(); aItLE.Next()) {
nE=aItLE.Value();
ChangePaveBlocks(nE);
}
}
}

13
src/BOPDS/BOPDS_DS.hxx
View File

@ -29,6 +29,7 @@
#include <BOPDS_DataMapOfPaveBlockCommonBlock.hxx>
#include <BOPDS_VectorOfFaceInfo.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPDS_MapOfPassKey.hxx>
#include <BOPDS_VectorOfInterfVV.hxx>
#include <BOPDS_VectorOfInterfVE.hxx>
@ -439,7 +440,13 @@ Standard_EXPORT virtual ~BOPDS_DS();
//! Updates tolerance of the sub-shapes of the shape with index <theIndex>.
Standard_EXPORT void UpdateEdgeTolerance (const Standard_Integer theIndex, const Standard_Real theTolerance);
Standard_EXPORT void UpdatePaveBlocksWithSDVertices();
Standard_EXPORT void UpdateCommonBlockWithSDVertices(const Handle(BOPDS_CommonBlock)& theCB);
Standard_EXPORT void InitPaveBlocksForVertex(const Standard_Integer theNV);
//! Sets the extended tolerance
void SetFuzzyValue (const Standard_Real theFuzz);
@ -458,7 +465,8 @@ protected:
//! Initializes the pave blocks for the shape with index theIndex
Standard_EXPORT void InitPaveBlocks (const Standard_Integer theIndex);
Standard_EXPORT void UpdatePaveBlockWithSDVertices(const Handle(BOPDS_PaveBlock)& thePB);
//! Initializes the state of face with index theIndex
Standard_EXPORT void InitFaceInfo (const Standard_Integer theIndex);
@ -483,6 +491,7 @@ protected:
BOPDS_DataMapOfPaveBlockCommonBlock myMapPBCB;
BOPDS_VectorOfFaceInfo myFaceInfoPool;
BOPCol_DataMapOfIntegerInteger myShapesSD;
BOPCol_DataMapOfIntegerListOfInteger myMapVE;
BOPDS_MapOfPassKey myInterfTB;
BOPDS_VectorOfInterfVV myInterfVV;
BOPDS_VectorOfInterfVE myInterfVE;

21
src/BOPDS/BOPDS_Interf.hxx
View File

@ -496,6 +496,7 @@ class BOPDS_InterfFF : public BOPDS_Interf {
myTangentFaces(Standard_False),
myTolR3D(1.e-7),
myTolR2D(1.e-7),
myTolReal(1.e-7),
myCurves(0, myAllocator),
myPoints(0, myAllocator)
{
@ -595,6 +596,25 @@ class BOPDS_InterfFF : public BOPDS_Interf {
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
@ -640,6 +660,7 @@ class BOPDS_InterfFF : public BOPDS_Interf {
Standard_Boolean myTangentFaces;
Standard_Real myTolR3D;
Standard_Real myTolR2D;
Standard_Real myTolReal;
BOPDS_VectorOfCurve myCurves;
BOPDS_VectorOfPoint myPoints;
};

8
src/BOPTest/BOPTest_APICommands.cxx
View File

@ -66,7 +66,7 @@ Standard_Integer bapibop(Draw_Interpretor& di,
}
//
char buf[128];
Standard_Boolean bRunParallel;
Standard_Boolean bRunParallel, bNonDestructive;
Standard_Integer iErr, iOp;
Standard_Real aFuzzyValue;
BRepAlgoAPI_Common aCommon;
@ -115,6 +115,7 @@ Standard_Integer bapibop(Draw_Interpretor& di,
//
bRunParallel=BOPTest_Objects::RunParallel();
aFuzzyValue=BOPTest_Objects::FuzzyValue();
bNonDestructive = BOPTest_Objects::NonDestructive();
//
if (aOp!=BOPAlgo_CUT21) {
pBuilder->SetArguments(aLS);
@ -127,6 +128,7 @@ Standard_Integer bapibop(Draw_Interpretor& di,
//
pBuilder->SetRunParallel(bRunParallel);
pBuilder->SetFuzzyValue(aFuzzyValue);
pBuilder->SetNonDestructive(bNonDestructive);
//
pBuilder->Build();
iErr=pBuilder->ErrorStatus();
@ -159,7 +161,7 @@ Standard_Integer bapibuild(Draw_Interpretor& di,
}
//
char buf[128];
Standard_Boolean bRunParallel;
Standard_Boolean bRunParallel, bNonDestructive;
Standard_Integer iErr;
Standard_Real aFuzzyValue;
BRepAlgoAPI_BuilderAlgo aBuilder;
@ -173,10 +175,12 @@ Standard_Integer bapibuild(Draw_Interpretor& di,
//
bRunParallel=BOPTest_Objects::RunParallel();
aFuzzyValue=BOPTest_Objects::FuzzyValue();
bNonDestructive = BOPTest_Objects::NonDestructive();
//
aBuilder.SetArguments(aLS);
aBuilder.SetRunParallel(bRunParallel);
aBuilder.SetFuzzyValue(aFuzzyValue);
aBuilder.SetNonDestructive(bNonDestructive);
//
aBuilder.Build();
iErr=aBuilder.ErrorStatus();

16
src/BOPTest/BOPTest_BOPCommands.cxx
View File

@ -119,7 +119,7 @@ Standard_Integer bop(Draw_Interpretor& di,
const char** a)
{
char buf[32];
Standard_Boolean bRunParallel;
Standard_Boolean bRunParallel, bNonDestructive;
Standard_Integer iErr;
Standard_Real aTol;
TopoDS_Shape aS1, aS2;
@ -140,6 +140,7 @@ Standard_Integer bop(Draw_Interpretor& di,
//
aTol=BOPTest_Objects::FuzzyValue();
bRunParallel=BOPTest_Objects::RunParallel();
bNonDestructive = BOPTest_Objects::NonDestructive();
//
aLC.Append(aS1);
aLC.Append(aS2);
@ -155,6 +156,7 @@ Standard_Integer bop(Draw_Interpretor& di,
pPF->SetArguments(aLC);
pPF->SetFuzzyValue(aTol);
pPF->SetRunParallel(bRunParallel);
pPF->SetNonDestructive(bNonDestructive);
//
pPF->Perform();
iErr=pPF->ErrorStatus();
@ -395,7 +397,7 @@ Standard_Integer bsection(Draw_Interpretor& di,
}
//
char buf[80];
Standard_Boolean bRunParallel, bApp, bPC1, bPC2;
Standard_Boolean bRunParallel, bNonDestructive, bApp, bPC1, bPC2;
Standard_Integer i, iErr;
Standard_Real aTol;
//
@ -404,6 +406,7 @@ Standard_Integer bsection(Draw_Interpretor& di,
bPC2 = Standard_True;
aTol = BOPTest_Objects::FuzzyValue();
bRunParallel = BOPTest_Objects::RunParallel();
bNonDestructive = BOPTest_Objects::NonDestructive();
//
for (i = 4; i < n; ++i) {
if (!strcmp(a[i], "-n2d")) {
@ -429,6 +432,7 @@ Standard_Integer bsection(Draw_Interpretor& di,
//
aSec.SetFuzzyValue(aTol);
aSec.SetRunParallel(bRunParallel);
aSec.SetNonDestructive(bNonDestructive);
//
aSec.Build();
iErr=aSec.ErrorStatus();
@ -456,7 +460,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
const BOPAlgo_Operation aOp)
{
char buf[32];
Standard_Boolean bRunParallel;
Standard_Boolean bRunParallel, bNonDestructive;
Standard_Integer iErr;
TopoDS_Shape aS1, aS2;
BOPCol_ListOfShape aLC;
@ -479,6 +483,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
//
aTol=BOPTest_Objects::FuzzyValue();
bRunParallel = BOPTest_Objects::RunParallel();
bNonDestructive = BOPTest_Objects::NonDestructive();
//
Handle(NCollection_BaseAllocator)aAL=
NCollection_BaseAllocator::CommonBaseAllocator();
@ -489,6 +494,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
aPF.SetArguments(aLC);
aPF.SetFuzzyValue(aTol);
aPF.SetRunParallel(bRunParallel);
aPF.SetNonDestructive(bNonDestructive);
//
aPF.Perform();
iErr=aPF.ErrorStatus();
@ -724,7 +730,7 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
//
const char* usage = "Type mkvolume without arguments for the usage of the command.\n";
//
Standard_Boolean bToIntersect, bRunParallel, bCompounds;
Standard_Boolean bToIntersect, bRunParallel, bNonDestructive, bCompounds;
Standard_Integer i;
Standard_Real aTol;
TopoDS_Shape aS;
@ -732,6 +738,7 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
//
aTol = BOPTest_Objects::FuzzyValue();
bRunParallel = BOPTest_Objects::RunParallel();
bNonDestructive = BOPTest_Objects::NonDestructive();
//
bToIntersect = Standard_True;
bCompounds = Standard_False;
@ -781,6 +788,7 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
aMV.SetIntersect(bToIntersect);
aMV.SetRunParallel(bRunParallel);
aMV.SetFuzzyValue(aTol);
aMV.SetNonDestructive(bNonDestructive);
//
aMV.Perform();
if (aMV.ErrorStatus()) {

28
src/BOPTest/BOPTest_Objects.cxx
View File

@ -50,7 +50,8 @@ class BOPTest_Session {
//
myBuilder=myBuilderDefault;
myRunParallel=Standard_False;
myFuzzyValue=0.;
myNonDestructive = Standard_False;
myFuzzyValue = 0.;
};
//
// Clear
@ -114,6 +115,14 @@ class BOPTest_Session {
return myFuzzyValue;
};
//
void SetNonDestructive(const Standard_Boolean theFlag) {
myNonDestructive = theFlag;
};
//
Standard_Boolean NonDestructive()const {
return myNonDestructive;
};
//
protected:
//
BOPTest_Session(const BOPTest_Session&);
@ -128,6 +137,7 @@ protected:
BOPCol_ListOfShape myShapes;
BOPCol_ListOfShape myTools;
Standard_Boolean myRunParallel;
Standard_Boolean myNonDestructive;
Standard_Real myFuzzyValue;
};
//
@ -282,6 +292,22 @@ Standard_Real BOPTest_Objects::FuzzyValue()
return GetSession().FuzzyValue();
}
//=======================================================================
//function : SetNonDestructive
//purpose :
//=======================================================================
void BOPTest_Objects::SetNonDestructive(const Standard_Boolean theFlag)
{
GetSession().SetNonDestructive(theFlag);
}
//=======================================================================
//function : NonDestructive
//purpose :
//=======================================================================
Standard_Boolean BOPTest_Objects::NonDestructive()
{
return GetSession().NonDestructive();
}
//=======================================================================
//function : Allocator1
//purpose :
//=======================================================================

4
src/BOPTest/BOPTest_Objects.hxx
View File

@ -71,6 +71,10 @@ public:
Standard_EXPORT static Standard_Real FuzzyValue();
Standard_EXPORT static void SetNonDestructive(const Standard_Boolean theFlag);
Standard_EXPORT static Standard_Boolean NonDestructive();

58
src/BOPTest/BOPTest_OptionCommands.cxx
View File

@ -22,8 +22,8 @@
#include <string.h>
static Standard_Integer boptions (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer brunparallel (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bfuzzyvalue (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bparallelmode(Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bnondestructive(Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bfuzzyvalue(Draw_Interpretor&, Standard_Integer, const char**);
//=======================================================================
//function : OptionCommands
@ -37,13 +37,10 @@ void BOPTest::OptionCommands(Draw_Interpretor& theCommands)
// Chapter's name
const char* g = "BOPTest commands";
// Commands
theCommands.Add("boptions", "use boptions" , __FILE__, boptions, g);
theCommands.Add("boptions", "use boptions, shows current value of BOP options" , __FILE__, boptions, g);
theCommands.Add("brunparallel", "use brunparallel [0/1]" , __FILE__, brunparallel, g);
theCommands.Add("bfuzzyvalue", "use bfuzzyvalue value" , __FILE__, bfuzzyvalue, g);
theCommands.Add("bparallelmode",
"bparallelmode [1/0] : show / set parallel mode for boolean operations",
__FILE__, bparallelmode, g);
theCommands.Add("bnondestructive", "use bnondestructive [0/1]", __FILE__, bnondestructive, g);
theCommands.Add("bfuzzyvalue", "use bfuzzyvalue value", __FILE__, bfuzzyvalue, g);
}
//=======================================================================
//function : boptions
@ -59,14 +56,17 @@ Standard_Integer boptions(Draw_Interpretor& di,
}
//
char buf[128];
Standard_Boolean bRunParallel;
Standard_Boolean bRunParallel, bNonDestructive;
Standard_Real aFuzzyValue;
//
bRunParallel=BOPTest_Objects::RunParallel();
aFuzzyValue=BOPTest_Objects::FuzzyValue();
bNonDestructive = BOPTest_Objects::NonDestructive();
aFuzzyValue = BOPTest_Objects::FuzzyValue();
Sprintf(buf, " RunParallel: %d\n", bRunParallel);
di << buf;
Sprintf(buf, " NonDestructive: %d\n", bNonDestructive);
di << buf;
Sprintf(buf, " FuzzyValue : %lf\n", aFuzzyValue);
di << buf;
//
@ -125,29 +125,29 @@ Standard_Integer brunparallel(Draw_Interpretor& di,
return 0;
}
//=======================================================================
//function : bparallelmode
//function : bnondestructive
//purpose :
//=======================================================================
Standard_Integer bparallelmode(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
Standard_Integer bnondestructive(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
Standard_Boolean bRunParallel;
if (n != 2) {
di << " use bnondestructive [0/1]\n";
return 0;
}
//
if (n == 2) {
bRunParallel=(Standard_Boolean)Draw::Atoi(a[1]);
BOPTest_Objects::SetRunParallel(bRunParallel);
if (bRunParallel) {
di << "Parallel mode for boolean operations has been enabled";
}
else {
di << "Parallel mode for boolean operations has been disabled";
}
}
else {
bRunParallel=BOPTest_Objects::RunParallel();
di << "Parallel mode state for boolean operations: "
<< (bRunParallel? "enabled" : "disabled");
Standard_Integer iX;
Standard_Boolean bNonDestructive;
//
iX = Draw::Atoi(a[1]);
if (iX<0 || iX>1) {
di << " Wrong value.\n";
return 0;
}
//
bNonDestructive = (Standard_Boolean)(iX);
BOPTest_Objects::SetNonDestructive(bNonDestructive);
//
return 0;
}

6
src/BOPTest/BOPTest_PartitionCommands.cxx
View File

@ -66,7 +66,7 @@ Standard_Integer bfillds(Draw_Interpretor& di,
}
//
char buf[32];
Standard_Boolean bRunParallel, bShowTime;
Standard_Boolean bRunParallel, bNonDestructive, bShowTime;
Standard_Integer i, aNbS, iErr;
Standard_Real aTol;
BOPCol_ListIteratorOfListOfShape aIt;
@ -81,7 +81,8 @@ Standard_Integer bfillds(Draw_Interpretor& di,
bShowTime = Standard_False;
//
bRunParallel=BOPTest_Objects::RunParallel();
aTol=BOPTest_Objects::FuzzyValue();
bNonDestructive = BOPTest_Objects::NonDestructive();
aTol = BOPTest_Objects::FuzzyValue();
//
for (i=1; i<n; ++i) {
if (!strcmp(a[i], "-t")) {
@ -107,6 +108,7 @@ Standard_Integer bfillds(Draw_Interpretor& di,
//
aPF.SetArguments(aLC);
aPF.SetRunParallel(bRunParallel);
aPF.SetNonDestructive(bNonDestructive);
aPF.SetFuzzyValue(aTol);
//
OSD_Timer aTimer;

8
src/BOPTools/BOPTools_AlgoTools.cxx
View File

@ -962,7 +962,7 @@ Standard_Boolean BOPTools_AlgoTools::AreFacesSameDomain
}
// 2
aTolF2=BRep_Tool::Tolerance(aF2);
aTol=aTolF1+aTolF2;
aTol = aTolF1 + aTolF2 + Precision::Confusion();
//
iErr = BOPTools_AlgoTools3D::PointInFace(aF1, aP, aP2D,
theContext);
@ -1461,7 +1461,7 @@ Standard_Integer BOPTools_AlgoTools::ComputeVV(const TopoDS_Vertex& aV1,
//
aTolV1=BRep_Tool::Tolerance(aV1);
aTolSum=aTolV1+aTolP2;
aTolSum = aTolV1 + aTolP2 + Precision::Confusion();
aTolSum2=aTolSum*aTolSum;
//
aP1=BRep_Tool::Pnt(aV1);
@ -1484,7 +1484,7 @@ Standard_Integer BOPTools_AlgoTools::ComputeVV(const TopoDS_Vertex& aV1,
//
aTolV1=BRep_Tool::Tolerance(aV1);
aTolV2=BRep_Tool::Tolerance(aV2);
aTolSum=aTolV1+aTolV2;
aTolSum = aTolV1 + aTolV2 + Precision::Confusion();
aTolSum2=aTolSum*aTolSum;
//
aP1=BRep_Tool::Pnt(aV1);
@ -1500,7 +1500,7 @@ Standard_Integer BOPTools_AlgoTools::ComputeVV(const TopoDS_Vertex& aV1,
// function: MakeVertex
// purpose :
//=======================================================================
void BOPTools_AlgoTools::MakeVertex(BOPCol_ListOfShape& aLV,
void BOPTools_AlgoTools::MakeVertex(const BOPCol_ListOfShape& aLV,
TopoDS_Vertex& aVnew)
{
Standard_Integer aNb;

29
src/BOPTools/BOPTools_AlgoTools.hxx
View File

@ -56,7 +56,7 @@ public:
Standard_EXPORT static Standard_Integer ComputeVV (const TopoDS_Vertex& aV1, const TopoDS_Vertex& aV2);
Standard_EXPORT static void MakeVertex (BOPCol_ListOfShape& aLV, TopoDS_Vertex& aV);
Standard_EXPORT static void MakeVertex (const BOPCol_ListOfShape& aLV, TopoDS_Vertex& aV);
Standard_EXPORT static void MakeEdge (const IntTools_Curve& theCurve, const TopoDS_Vertex& theV1, const Standard_Real theT1, const TopoDS_Vertex& theV2, const Standard_Real theT2, const Standard_Real theTolR3D, TopoDS_Edge& theE);
@ -177,18 +177,27 @@ public:
//! accepted for correction. If real value of the tolerance
//! will be greater than <aTolMax>, the correction does not
//! perform.
Standard_EXPORT static void CorrectTolerances (const TopoDS_Shape& theS, const Standard_Real theTolMax = 0.0001, const Standard_Boolean theRunParallel = Standard_False);
Standard_EXPORT static void CorrectTolerances
(const TopoDS_Shape& theS,
const BOPCol_IndexedMapOfShape& theMapToAvoid,
const Standard_Real theTolMax = 0.0001,
const Standard_Boolean theRunParallel = Standard_False);
//! Provides valid values of tolerances for the shape <theS>
//! in terms of BRepCheck_InvalidCurveOnSurface.
Standard_EXPORT static void CorrectCurveOnSurface (const TopoDS_Shape& theS, const Standard_Real theTolMax = 0.0001, const Standard_Boolean theRunParallel = Standard_False);
Standard_EXPORT static void CorrectCurveOnSurface
(const TopoDS_Shape& theS,
const BOPCol_IndexedMapOfShape& theMapToAvoid,
const Standard_Real theTolMax = 0.0001,
const Standard_Boolean theRunParallel = Standard_False);
//! Provides valid values of tolerances for the shape <theS>
//! in terms of BRepCheck_InvalidPointOnCurve.
Standard_EXPORT static void CorrectPointOnCurve (const TopoDS_Shape& theS, const Standard_Real theTolMax = 0.0001, const Standard_Boolean theRunParallel = Standard_False);
Standard_EXPORT static void CorrectPointOnCurve
(const TopoDS_Shape& theS,
const BOPCol_IndexedMapOfShape& theMapToAvoid,
const Standard_Real theTolMax = 0.0001,
const Standard_Boolean theRunParallel = Standard_False);
//! Make a vertex using 3D-point <aP1> and 3D-tolerance value <aTol>
Standard_EXPORT static void MakeNewVertex (const gp_Pnt& aP1, const Standard_Real aTol, TopoDS_Vertex& aNewVertex);
@ -260,8 +269,10 @@ public:
//! Corrects tolerance values of the sub-shapes of the shape <theS> if needed.
Standard_EXPORT static void CorrectShapeTolerances (const TopoDS_Shape& theS, const Standard_Boolean theRunParallel = Standard_False);
Standard_EXPORT static void CorrectShapeTolerances
(const TopoDS_Shape& theS,
const BOPCol_IndexedMapOfShape& theMapToAvoid,
const Standard_Boolean theRunParallel = Standard_False);
//! Retutns dimension of the shape <theS>.
Standard_EXPORT static Standard_Integer Dimension (const TopoDS_Shape& theS);

153
src/BOPTools/BOPTools_AlgoTools_1.cxx
View File

@ -92,11 +92,13 @@
//
static
void CheckEdge (const TopoDS_Edge& E,
const Standard_Real aMaxTol);
const Standard_Real aMaxTol,
const BOPCol_IndexedMapOfShape& aMapToAvoid);
static
void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
const TopoDS_Face& S,
const Standard_Real aMaxTol);
const Standard_Real aMaxTol,
const BOPCol_IndexedMapOfShape& aMapToAvoid);
static
Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
const Adaptor3d_Curve& Other,
@ -105,15 +107,23 @@ static
Standard_Real& aNewTolerance);
static
void CorrectVertexTolerance(const TopoDS_Edge& aE);
void CorrectVertexTolerance(const TopoDS_Edge& aE,
const BOPCol_IndexedMapOfShape& aMapToAvoid);
static
void CorrectWires(const TopoDS_Face& aF);
void CorrectWires(const TopoDS_Face& aF,
const BOPCol_IndexedMapOfShape& aMapToAvoid);
static
void UpdateEdges(const TopoDS_Face& aF);
void UpdateEdges(const TopoDS_Face& aF,
const BOPCol_IndexedMapOfShape& aMapToAvoid);
static
void UpdateShape(const TopoDS_Shape& aS,
const Standard_Real aTol,
const BOPCol_IndexedMapOfShape& aMapToAvoid);
static
Standard_Real IntersectCurves2d(const gp_Pnt& aPV,
@ -131,7 +141,7 @@ static
class BOPTools_CPC {
public:
BOPTools_CPC()
: myMaxTol(1.e-7) {
: myMaxTol(1.e-7), mypMapToAvoid(0L) {
}
//
~BOPTools_CPC() {
@ -153,13 +163,19 @@ class BOPTools_CPC {
return myMaxTol;
}
//
void SetMapToAvoid(const BOPCol_IndexedMapOfShape& aMapToAvoid) {
mypMapToAvoid = &aMapToAvoid;
}
//
void Perform() {
CheckEdge(myEdge, myMaxTol);
Standard_ProgramError_Raise_if(!mypMapToAvoid, "mypMapToAvoid is null");
CheckEdge(myEdge, myMaxTol, *mypMapToAvoid);
}
protected:
Standard_Real myMaxTol;
TopoDS_Edge myEdge;
const BOPCol_IndexedMapOfShape* mypMapToAvoid;
};
//
//=======================================================================
@ -179,7 +195,7 @@ typedef BOPCol_Cnt
//=======================================================================
class BOPTools_CWT {
public:
BOPTools_CWT() {
BOPTools_CWT() : mypMapToAvoid(0L) {
}
//
~BOPTools_CWT() {
@ -189,12 +205,18 @@ class BOPTools_CWT {
myFace=aF;
}
//
void SetMapToAvoid(const BOPCol_IndexedMapOfShape& aMapToAvoid) {
mypMapToAvoid = &aMapToAvoid;
}
//
void Perform() {
CorrectWires(myFace);
Standard_ProgramError_Raise_if(!mypMapToAvoid, "mypMapToAvoid is null");
CorrectWires(myFace, *mypMapToAvoid);
}
//
protected:
TopoDS_Face myFace;
const BOPCol_IndexedMapOfShape* mypMapToAvoid;
};
//=======================================================================
typedef BOPCol_NCVector<BOPTools_CWT> BOPTools_VectorOfCWT;
@ -214,7 +236,7 @@ typedef BOPCol_Cnt
class BOPTools_CDT {
public:
BOPTools_CDT()
: myMaxTol(1.e-7) {
: myMaxTol(1.e-7), mypMapToAvoid(0L) {
}
//
~BOPTools_CDT() {
@ -232,14 +254,20 @@ class BOPTools_CDT {
myMaxTol=aMaxTol;
}
//
void SetMapToAvoid(const BOPCol_IndexedMapOfShape& aMapToAvoid) {
mypMapToAvoid = &aMapToAvoid;
}
//
void Perform() {
CorrectEdgeTolerance (myEdge, myFace, myMaxTol);
Standard_ProgramError_Raise_if(!mypMapToAvoid, "mypMapToAvoid is null");
CorrectEdgeTolerance (myEdge, myFace, myMaxTol, *mypMapToAvoid);
}
//
protected:
Standard_Real myMaxTol;
TopoDS_Edge myEdge;
TopoDS_Face myFace;
const BOPCol_IndexedMapOfShape* mypMapToAvoid;
};
//=======================================================================
typedef BOPCol_NCVector<BOPTools_CDT> BOPTools_VectorOfCDT;
@ -258,7 +286,7 @@ typedef BOPCol_Cnt
//=======================================================================
class BOPTools_CVT {
public:
BOPTools_CVT() {
BOPTools_CVT() : mypMapToAvoid(0L) {
}
//
~BOPTools_CVT() {
@ -268,12 +296,18 @@ class BOPTools_CVT {
myEdge=aE;
}
//
void SetMapToAvoid(const BOPCol_IndexedMapOfShape& aMapToAvoid) {
mypMapToAvoid = &aMapToAvoid;
}
//
void Perform() {
CorrectVertexTolerance(myEdge);
Standard_ProgramError_Raise_if(!mypMapToAvoid, "mypMapToAvoid is null");
CorrectVertexTolerance(myEdge, *mypMapToAvoid);
}
//
protected:
TopoDS_Edge myEdge;
const BOPCol_IndexedMapOfShape* mypMapToAvoid;
};
//
//=======================================================================
@ -293,7 +327,7 @@ typedef BOPCol_Cnt
//=======================================================================
class BOPTools_CET {
public:
BOPTools_CET() {
BOPTools_CET() : mypMapToAvoid(0L) {
}
//
~BOPTools_CET() {
@ -303,12 +337,18 @@ class BOPTools_CET {
myFace=aF;
}
//
void SetMapToAvoid(const BOPCol_IndexedMapOfShape& aMapToAvoid) {
mypMapToAvoid = &aMapToAvoid;
}
//
void Perform() {
UpdateEdges(myFace);
Standard_ProgramError_Raise_if(!mypMapToAvoid, "mypMapToAvoid is null");
UpdateEdges(myFace, *mypMapToAvoid);
}
//
protected:
TopoDS_Face myFace;
const BOPCol_IndexedMapOfShape* mypMapToAvoid;
};
//=======================================================================
typedef BOPCol_NCVector<BOPTools_CET> BOPTools_VectorOfCET;
@ -330,11 +370,12 @@ typedef BOPCol_Cnt
//=======================================================================
void BOPTools_AlgoTools::CorrectTolerances
(const TopoDS_Shape& aShape,
const BOPCol_IndexedMapOfShape& aMapToAvoid,
const Standard_Real aMaxTol,
const Standard_Boolean bRunParallel)
{
BOPTools_AlgoTools::CorrectPointOnCurve(aShape, aMaxTol, bRunParallel);
BOPTools_AlgoTools::CorrectCurveOnSurface(aShape, aMaxTol, bRunParallel);
BOPTools_AlgoTools::CorrectPointOnCurve(aShape, aMapToAvoid, aMaxTol, bRunParallel);
BOPTools_AlgoTools::CorrectCurveOnSurface(aShape, aMapToAvoid, aMaxTol, bRunParallel);
}
//
//=======================================================================
@ -343,6 +384,7 @@ void BOPTools_AlgoTools::CorrectTolerances
//=======================================================================
void BOPTools_AlgoTools::CorrectPointOnCurve
(const TopoDS_Shape& aS,
const BOPCol_IndexedMapOfShape& aMapToAvoid,
const Standard_Real aMaxTol,
const Standard_Boolean bRunParallel)
{
@ -355,6 +397,7 @@ void BOPTools_AlgoTools::CorrectPointOnCurve
BOPTools_CPC& aCPC=aVCPC.Append1();
aCPC.SetEdge(aE);
aCPC.SetMaxTol(aMaxTol);
aCPC.SetMapToAvoid(aMapToAvoid);
}
//
//======================================================
@ -367,6 +410,7 @@ void BOPTools_AlgoTools::CorrectPointOnCurve
//=======================================================================
void BOPTools_AlgoTools::CorrectCurveOnSurface
(const TopoDS_Shape& aS,
const BOPCol_IndexedMapOfShape& aMapToAvoid,
const Standard_Real aMaxTol,
const Standard_Boolean bRunParallel)
{
@ -380,6 +424,7 @@ void BOPTools_AlgoTools::CorrectCurveOnSurface
//
BOPTools_CWT& aCWT=aVCWT.Append1();
aCWT.SetFace(aF);
aCWT.SetMapToAvoid(aMapToAvoid);
//
aExpE.Init(aF, TopAbs_EDGE);
for (; aExpE.More(); aExpE.Next()) {
@ -389,6 +434,7 @@ void BOPTools_AlgoTools::CorrectCurveOnSurface
aCDT.SetEdge(aE);
aCDT.SetFace(aF);
aCDT.SetMaxTol(aMaxTol);
aCDT.SetMapToAvoid(aMapToAvoid);
}
}
//
@ -404,6 +450,7 @@ void BOPTools_AlgoTools::CorrectCurveOnSurface
//=======================================================================
void BOPTools_AlgoTools::CorrectShapeTolerances
(const TopoDS_Shape& aShape,
const BOPCol_IndexedMapOfShape& aMapToAvoid,
const Standard_Boolean bRunParallel)
{
TopExp_Explorer aExp;
@ -415,6 +462,7 @@ void BOPTools_AlgoTools::CorrectShapeTolerances
const TopoDS_Edge& aE = *(TopoDS_Edge*)&aExp.Current();
BOPTools_CVT& aCVT=aVCVT.Append1();
aCVT.SetEdge(aE);
aCVT.SetMapToAvoid(aMapToAvoid);
}
//
//======================================================
@ -426,6 +474,7 @@ void BOPTools_AlgoTools::CorrectShapeTolerances
const TopoDS_Face& aF = *(TopoDS_Face*)&aExp.Current();
BOPTools_CET& aCET=aVCET.Append1();
aCET.SetFace(aF);
aCET.SetMapToAvoid(aMapToAvoid);
}
//
//======================================================
@ -438,7 +487,8 @@ void BOPTools_AlgoTools::CorrectShapeTolerances
// purpose : Correct tolerances for Vertices on Edge
//=======================================================================
void CheckEdge (const TopoDS_Edge& Ed,
const Standard_Real aMaxTol)
const Standard_Real aMaxTol,
const BOPCol_IndexedMapOfShape& aMapToAvoid)
{
Standard_Real aTolE, aTol, aD2, aNewTolerance, dd;
gp_Pnt aPC;
@ -490,7 +540,7 @@ void CheckEdge (const TopoDS_Edge& Ed,
if (aD2 > aTol) {
aNewTolerance=sqrt(aD2)+dd;
if (aNewTolerance<aMaxTol)
TV->UpdateTolerance(aNewTolerance);
UpdateShape(aV, aNewTolerance, aMapToAvoid);
}
}
aItPR.Next();
@ -512,7 +562,7 @@ void CheckEdge (const TopoDS_Edge& Ed,
if (aD2 > aTol) {
aNewTolerance=sqrt(aD2)+dd;
if (aNewTolerance<aMaxTol)
TV->UpdateTolerance(aNewTolerance);
UpdateShape(aV, aNewTolerance, aMapToAvoid);
}
}
}
@ -525,7 +575,8 @@ void CheckEdge (const TopoDS_Edge& Ed,
// Function : CorrectWires
// purpose :
//=======================================================================
void CorrectWires(const TopoDS_Face& aFx)
void CorrectWires(const TopoDS_Face& aFx,
const BOPCol_IndexedMapOfShape& aMapToAvoid)
{
Standard_Boolean bIsPeriodic;
Standard_Integer i, aNbV;
@ -600,10 +651,8 @@ void CorrectWires(const TopoDS_Face& aFx)
}// for (; aIt1.More(); aIt1.Next()) {
}// for (; aIt.More(); aIt.Next()) {
if (aD2max>aTol2) {
BRep_Builder aBB;
//
aTol=sqrt(aD2max);
aBB.UpdateVertex(aV, aTol);
UpdateShape(aV, aTol, aMapToAvoid);
}
}// for (i=1; i<=aNbV; ++i) {
}
@ -673,7 +722,8 @@ Standard_Real IntersectCurves2d(const gp_Pnt& aPV,
//=======================================================================
void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
const TopoDS_Face& S,
const Standard_Real aMaxTol)
const Standard_Real aMaxTol,
const BOPCol_IndexedMapOfShape& aMapToAvoid)
{
//
// 1. Minimum of conditions to Perform
@ -812,9 +862,8 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
Tol, SameParameter, aNewTol);
if (ok) {
if (aNewTol<aMaxTol) {
TE->UpdateTolerance(aNewTol+Delta);
//
CorrectVertexTolerance(myShape);
UpdateShape(myShape, aNewTol+Delta, aMapToAvoid);
CorrectVertexTolerance(myShape, aMapToAvoid);
}
}
@ -825,8 +874,8 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
if (ok) {
if (aNewTol<aMaxTol) {
TE->UpdateTolerance(aNewTol+Delta);
CorrectVertexTolerance(myShape);
UpdateShape(myShape, aNewTol+Delta, aMapToAvoid);
CorrectVertexTolerance(myShape, aMapToAvoid);
}
}
}
@ -881,8 +930,8 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
Tol,Standard_True, aNewTol);
if (okx) {
if (aNewTol<aMaxTol) {
TE->UpdateTolerance(aNewTol+Delta);
CorrectVertexTolerance(myShape);
UpdateShape(myShape, aNewTol+Delta, aMapToAvoid);
CorrectVertexTolerance(myShape, aMapToAvoid);
}
}
}
@ -893,7 +942,8 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
//function : CorrectVertexTolerance
//purpose :
//=======================================================================
void CorrectVertexTolerance(const TopoDS_Edge& aE)
void CorrectVertexTolerance(const TopoDS_Edge& aE,
const BOPCol_IndexedMapOfShape& aMapToAvoid)
{
Standard_Real aTolE, aTolV;
TopoDS_Iterator aIt;
@ -904,8 +954,7 @@ void CorrectVertexTolerance(const TopoDS_Edge& aE)
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aIt.Value());
aTolV=BRep_Tool::Tolerance(aV);
if (aTolV<aTolE) {
Handle(BRep_TVertex)& aTV= *((Handle(BRep_TVertex)*)&aV.TShape());
aTV->UpdateTolerance(aTolE);
UpdateShape(aV, aTolE, aMapToAvoid);
}
}
}
@ -1027,11 +1076,11 @@ Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
// Function : UpdateEdges
// purpose :
//=======================================================================
void UpdateEdges(const TopoDS_Face& aF)
void UpdateEdges(const TopoDS_Face& aF,
const BOPCol_IndexedMapOfShape& aMapToAvoid)
{
Standard_Real aTolF, aTolE, aTolV;
TopoDS_Iterator aItF, aItW, aItE;
BRep_Builder aBB;
//
aTolE=aTolF= BRep_Tool::Tolerance(aF);
aItF.Initialize(aF);
@ -1043,22 +1092,46 @@ void UpdateEdges(const TopoDS_Face& aF)
const TopoDS_Edge& aE=*((TopoDS_Edge*)&aItW.Value());
aTolE = BRep_Tool::Tolerance(aE);
if (aTolE < aTolF) {
aBB.UpdateEdge(aE, aTolF);
UpdateShape(aE, aTolF, aMapToAvoid);
aTolE = aTolF;
}
//UpdateVertices(aE);
}
}
else {
const TopoDS_Vertex& aV=*(TopoDS_Vertex*)&aItF.Value();
aTolV = BRep_Tool::Tolerance(aV);
if (aTolV < aTolE) {
aBB.UpdateVertex(aV, aTolF);
UpdateShape(aV, aTolF, aMapToAvoid);
}
}
}
}
//=======================================================================
//function : UpdateShape
//purpose :
//=======================================================================
void UpdateShape(const TopoDS_Shape& aS,
const Standard_Real aTol,
const BOPCol_IndexedMapOfShape& aMapToAvoid)
{
if (aMapToAvoid.Contains(aS)) {
return;
}
//
TopAbs_ShapeEnum aType;
BRep_Builder aBB;
//
aType=aS.ShapeType();
if (aType==TopAbs_EDGE) {
const TopoDS_Edge& aE = *((TopoDS_Edge*)&aS);
aBB.UpdateEdge(aE, aTol);
}
else if (aType==TopAbs_VERTEX) {
const TopoDS_Vertex& aV = *((TopoDS_Vertex*)&aS);
aBB.UpdateVertex(aV, aTol);
}
}
//=======================================================================
// Function : ComputeTolerance
// purpose :
//=======================================================================

1
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cxx
View File

@ -305,6 +305,7 @@ void BRepAlgoAPI_BooleanOperation::Build()
myDSFiller->SetRunParallel(myRunParallel);
myDSFiller->SetProgressIndicator(myProgressIndicator);
myDSFiller->SetFuzzyValue(myFuzzyValue);
myDSFiller->SetNonDestructive(myNonDestructive);
//
SetAttributes();
//

23
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx
View File

@ -28,7 +28,8 @@ BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo()
myEntryType(1),
myDSFiller(NULL),
myBuilder(NULL),
myFuzzyValue(0.)
myFuzzyValue(0.),
myNonDestructive(Standard_False)
{}
//=======================================================================
// function:
@ -40,7 +41,8 @@ BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo
BRepAlgoAPI_Algo(),
myEntryType(0),
myBuilder(NULL),
myFuzzyValue(0.)
myFuzzyValue(0.),
myNonDestructive(Standard_False)
{
BOPAlgo_PaveFiller* pPF=(BOPAlgo_PaveFiller*)&aPF;
myDSFiller=pPF;
@ -70,6 +72,22 @@ Standard_Real BRepAlgoAPI_BuilderAlgo::FuzzyValue() const
return myFuzzyValue;
}
//=======================================================================
//function : SetNonDestructive
//purpose :
//=======================================================================
void BRepAlgoAPI_BuilderAlgo::SetNonDestructive(const Standard_Boolean theFlag)
{
myNonDestructive = theFlag;
}
//=======================================================================
//function : NonDestructive
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_BuilderAlgo::NonDestructive() const
{
return myNonDestructive;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
@ -125,6 +143,7 @@ void BRepAlgoAPI_BuilderAlgo::Build()
myDSFiller->SetRunParallel(myRunParallel);
myDSFiller->SetProgressIndicator(myProgressIndicator);
myDSFiller->SetFuzzyValue(myFuzzyValue);
myDSFiller->SetNonDestructive(myNonDestructive);
//
myDSFiller->Perform();
iErr=myDSFiller->ErrorStatus();

13
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.hxx
View File

@ -51,7 +51,17 @@ Standard_EXPORT virtual ~BRepAlgoAPI_BuilderAlgo();
//! Returns the additional tolerance
Standard_EXPORT Standard_Real FuzzyValue() const;
//! Sets the flag that defines the mode of treatment.
//! In non-destructive mode the argument shapes are not modified. Instead
//! a copy of a sub-shape is created in the result if it is needed to be updated.
Standard_EXPORT void SetNonDestructive(const Standard_Boolean theFlag);
//! Returns the flag that defines the mode of treatment.
//! In non-destructive mode the argument shapes are not modified. Instead
//! a copy of a sub-shape is created in the result if it is needed to be updated.
Standard_EXPORT Standard_Boolean NonDestructive() const;
//! Sets the arguments
Standard_EXPORT void SetArguments (const TopTools_ListOfShape& theLS);
@ -101,6 +111,7 @@ protected:
BOPAlgo_PPaveFiller myDSFiller;
BOPAlgo_PBuilder myBuilder;
Standard_Real myFuzzyValue;
Standard_Boolean myNonDestructive;
TopTools_ListOfShape myArguments;

24
src/IntTools/IntTools_BeanFaceIntersector.cxx
View File

@ -200,7 +200,7 @@ IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const BRepAdaptor_Cur
{
myCurve = theCurve;
myCriteria = myBeanTolerance + myFaceTolerance;
myCriteria = myBeanTolerance + myFaceTolerance + Precision::Confusion();
myCurveResolution = myCurve.Resolution(myCriteria);
mySurface = theSurface;
@ -220,7 +220,7 @@ void IntTools_BeanFaceIntersector::Init(const TopoDS_Edge& theEdge,
myBeanTolerance = BRep_Tool::Tolerance(theEdge);
myFaceTolerance = BRep_Tool::Tolerance(theFace);
myCriteria = myBeanTolerance + myFaceTolerance;
myCriteria = myBeanTolerance + myFaceTolerance + Precision::Confusion();
myCurveResolution = myCurve.Resolution(myCriteria);
SetSurfaceParameters(mySurface.FirstUParameter(), mySurface.LastUParameter(),
@ -243,7 +243,7 @@ void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve& theCurve,
myBeanTolerance = theBeanTolerance;
myFaceTolerance = theFaceTolerance;
myCriteria = myBeanTolerance + myFaceTolerance;
myCriteria = myBeanTolerance + myFaceTolerance + Precision::Confusion();
myCurveResolution = myCurve.Resolution(myCriteria);
SetSurfaceParameters(mySurface.FirstUParameter(), mySurface.LastUParameter(),
@ -1018,14 +1018,24 @@ void IntTools_BeanFaceIntersector::ComputeLinePlane()
if(myUMinParameter > u || u > myUMaxParameter || myVMinParameter > v || v > myVMaxParameter) {
return;
}
Standard_Real t1 = Max(myFirstParameter, t-myCriteria);
Standard_Real t2 = Min(myLastParameter, t+myCriteria);
//
// compute correct range on the edge
Standard_Real anAngle, aDt;
gp_Dir aDL, aDP;
//
aDL = L.Position().Direction();
aDP = P.Position().Direction();
anAngle = Abs(M_PI_2 - aDL.Angle(aDP));
//
aDt = IntTools_Tools::ComputeIntRange
(myBeanTolerance, myFaceTolerance, anAngle);
//
Standard_Real t1 = Max(myFirstParameter, t - aDt);
Standard_Real t2 = Min(myLastParameter, t + aDt);
IntTools_Range aRange(t1, t2);
myResults.Append(aRange);
return;
}

46
src/IntTools/IntTools_Context.cxx
View File

@ -500,7 +500,7 @@ Standard_Integer IntTools_Context::ComputePE
aDist=aProjector.LowerDistance();
//
aTolE2=BRep_Tool::Tolerance(aE2);
aTolSum=aTolP1+aTolE2;
aTolSum = aTolP1 + aTolE2 + Precision::Confusion();
//
aT=aProjector.LowerDistanceParameter();
if (aDist > aTolSum) {
@ -515,7 +515,8 @@ Standard_Integer IntTools_Context::ComputePE
Standard_Integer IntTools_Context::ComputeVE
(const TopoDS_Vertex& aV1,
const TopoDS_Edge& aE2,
Standard_Real& aT)
Standard_Real& aParam,
Standard_Real& aTolVnew)
{
if (BRep_Tool::Degenerated(aE2)) {
return -1;
@ -538,29 +539,29 @@ Standard_Integer IntTools_Context::ComputeVE
}
//
aDist=aProjector.LowerDistance();
// tolerance of check for coincidence is sum of tolerances of edge and vertex
// extended by additional Precision::Confusion() to allow for interference where
// it is very close but not fit to tolerance (see #24108)
//
aTolV1=BRep_Tool::Tolerance(aV1);
aTolE2=BRep_Tool::Tolerance(aE2);
aTolSum = aTolV1 + aTolE2 + Precision::Confusion();
//
aT=aProjector.LowerDistanceParameter();
aTolVnew=aDist+aTolE2;
//
aParam=aProjector.LowerDistanceParameter();
if (aDist > aTolSum) {
return -4;
}
return 0;
}
//=======================================================================
//function : ComputeVS
//function : ComputeVF
//purpose :
//=======================================================================
Standard_Integer IntTools_Context::ComputeVF
(const TopoDS_Vertex& aV1,
const TopoDS_Face& aF2,
Standard_Real& U,
Standard_Real& V)
Standard_Real& V,
Standard_Real& aTolVnew)
{
Standard_Real aTolV1, aTolF2, aTolSum, aDist;
gp_Pnt aP;
@ -578,10 +579,13 @@ Standard_Integer IntTools_Context::ComputeVF
// 2. Check the distance between the projection point and
// the original point
aDist=aProjector.LowerDistance();
//
aTolV1=BRep_Tool::Tolerance(aV1);
aTolF2=BRep_Tool::Tolerance(aF2);
aTolSum=aTolV1+aTolF2;
//
aTolSum = aTolV1 + aTolF2 + Precision::Confusion();
aTolVnew = aDist + aTolF2;
//
if (aDist > aTolSum) {
// the distance is too large
return -2;
@ -860,14 +864,16 @@ Standard_Boolean IntTools_Context::IsVertexOnLine
Extrema_ExtPC anExt2(aPv, aGAC, 1.e-10);
Standard_Real aMinDist = RealLast();
Standard_Integer aMinIdx = -1;
for (Standard_Integer anIdx = 1; anIdx <= anExt2.NbExt(); anIdx++)
{
if ( anExt2.IsMin(anIdx) &&
anExt2.SquareDistance(anIdx) < aMinDist )
if (anExt2.IsDone()) {
for (Standard_Integer anIdx = 1; anIdx <= anExt2.NbExt(); anIdx++)
{
if ( anExt2.IsMin(anIdx) &&
anExt2.SquareDistance(anIdx) < aMinDist )
{
aMinDist = anExt2.SquareDistance(anIdx);
aMinIdx = anIdx;
}
}
}
if (aMinIdx != -1)
{
@ -912,14 +918,16 @@ Standard_Boolean IntTools_Context::IsVertexOnLine
Extrema_ExtPC anExt2(aPv, aGAC, 1.e-10);
Standard_Real aMinDist = RealLast();
Standard_Integer aMinIdx = -1;
for (Standard_Integer anIdx = 1; anIdx <= anExt2.NbExt(); anIdx++)
{
if ( anExt2.IsMin(anIdx) &&
anExt2.SquareDistance(anIdx) < aMinDist )
if (anExt2.IsDone()) {
for (Standard_Integer anIdx = 1; anIdx <= anExt2.NbExt(); anIdx++)
{
if ( anExt2.IsMin(anIdx) &&
anExt2.SquareDistance(anIdx) < aMinDist )
{
aMinDist = anExt2.SquareDistance(anIdx);
aMinIdx = anIdx;
}
}
}
if (aMinIdx != -1)
{

30
src/IntTools/IntTools_Context.hxx
View File

@ -112,27 +112,35 @@ Standard_EXPORT virtual ~IntTools_Context();
//! Computes parameter of the vertex aV on
//! the edge aE.
//! the edge aE and new increased value of vertex tolerance.
//! Returns zero if the distance between vertex
//! and edge is less than sum of tolerances,
//! otherwise and for following conditions returns
//! negative value
//! 1. the edge is degenerated (-1)
//! 2. the edge does not contain 3d curve and pcurves (-2)
//! negative value: <br>
//! 1. the edge is degenerated (-1) <br>
//! 2. the edge does not contain 3d curve and pcurves (-2) <br>
//! 3. projection algorithm failed (-3)
Standard_EXPORT Standard_Integer ComputeVE (const TopoDS_Vertex& aV, const TopoDS_Edge& aE, Standard_Real& aT);
Standard_EXPORT Standard_Integer ComputeVE (const TopoDS_Vertex& aV,
const TopoDS_Edge& aE,
Standard_Real& aParam,
Standard_Real& aTolVnew);
//! Computes UV parameters of the vertex aV on face aF
//! and new increased value of vertex tolerance.
//! Returns zero if the distance between vertex and face is
//! less than or equal the sum of tolerances and the projection
//! point lays inside boundaries of the face.
//! For following conditions returns negative value
//! 1. projection algorithm failed (-1)
//! 2. distance is more than sum of tolerances (-2)
//! For following conditions returns negative value <br>
//! 1. projection algorithm failed (-1) <br>
//! 2. distance is more than sum of tolerances (-2) <br>
//! 3. projection point out or on the boundaries of face (-3)
Standard_EXPORT Standard_Integer ComputeVF (const TopoDS_Vertex& aV, const TopoDS_Face& aF, Standard_Real& U, Standard_Real& V);
Standard_EXPORT Standard_Integer ComputeVF (const TopoDS_Vertex& aV,
const TopoDS_Face& aF,
Standard_Real& U,
Standard_Real& V,
Standard_Real& aTolVnew);
//! Returns the state of the point aP2D
//! relative to face aF

34
src/IntTools/IntTools_EdgeEdge.cxx
View File

@ -30,6 +30,7 @@
#include <IntTools_CommonPrt.hxx>
#include <IntTools_EdgeEdge.hxx>
#include <IntTools_Range.hxx>
#include <IntTools_Tools.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Iterator.hxx>
@ -157,8 +158,9 @@ void IntTools_EdgeEdge::Prepare()
mySwap = Standard_True;
}
//
myTol1 = myCurve1.Tolerance();
myTol2 = myCurve2.Tolerance();
Standard_Real aTolAdd = Precision::Confusion() / 2.;
myTol1 = myCurve1.Tolerance() + aTolAdd;
myTol2 = myCurve2.Tolerance() + aTolAdd;
myTol = myTol1 + myTol2;
//
if (iCT1 != 0 || iCT2 != 0) {
@ -321,7 +323,7 @@ void IntTools_EdgeEdge::FindSolutions(const IntTools_Range& theR1,
bThin = ((aT12 - aT11) < myRes1) ||
(aB1.IsXThin(myTol) && aB1.IsYThin(myTol) && aB1.IsZThin(myTol));
//
bOut = !FindParameters(myCurve2, aTB21, aTB22, myRes2, myPTol2,
bOut = !FindParameters(myCurve2, aTB21, aTB22, myTol2, myRes2, myPTol2,
myResCoeff2, aB1, aT21, aT22);
if (bOut || bThin) {
break;
@ -338,7 +340,7 @@ void IntTools_EdgeEdge::FindSolutions(const IntTools_Range& theR1,
bThin = ((aT22 - aT21) < myRes2) ||
(aB2.IsXThin(myTol) && aB2.IsYThin(myTol) && aB2.IsZThin(myTol));
//
bOut = !FindParameters(myCurve1, aTB11, aTB12, myRes1, myPTol1,
bOut = !FindParameters(myCurve1, aTB11, aTB12, myTol1, myRes1, myPTol1,
myResCoeff1, aB2, aT11, aT12);
//
if (bOut || bThin) {
@ -439,7 +441,8 @@ void IntTools_EdgeEdge::FindSolutions(const IntTools_Range& theR1,
//=======================================================================
Standard_Boolean IntTools_EdgeEdge::FindParameters(const BRepAdaptor_Curve& theBAC,
const Standard_Real aT1,
const Standard_Real aT2,
const Standard_Real aT2,
const Standard_Real theTol,
const Standard_Real theRes,
const Standard_Real thePTol,
const Standard_Real theResCoeff,
@ -450,18 +453,17 @@ Standard_Boolean IntTools_EdgeEdge::FindParameters(const BRepAdaptor_Curve& theB
Standard_Boolean bRet;
Standard_Integer aC, i, k;
Standard_Real aCf, aDiff, aDt, aT, aTB, aTOut, aTIn;
Standard_Real aDist, aDistP, aDistTol, aTol;
Standard_Real aDist, aDistP, aDistTol;
gp_Pnt aP;
Bnd_Box aCBx;
//
bRet = Standard_False;
aCf = 0.6180339887498948482045868343656;// =0.5*(1.+sqrt(5.))/2.;
aDt = theRes;
aTol = theBAC.Tolerance();
aDistP = 0.;
aDistTol = Precision::PConfusion();
aDistTol = 1e-9;
aCBx = theCBox;
aCBx.Enlarge(aTol);
aCBx.Enlarge(theTol);
//
const Handle(Geom_Curve)& aCurve = theBAC.Curve().Curve();
const GeomAbs_CurveType aCurveType = theBAC.GetType();
@ -476,7 +478,7 @@ Standard_Boolean IntTools_EdgeEdge::FindParameters(const BRepAdaptor_Curve& theB
while (aC*(aT-aTB) >= 0) {
theBAC.D0(aTB, aP);
aDist = PointBoxDistance(theCBox, aP);
if (aDist > aTol) {
if (aDist > theTol) {
if (fabs(aDist - aDistP) < aDistTol) {
aDt = Resolution(aCurve, aCurveType, theResCoeff, (++k)*aDist);
} else {
@ -867,8 +869,16 @@ void IntTools_EdgeEdge::ComputeLineLine()
return;
}
//
aCommonPrt.SetRange1(aT1 - myTol, aT1 + myTol);
aCommonPrt.AppendRange2(aT2 - myTol, aT2 + myTol);
// compute correct range on the edges
Standard_Real anAngle, aDt1, aDt2;
//
anAngle = aD1.Angle(aD2);
//
aDt1 = IntTools_Tools::ComputeIntRange(myTol1, myTol2, anAngle);
aDt2 = IntTools_Tools::ComputeIntRange(myTol2, myTol1, anAngle);
//
aCommonPrt.SetRange1(aT1 - aDt1, aT1 + aDt1);
aCommonPrt.AppendRange2(aT2 - aDt2, aT2 + aDt2);
aCommonPrt.SetType(TopAbs_VERTEX);
aCommonPrt.SetVertexParameter1(aT1);
aCommonPrt.SetVertexParameter2(aT2);

79
src/IntTools/IntTools_EdgeEdge.hxx
View File

@ -47,48 +47,51 @@ public:
//! Empty contructor
IntTools_EdgeEdge();
~IntTools_EdgeEdge();
IntTools_EdgeEdge();
//! Destructor
~IntTools_EdgeEdge();
//! Contructor
IntTools_EdgeEdge(const TopoDS_Edge& theEdge1, const TopoDS_Edge& theEdge2);
//! Contructor
IntTools_EdgeEdge(const TopoDS_Edge& theEdge1, const TopoDS_Edge& theEdge2);
//! Contructor
IntTools_EdgeEdge(const TopoDS_Edge& theEdge1, const Standard_Real aT11, const Standard_Real aT12, const TopoDS_Edge& theEdge2, const Standard_Real aT21, const Standard_Real aT22);
IntTools_EdgeEdge(const TopoDS_Edge& theEdge1, const Standard_Real aT11,
const Standard_Real aT12, const TopoDS_Edge& theEdge2,
const Standard_Real aT21, const Standard_Real aT22);
//! Sets the first edge
void SetEdge1 (const TopoDS_Edge& theEdge);
void SetEdge1(const TopoDS_Edge& theEdge);
//! Sets the first edge and its range
void SetEdge1 (const TopoDS_Edge& theEdge, const Standard_Real aT1, const Standard_Real aT2);
void SetEdge1(const TopoDS_Edge& theEdge, const Standard_Real aT1, const Standard_Real aT2);
//! Sets the range for the first edge
void SetRange1 (const IntTools_Range& theRange1);
void SetRange1(const IntTools_Range& theRange1);
//! Sets the range for the first edge
void SetRange1 (const Standard_Real aT1, const Standard_Real aT2);
void SetRange1(const Standard_Real aT1, const Standard_Real aT2);
//! Sets the second edge
void SetEdge2 (const TopoDS_Edge& theEdge);
void SetEdge2(const TopoDS_Edge& theEdge);
//! Sets the first edge and its range
void SetEdge2 (const TopoDS_Edge& theEdge, const Standard_Real aT1, const Standard_Real aT2);
void SetEdge2(const TopoDS_Edge& theEdge, const Standard_Real aT1, const Standard_Real aT2);
//! Sets the range for the second edge
void SetRange2 (const IntTools_Range& theRange);
void SetRange2(const IntTools_Range& theRange);
//! Sets the range for the second edge
void SetRange2 (const Standard_Real aT1, const Standard_Real aT2);
void SetRange2(const Standard_Real aT1, const Standard_Real aT2);
//! Performs the intersection between edges
@ -96,11 +99,11 @@ public:
//! Returns TRUE if common part(s) is(are) found
Standard_Boolean IsDone() const;
Standard_Boolean IsDone() const;
//! Returns common parts
const IntTools_SequenceOfCommonPrts& CommonParts() const;
const IntTools_SequenceOfCommonPrts& CommonParts() const;
@ -110,7 +113,7 @@ protected:
//! Checks the data
void CheckData();
void CheckData();
//! Prepares the data
@ -122,36 +125,50 @@ protected:
//! Intermediate function
Standard_EXPORT void FindSolutions (IntTools_SequenceOfRanges& theRanges1, IntTools_SequenceOfRanges& theRanges2, Standard_Boolean& bSplit2);
Standard_EXPORT void FindSolutions (IntTools_SequenceOfRanges& theRanges1,
IntTools_SequenceOfRanges& theRanges2, Standard_Boolean& bSplit2);
//! Looking for the exact intersection ranges
Standard_EXPORT void FindSolutions (const IntTools_Range& theR1, const IntTools_Range& theR2, const Bnd_Box& theBox2, IntTools_SequenceOfRanges& theRanges1, IntTools_SequenceOfRanges& theRanges2);
Standard_EXPORT void FindSolutions (const IntTools_Range& theR1,
const IntTools_Range& theR2, const Bnd_Box& theBox2,
IntTools_SequenceOfRanges& theRanges1, IntTools_SequenceOfRanges& theRanges2);
//! Merges found solutions
Standard_EXPORT void MergeSolutions (const IntTools_SequenceOfRanges& theRanges1, const IntTools_SequenceOfRanges& theRanges2, const Standard_Boolean bSplit2);
Standard_EXPORT void MergeSolutions (const IntTools_SequenceOfRanges& theRanges1,
const IntTools_SequenceOfRanges& theRanges2, const Standard_Boolean bSplit2);
//! Looking for the range of the edge whick is in the box
Standard_EXPORT static Standard_Boolean FindParameters (const BRepAdaptor_Curve& theBAC, const Standard_Real aT1, const Standard_Real aT2, const Standard_Real theRes, const Standard_Real thePTol, const Standard_Real theResCoeff, const Bnd_Box& theCBox, Standard_Real& aTB1, Standard_Real& aTB2);
Standard_EXPORT static Standard_Boolean FindParameters(const BRepAdaptor_Curve& theBAC,
const Standard_Real aT1, const Standard_Real aT2, const Standard_Real theTol,
const Standard_Real theRes, const Standard_Real thePTol,
const Standard_Real theResCoeff, const Bnd_Box& theCBox,
Standard_Real& aTB1, Standard_Real& aTB2);
//! Checks if edges coincide on the ranges
Standard_EXPORT Standard_Integer CheckCoincidence (const Standard_Real aT11, const Standard_Real aT12, const Standard_Real aT21, const Standard_Real aT22, const Standard_Real theCriteria, const Standard_Real theCurveRes1);
Standard_EXPORT Standard_Integer CheckCoincidence (const Standard_Real aT11,
const Standard_Real aT12, const Standard_Real aT21, const Standard_Real aT22,
const Standard_Real theCriteria, const Standard_Real theCurveRes1);
//! Adds common part of the given type to myCommonParts
Standard_EXPORT void AddSolution (const Standard_Real aT11, const Standard_Real aT12, const Standard_Real aT21, const Standard_Real aT22, const TopAbs_ShapeEnum theType);
Standard_EXPORT void AddSolution (const Standard_Real aT11, const Standard_Real aT12,
const Standard_Real aT21, const Standard_Real aT22, const TopAbs_ShapeEnum theType);
//! Looking for the minimal distance between edges on the ranges
Standard_EXPORT void FindBestSolution (const Standard_Real aT11, const Standard_Real aT12, const Standard_Real aT21, const Standard_Real aT22, Standard_Real& aT1, Standard_Real& aT2);
Standard_EXPORT void FindBestSolution (const Standard_Real aT11, const Standard_Real aT12,
const Standard_Real aT21, const Standard_Real aT22,
Standard_Real& aT1, Standard_Real& aT2);
//! Checks is there an intersection between edges on the given ranges
//! (for nearly conicident edges)
Standard_EXPORT Standard_Boolean IsIntersection (const Standard_Real aT11, const Standard_Real aT12, const Standard_Real aT21, const Standard_Real aT22);
Standard_EXPORT Standard_Boolean IsIntersection (const Standard_Real aT11,
const Standard_Real aT12, const Standard_Real aT21, const Standard_Real aT22);
TopoDS_Edge myEdge1;
@ -175,20 +192,10 @@ protected:
Standard_Integer myErrorStatus;
IntTools_SequenceOfCommonPrts myCommonParts;
private:
};
#include <IntTools_EdgeEdge.lxx>
#endif // _IntTools_EdgeEdge_HeaderFile

4
src/IntTools/IntTools_EdgeFace.cxx
View File

@ -284,7 +284,7 @@ void IntTools_EdgeFace::Prepare()
myCriteria=1.5*myTolE+myTolF;
}
else {
myCriteria=myTolE+myTolF;
myCriteria = myTolE + myTolF + Precision::Confusion();
}
// 2.a myTmin, myTmax
myTmin=myRange.First();
@ -1236,7 +1236,7 @@ void IntTools_EdgeFace::Perform()
myCriteria=1.5*myTolE+myTolF;
}
else {
myCriteria=myTolE+myTolF;
myCriteria = myTolE + myTolF + Precision::Confusion();
}
myTmin=myRange.First();

60
src/IntTools/IntTools_FaceFace.cxx
View File

@ -151,12 +151,15 @@ static
static void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
const Handle(GeomAdaptor_HSurface)& theS2,
const Standard_Real TolF1,
const Standard_Real TolF2,
const Standard_Real TolAng,
const Standard_Real TolTang,
const Standard_Boolean theApprox1,
const Standard_Boolean theApprox2,
IntTools_SequenceOfCurves& theSeqOfCurve,
Standard_Boolean& theTangentFaces);
Standard_Boolean& theTangentFaces,
Standard_Real& TolReached3d);
static Standard_Boolean ClassifyLin2d(const Handle(GeomAdaptor_HSurface)& theS,
const gp_Lin2d& theLin2d,
@ -225,6 +228,7 @@ IntTools_FaceFace::IntTools_FaceFace()
myHS2 = new GeomAdaptor_HSurface ();
myTolReached2d=0.;
myTolReached3d=0.;
myTolReal = 0.;
SetParameters(Standard_True, Standard_True, Standard_True, 1.e-07);
}
@ -293,6 +297,14 @@ Standard_Real IntTools_FaceFace::TolReached3d() const
return myTolReached3d;
}
//=======================================================================
//function : TolReal
//purpose :
//=======================================================================
Standard_Real IntTools_FaceFace::TolReal() const
{
return myTolReal;
}
//=======================================================================
//function : Lines
//purpose : return lines of intersection
//=======================================================================
@ -341,7 +353,7 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
const Standard_Real Tolang = 1.e-8;
const Standard_Real aTolF1=BRep_Tool::Tolerance(theF1);
const Standard_Real aTolF2=BRep_Tool::Tolerance(theF2);
const Standard_Real aTolSum = aTolF1 + aTolF2;
const Standard_Real aTolSum = aTolF1 + aTolF2 + Precision::Confusion();
Standard_Real aHigh = 0.0;
const BRepAdaptor_Surface aBAS1(theF1), aBAS2(theF2);
@ -424,6 +436,7 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
mySeqOfCurve.Clear();
myTolReached2d=0.;
myTolReached3d=0.;
myTolReal = 0.;
myIsDone = Standard_False;
myNbrestr=0;//?
@ -469,7 +482,7 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
const Standard_Real aTolF1=BRep_Tool::Tolerance(myFace1);
const Standard_Real aTolF2=BRep_Tool::Tolerance(myFace2);
Standard_Real TolArc = aTolF1 + aTolF2;
Standard_Real TolArc = aTolF1 + aTolF2 + Precision::Confusion();
Standard_Real TolTang = TolArc;
const Standard_Boolean isFace1Quad = (aType1 == GeomAbs_Cylinder ||
@ -493,8 +506,10 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
//
Standard_Real TolAng = 1.e-8;
//
PerformPlanes(myHS1, myHS2, TolAng, TolTang, myApprox1, myApprox2,
mySeqOfCurve, myTangentFaces);
PerformPlanes(myHS1, myHS2,
aTolF1, aTolF2, TolAng, TolTang,
myApprox1, myApprox2,
mySeqOfCurve, myTangentFaces, myTolReached3d);
//
myIsDone = Standard_True;
@ -502,13 +517,16 @@ void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
const Standard_Integer NbLinPP = mySeqOfCurve.Length();
if(NbLinPP) {
Standard_Real aTolFMax;
myTolReached3d = 1.e-7;
aTolFMax=Max(aTolF1, aTolF2);
if (aTolFMax>myTolReached3d) {
myTolReached3d=aTolFMax;
myTolReal = Precision::Confusion();
if (aTolFMax > myTolReal) {
myTolReal = aTolFMax;
}
if (aTolFMax > myTolReached3d) {
myTolReached3d = aTolFMax;
}
//
myTolReached2d = myTolReached3d;
myTolReached2d = myTolReal;
if (bReverse) {
Handle(Geom2d_Curve) aC2D1, aC2D2;
@ -778,7 +796,7 @@ Standard_Real IntTools_FaceFace::ComputeTolerance()
//function :ComputeTolReached3d
//purpose :
//=======================================================================
void IntTools_FaceFace::ComputeTolReached3d()
void IntTools_FaceFace::ComputeTolReached3d()
{
Standard_Integer aNbLin;
GeomAbs_SurfaceType aType1, aType2;
@ -825,9 +843,10 @@ Standard_Real IntTools_FaceFace::ComputeTolerance()
Standard_Real aDMax = ComputeTolerance();
if (aDMax > myTolReached3d)
{
myTolReached3d = aDMax;
}
myTolReached3d = aDMax;
}
myTolReal = myTolReached3d;
}
//=======================================================================
//function : MakeCurve
@ -2686,12 +2705,15 @@ Standard_Boolean ApproxWithPCurves(const gp_Cylinder& theCyl,
//=======================================================================
void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
const Handle(GeomAdaptor_HSurface)& theS2,
const Standard_Real TolF1,
const Standard_Real TolF2,
const Standard_Real TolAng,
const Standard_Real TolTang,
const Standard_Boolean theApprox1,
const Standard_Boolean theApprox2,
IntTools_SequenceOfCurves& theSeqOfCurve,
Standard_Boolean& theTangentFaces)
Standard_Boolean& theTangentFaces,
Standard_Real& TolReached3d)
{
gp_Pln aPln1 = theS1->Surface().Plane();
@ -2774,7 +2796,17 @@ void PerformPlanes(const Handle(GeomAdaptor_HSurface)& theS1,
}
theSeqOfCurve.Append(aCurve);
//
// computation of the tolerance reached
Standard_Real anAngle, aDt;
gp_Dir aD1, aD2;
//
aD1 = aPln1.Position().Direction();
aD2 = aPln2.Position().Direction();
anAngle = aD1.Angle(aD2);
//
aDt = IntTools_Tools::ComputeIntRange(TolF1, TolF2, anAngle);
TolReached3d = sqrt(aDt*aDt + TolF1*TolF1);
}
//=======================================================================

11
src/IntTools/IntTools_FaceFace.hxx
View File

@ -72,10 +72,14 @@ public:
Standard_EXPORT const IntTools_SequenceOfPntOn2Faces& Points() const;
//! Returns tolerance reached during approximation.
//! 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.
@ -92,7 +96,7 @@ public:
//! Returns True if faces are tangent
Standard_EXPORT Standard_Boolean TangentFaces() const;
//! Provides post-processing the result lines.
//! <bToSplit> - the flag.
@ -141,6 +145,7 @@ private:
Standard_Integer myNbrestr;
Standard_Real myTolReached2d;
Standard_Real myTolReached3d;
Standard_Real myTolReal;
Standard_Boolean myApprox;
Standard_Boolean myApprox1;
Standard_Boolean myApprox2;

14
src/IntTools/IntTools_ShrunkRange.cxx
View File

@ -137,7 +137,7 @@ void IntTools_ShrunkRange::SetShrunkRange(const Standard_Real aT1,
void IntTools_ShrunkRange::Perform()
{
Standard_Real aCF, aCL, aTolE, aTolV1;
Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C;
Standard_Real aTolV2, t1, t11, t1C, t2, t12, t2C, dummy;
Standard_Real aCoeff1, aCoeff2, aTol1, aTol2, dt1, dt2, aR, anEps;
Standard_Integer pri;
Standard_Boolean bInf1, bInf2, bAppr;
@ -187,8 +187,8 @@ void IntTools_ShrunkRange::Perform()
return;
}
//
aTol1 = aTolV1+aTolE;
aTol2 = aTolV2+aTolE;
aTol1 = Max(aTolV1, aTolE);
aTol2 = Max(aTolV2, aTolE);
//
aCoeff1 = (aTolE>0.05) ? 1. : 2.;
aCoeff2 = aCoeff1;
@ -214,9 +214,11 @@ void IntTools_ShrunkRange::Perform()
//
if (fabs(aTV1-aCF)<aEps) {
aCoeff1=1.;
aTol1 += Precision::Confusion();
}
if (fabs(aTV2-aCL)<aEps) {
aCoeff2=1.;
aTol2 += Precision::Confusion();
}
}
//
@ -346,7 +348,7 @@ void IntTools_ShrunkRange::Perform()
BRepBuilderAPI_MakeVertex aMV1(aP1L);
const TopoDS_Vertex& aV1L=aMV1.Vertex();
//
pri=myCtx->ComputeVE (aV1L, myEdge, t1C);
pri = myCtx->ComputeVE(aV1L, myEdge, t1C, dummy);
//
if (pri==-3) {
myErrorStatus=4;
@ -446,7 +448,7 @@ void IntTools_ShrunkRange::Perform()
BRepBuilderAPI_MakeVertex aMV2(aP2L);
const TopoDS_Vertex& aV2L=aMV2.Vertex();
//
pri=myCtx->ComputeVE (aV2L, myEdge, t2C);
pri = myCtx->ComputeVE(aV2L, myEdge, t2C, dummy);
//
if (pri==-3) {
myErrorStatus=5;
@ -474,7 +476,7 @@ void IntTools_ShrunkRange::Perform()
myTS2=t2C;
//
// BndBox
Standard_Real ddx=aTolE;//1.e-12;
Standard_Real ddx = aTolE + Precision::Confusion();
BndLib_Add3dCurve::Add (aBAC, t1C, t2C, ddx, myBndBox);
}
/////////////////////////////////////////////////////////////////////////

27
src/IntTools/IntTools_Tools.cxx
View File

@ -676,7 +676,7 @@ Standard_Boolean IntTools_Tools::IsOnPave1(const Standard_Real aTR,
//
aT1=aCPRange.First();
aT2=aCPRange.Last();
bIsOnPave=(aTR>=aT1 && aTR<=aT1);
bIsOnPave=(aTR>=aT1 && aTR<=aT2);
if (bIsOnPave) {
return bIsOnPave;
}
@ -802,3 +802,28 @@ Standard_Boolean IntTools_Tools::ComputeTolerance
//
return Standard_True;
}
//=======================================================================
// Function : ComputeIntRange
// purpose :
//=======================================================================
Standard_Real IntTools_Tools::ComputeIntRange(const Standard_Real theTol1,
const Standard_Real theTol2,
const Standard_Real theAngle)
{
Standard_Real aDt;
//
if (Abs(M_PI_2 - theAngle) < Precision::Angular()) {
aDt = theTol2;
}
else {
Standard_Real a1, a2, anAngle;
//
anAngle = (theAngle > M_PI_2) ? (M_PI - theAngle) : theAngle;
a1 = theTol1 * tan(M_PI_2 - anAngle);
a2 = theTol2 / sin(anAngle);
aDt = a1 + a2;
}
//
return aDt;
}

5
src/IntTools/IntTools_Tools.hxx
View File

@ -163,6 +163,11 @@ public:
Standard_EXPORT static Standard_Boolean ComputeTolerance (const Handle(Geom_Curve)& theCurve3D, const Handle(Geom2d_Curve)& theCurve2D, const Handle(Geom_Surface)& theSurf, const Standard_Real theFirst, const Standard_Real theLast, Standard_Real& theMaxDist, Standard_Real& theMaxPar);
//! Computes the correct Intersection range for
//! Line/Line, Line/Plane and Plane/Plane intersections
Standard_EXPORT static Standard_Real ComputeIntRange(const Standard_Real theTol1,
const Standard_Real theTol2,
const Standard_Real theAngle);
protected:

14
src/QABugs/QABugs_19.cxx
View File

@ -130,14 +130,18 @@ static Standard_Integer OCC23237 (Draw_Interpretor& di, Standard_Integer /*argc*
}
int aNbEnters = 0;
Standard_Real aPerfMeter_CPUtime = 0., aTimer_ElapsedTime = aTM.ElapsedTime();
Standard_Real aPerfMeter_CPUtime = 0., aTimer_CPUTime = 0., aS;
Standard_Integer aM, aH;
aTM.Show(aS, aM, aH, aTimer_CPUTime);
perf_get_meter("TestMeter", &aNbEnters, &aPerfMeter_CPUtime);
perf_init_meter("TestMeter");
Standard_Real aTimeDiff = (fabs(aTimer_ElapsedTime - aPerfMeter_CPUtime) / aTimer_ElapsedTime);
Standard_Real aTimeDiff = (fabs(aTimer_CPUTime - aPerfMeter_CPUtime) / aTimer_CPUTime);
printf("\nMeasurement results (%d cycles):\n", count);
printf("\nOSD_PerfMeter CPU time: %lf\nOSD_Timer elapsed time: %lf\n", aPerfMeter_CPUtime, aTimer_ElapsedTime);
printf("\nOSD_PerfMeter CPU time: %lf\nOSD_Timer CPU time: %lf\n",
aPerfMeter_CPUtime, aTimer_CPUTime);
printf("Time delta is: %.3lf %%\n", aTimeDiff * 100);
if (aTimeDiff > 0.2)
@ -2413,14 +2417,14 @@ static Standard_Integer OCC25043 (Draw_Interpretor& theDI,
}
else
{
theDI << "Info. Faulty shape if found in source shape\n";
theDI << "Info. Faulty shape is found in source shape\n";
}
}
}
}
else
{
theDI << "Error. Problems are not detected. Test is not performed.";
theDI << "Problems are not detected. Test is not performed.";
}
return 0;

2
tests/boolean/bopcut_2d/D5
View File

@ -1,5 +1,3 @@
puts "TODO #23876 ALL: Error: The command cannot be built"
restore [locate_data_file case_9_edge.brep] a
restore [locate_data_file case_9_wire3.brep] b
settolerance a 0.1

2
tests/boolean/bsection/M3
View File

@ -44,4 +44,4 @@ donly a_1 a_2
bsection result a_1 a_2
checkprops result -l 22.2575
checksection result
checksection result

4
tests/boolean/bsection/N2
View File

@ -1,9 +1,7 @@
puts "TODO #OCC26814 ALL: Error : The length of result shape is"
restore [locate_data_file lh3d_px1.brep] a
plane p 0 0 0 1 0 0
mkface f p
bsection result a f
checkprops result -l 20674.3
checkprops result -l 18981.2
checksection result

2
tests/boolean/bsection/R2
View File

@ -10,5 +10,5 @@ updatetolerance b 1
bsection result a b
checkprops result -l 135.096
checkprops result -l 130.625
checksection result

1
tests/boolean/gdml_private/B6
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_bat-nord.asm.4.gdml.tcl]

1
tests/boolean/gdml_private/C2
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_bat-nord_et2.asm.4.gdml.tcl]

1
tests/boolean/gdml_private/C6
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_bat-nord_et2_13302.prt.3.gdml.tcl]

1
tests/boolean/gdml_private/F6
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_et1_401-ta6025.prt.3.gdml.tcl]

2
tests/boolean/gdml_private/F8
View File

@ -1,4 +1,4 @@
source [locate_data_file 20000_et1_401-ta6027.prt.2.gdml.tcl]
## image is differ from application
checkprops result -s 1.26259e+07
checkprops result -s 1.50445e+007

2
tests/boolean/gdml_private/G1
View File

@ -1,3 +1,3 @@
puts "TODO OCC26018 Linux: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_et1_401-ta6029.prt.2.gdml.tcl]
checkprops result -s 1.0285e+007

4
tests/boolean/gdml_private/G7
View File

@ -1,6 +1,4 @@
puts "TODO OCC26018 ALL: Error : The area of result shape is"
#puts "TODO OCC26018 Linux: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_et3_401-ta6037.prt.2.gdml.tcl]
## image is differ from application
checkprops result -s 0
checkprops result -s 2.00593e+007

2
tests/boolean/gdml_private/H7
View File

@ -1,4 +1,2 @@
puts "TODO OCC26018 Linux: Faulty shapes in variables faulty_1 to"
source [locate_data_file 20000_et4_401-ta6049.prt.2.gdml.tcl]

5
tests/boolean/gdml_private/I6
View File

@ -1,6 +1,5 @@
puts "TODO OCC26018 Windows: Error : The area of result shape is"
puts "TODO OCC26018 Linux: Error : The command is not valid. The area is"
source [locate_data_file 20000_et4_401-ta6319.prt.2.gdml.tcl]
## image is differ from application
checkprops result -s 0
donly result
checkprops result -s empty

1
tests/boolean/gdml_private/J1
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_et5_401-ta6156.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/J4
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_et5_401-ta6160.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/M7
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et3.asm.2.gdml.tcl]

1
tests/boolean/gdml_private/N1
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et3_401-ta13450.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/N8
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et5.asm.2.gdml.tcl]

1
tests/boolean/gdml_private/N9
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et5_401-ta13428.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/O1
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Linux: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et5_401-ta13429.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/O3
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et5_401-ta13457.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/O4
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et6.asm.2.gdml.tcl]

1
tests/boolean/gdml_private/O6
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et6_401-ta13432.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/O8
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_et6_401-ta13460.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/O9
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_rdc.asm.3.gdml.tcl]

1
tests/boolean/gdml_private/P1
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_rdc_401-ta13415.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/P2
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_rdc_401-ta13416.prt.3.gdml.tcl]

1
tests/boolean/gdml_private/P5
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_ss1.asm.2.gdml.tcl]

1
tests/boolean/gdml_private/Q1
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_ss2.asm.2.gdml.tcl]

1
tests/boolean/gdml_private/Q3
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_ss2_401-ta13399.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/Q5
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_h1-2_ss2_401-ta13435.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/S9
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_rdc_401-ta6018.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/T2
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_salle-experience.asm.4.gdml.tcl]

1
tests/boolean/gdml_private/U4
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_ss1_401-ta6004.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/U5
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_ss1_401-ta6005.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/U9
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 20000_ss1_401-ta6009.prt.2.gdml.tcl]

1
tests/boolean/gdml_private/ZB5
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sid-deploye.asm.1.gdml.tcl]

1
tests/boolean/gdml_private/ZB6
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sid-retracte.asm.1.gdml.tcl]

1
tests/boolean/gdml_private/ZC1
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sid_ens-fixe.asm.1.gdml.tcl]

1
tests/boolean/gdml_private/ZC5
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sid_ens-fixe_vanne-tete.prt.1.gdml.tcl]

1
tests/boolean/gdml_private/ZD3
View File

@ -1,2 +1 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sopac-dn500.asm.1.gdml.tcl]

1
tests/boolean/gdml_private/ZD6
View File

@ -1,2 +1 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sopac-dn500_piquage.prt.1.gdml.tcl]

1
tests/boolean/gdml_private/ZD7
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 Windows: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 200a0-1_sopac-dn500_support.prt.1.gdml.tcl]

1
tests/boolean/gdml_private/ZH2
View File

@ -1,3 +1,2 @@
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to faulty_"
source [locate_data_file 51678_flame-sbr.prt.1.gdml.tcl]

2
tests/boolean/gdml_private/ZH5
View File

@ -1,5 +1,3 @@
puts "TODO ?OCC26018 ALL: Error: bopcheck failed"
puts "TODO OCC26018 ALL: Faulty shapes in variables faulty_1 to"
source [locate_data_file 52109_shapiro.prt.gdml.tcl]
set bcheck [bopcheck result]

Some files were not shown because too many files have changed in this diff Show More