OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00
Code Activity

0030386: Modeling Algorithms - Unable to perform Cut operation

Browse Source 
Get rid of requirement for the arguments of Boolean operations of type CUT and COMMON to be one-dimensional shape. For FUSE operation this requirement is kept.
This commit is contained in:
emv
2020-02-21 18:19:03 +03:00
committed by bugmaster
parent f732ea1ab5
commit 739c7e5968
18 changed files with 365 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
src/BOPAlgo/BOPAlgo_ArgumentAnalyzer.cxx
View File

@@ -305,30 +305,27 @@ void BOPAlgo_ArgumentAnalyzer::TestTypes()
return;
}
//
Standard_Integer aDim1, aDim2;
Standard_Boolean bBadTypes = Standard_False;
//
aDim1 = BOPTools_AlgoTools::Dimension(myShape1);
aDim2 = BOPTools_AlgoTools::Dimension(myShape2);
if (aDim1 < aDim2) {
if (myOperation == BOPAlgo_FUSE ||
myOperation == BOPAlgo_CUT21) {
bBadTypes = Standard_True;
if (myOperation != BOPAlgo_UNKNOWN &&
myOperation != BOPAlgo_COMMON)
{
Standard_Integer iDimMin[2], iDimMax[2];
BOPTools_AlgoTools::Dimensions(myShape1, iDimMin[0], iDimMax[0]);
BOPTools_AlgoTools::Dimensions(myShape2, iDimMin[1], iDimMax[1]);
Standard_Boolean bBadTypes =
((myOperation == BOPAlgo_FUSE) &&
(iDimMin[0] != iDimMax[0] || iDimMin[1] != iDimMax[1] || iDimMin[0] != iDimMin[1])) ||
((myOperation == BOPAlgo_CUT) && (iDimMax[0] > iDimMin[1])) ||
((myOperation == BOPAlgo_CUT21) && (iDimMin[0] < iDimMax[1]));
if (bBadTypes) {
BOPAlgo_CheckResult aResult;
aResult.SetShape1(myShape1);
aResult.SetShape2(myShape2);
aResult.SetCheckStatus(BOPAlgo_BadType);
myResult.Append(aResult);
}
}
else if (aDim1 > aDim2) {
if (myOperation == BOPAlgo_FUSE ||
myOperation == BOPAlgo_CUT) {
bBadTypes = Standard_True;
}
}
if (bBadTypes) {
BOPAlgo_CheckResult aResult;
aResult.SetShape1(myShape1);
aResult.SetShape2(myShape2);
aResult.SetCheckStatus(BOPAlgo_BadType);
myResult.Append(aResult);
}
}
}
//=======================================================================

61
src/BOPAlgo/BOPAlgo_BOP.cxx
View File

@@ -122,7 +122,7 @@ BOPAlgo_Operation BOPAlgo_BOP::Operation()const
//=======================================================================
void BOPAlgo_BOP::CheckData()
{
Standard_Integer i, j, iDim, aNbArgs, aNbTools;
Standard_Integer i, j, aNbArgs, aNbTools;
Standard_Boolean bFuse;
TopTools_ListIteratorOfListOfShape aItLS;
//
@@ -164,7 +164,8 @@ void BOPAlgo_BOP::CheckData()
// or equal to the MAXIMAL dimension of the TOOLS;
// 4. COMMON: The arguments and tools could have any dimensions.
//
Standard_Integer iDimMin[2] = { 0, 0 }, iDimMax[2] = { 0, 0 };
Standard_Integer iDimMin[2] = { 3, 3 },
iDimMax[2] = { 0, 0 };
Standard_Boolean bHasValid[2] = {Standard_False, Standard_False};
//
for (i=0; i<2; ++i) {
@@ -173,38 +174,27 @@ void BOPAlgo_BOP::CheckData()
for (j=0; aItLS.More(); aItLS.Next(), ++j) {
const TopoDS_Shape& aS=aItLS.Value();
Standard_Boolean bIsEmpty = BOPTools_AlgoTools3D::IsEmptyShape(aS);
if (bIsEmpty) {
if (bIsEmpty)
{
AddWarning(new BOPAlgo_AlertEmptyShape (aS));
continue;
}
//
iDim = BOPTools_AlgoTools::Dimension(aS);
if (iDim < 0) {
Standard_Integer iDMin, iDMax;
BOPTools_AlgoTools::Dimensions(aS, iDMin, iDMax);
if (iDMin < iDimMin[i])
iDimMin[i] = iDMin;
if (iDMax > iDimMax[i])
iDimMax[i] = iDMax;
if (bFuse && (iDimMin[i] != iDimMax[i]))
{
// non-homogeneous argument
AddError (new BOPAlgo_AlertBOPNotAllowed);
return;
}
//
bHasValid[i] = Standard_True;
//
if (!j) {
iDimMin[i] = iDim;
iDimMax[i] = iDim;
continue;
}
//
if (iDim < iDimMin[i]) {
iDimMin[i] = iDim;
}
else if (iDim > iDimMax[i]) {
iDimMax[i] = iDim;
}
//
if (bFuse && (iDimMin[i] != iDimMax[i])) {
// non-homogeneous argument
AddError (new BOPAlgo_AlertBOPNotAllowed);
return;
}
}
}
//
@@ -222,7 +212,7 @@ void BOPAlgo_BOP::CheckData()
if (bHasValid[0] || bHasValid[1])
{
// In case of all empty shapes in one of the groups
// this group aquires the dimension of other group
// this group acquires the dimension of other group
myDims[0] = bHasValid[0] ? iDimMin[0] : iDimMin[1];
myDims[1] = bHasValid[1] ? iDimMin[1] : iDimMin[0];
}
@@ -583,12 +573,17 @@ void BOPAlgo_BOP::BuildRC()
aItLS.Initialize(aLS);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aS = aItLS.Value();
iDim = BOPTools_AlgoTools::Dimension(aS);
if (iDim < 0) {
continue;
TopTools_ListOfShape aList;
BOPTools_AlgoTools::TreatCompound (aS, aList);
for (TopTools_ListOfShape::Iterator itList (aList); itList.More(); itList.Next())
{
const TopoDS_Shape& aSS = itList.Value();
iDim = BOPTools_AlgoTools::Dimension (aSS);
if (iDim < 0)
continue;
aType = TypeToExplore (iDim);
TopExp::MapShapes (aSS, aType, aMS);
}
aType = TypeToExplore(iDim);
TopExp::MapShapes(aS, aType, aMS);
}
}
//
@@ -930,7 +925,7 @@ void BOPAlgo_BOP::BuildShape()
for (; aItLS.More(); aItLS.Next())
{
const TopoDS_Shape& aS = aItLS.Value();
BOPAlgo_Tools::TreatCompound(aS, aMInpFence, aLSNonCont);
BOPTools_AlgoTools::TreatCompound(aS, aLSNonCont, &aMInpFence);
}
}

2
src/BOPAlgo/BOPAlgo_Builder.cxx
View File

@@ -441,7 +441,7 @@ void BOPAlgo_Builder::BuildBOP(const TopTools_ListOfShape& theObjects,
{
TopTools_ListOfShape aLS;
TopTools_MapOfShape aMFence;
BOPAlgo_Tools::TreatCompound(aS, aMFence, aLS);
BOPTools_AlgoTools::TreatCompound(aS, aLS, &aMFence);
TopTools_ListOfShape::Iterator it(aLS);
for (; it.More(); it.Next())

2
src/BOPAlgo/BOPAlgo_Builder_3.cxx
View File

@@ -550,7 +550,7 @@ void BOPAlgo_Builder::FillInternalShapes()
aIt.Initialize(aArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
BOPAlgo_Tools::TreatCompound(aS, aMFence, aLSC);
BOPTools_AlgoTools::TreatCompound(aS, aLSC, &aMFence);
}
aIt.Initialize(aLSC);
for (; aIt.More(); aIt.Next()) {

78
src/BOPAlgo/BOPAlgo_CellsBuilder.cxx
View File

@@ -141,44 +141,50 @@ void BOPAlgo_CellsBuilder::IndexParts()
TopTools_ListIteratorOfListOfShape aIt(myArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
//
Standard_Integer iDim = BOPTools_AlgoTools::Dimension(aS);
aMDims.Add(iDim);
TopAbs_ShapeEnum aType = TypeToExplore(iDim);
//
TopExp_Explorer aExp(aS, aType);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aST = aExp.Current();
const TopTools_ListOfShape* pLSIm = myImages.Seek(aST);
if (!pLSIm) {
TopTools_ListOfShape* pLS = myIndex.ChangeSeek(aST);
if (!pLS) {
pLS = &myIndex(myIndex.Add(aST, TopTools_ListOfShape()));
}
pLS->Append(aS);
//
if (aMFence.Add(aST)) {
aBB.Add(anAllParts, aST);
TopTools_ListOfShape aLSubS;
BOPTools_AlgoTools::TreatCompound (aS, aLSubS);
for (TopTools_ListOfShape::Iterator itSub (aLSubS); itSub.More(); itSub.Next())
{
const TopoDS_Shape& aSS = itSub.Value();
Standard_Integer iDim = BOPTools_AlgoTools::Dimension (aSS);
aMDims.Add(iDim);
TopAbs_ShapeEnum aType = TypeToExplore (iDim);
TopExp_Explorer aExp (aSS, aType);
for (; aExp.More(); aExp.Next())
{
const TopoDS_Shape& aST = aExp.Current();
const TopTools_ListOfShape* pLSIm = myImages.Seek(aST);
if (!pLSIm) {
TopTools_ListOfShape* pLS = myIndex.ChangeSeek(aST);
if (!pLS) {
pLS = &myIndex(myIndex.Add(aST, TopTools_ListOfShape()));
}
pLS->Append(aS);
//
if (aMFence.Add(aST)) {
aBB.Add(anAllParts, aST);
}
//
continue;
}
//
continue;
}
//
TopTools_ListIteratorOfListOfShape aItIm(*pLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSTIm = aItIm.Value();
//
TopTools_ListOfShape* pLS = myIndex.ChangeSeek(aSTIm);
if (!pLS) {
pLS = &myIndex(myIndex.Add(aSTIm, TopTools_ListOfShape()));
}
pLS->Append(aS);
//
if (aMFence.Add(aSTIm)) {
aBB.Add(anAllParts, aSTIm);
}
} // for (; aItIm.More(); aItIm.Next()) {
} // for (; aExp.More(); aExp.Next()) {
TopTools_ListIteratorOfListOfShape aItIm(*pLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSTIm = aItIm.Value();
//
TopTools_ListOfShape* pLS = myIndex.ChangeSeek(aSTIm);
if (!pLS) {
pLS = &myIndex(myIndex.Add(aSTIm, TopTools_ListOfShape()));
}
pLS->Append(aS);
//
if (aMFence.Add(aSTIm)) {
aBB.Add(anAllParts, aSTIm);
}
} // for (; aItIm.More(); aItIm.Next()) {
} // for (; aExp.More(); aExp.Next()) {
} // for (; itSub.More(); itSub.Next())
} // for (; aIt.More(); aIt.Next()) {
//
myAllParts = anAllParts;

4
src/BOPAlgo/BOPAlgo_MakeConnected.cxx
View File

@@ -75,7 +75,7 @@ void BOPAlgo_MakeConnected::CheckData()
TopTools_ListIteratorOfListOfShape itLA(myArguments);
for (; itLA.More(); itLA.Next())
BOPAlgo_Tools::TreatCompound(itLA.Value(), aMFence, aLA);
BOPTools_AlgoTools::TreatCompound(itLA.Value(), aLA, &aMFence);
if (aLA.IsEmpty())
{
@@ -197,7 +197,7 @@ void BOPAlgo_MakeConnected::AssociateMaterials()
// Extract all non-compound shapes from the result
TopTools_ListOfShape aLShapes;
TopTools_MapOfShape aMFence;
BOPAlgo_Tools::TreatCompound(myShape, aMFence, aLShapes);
BOPTools_AlgoTools::TreatCompound(myShape, aLShapes, &aMFence);
if (aLShapes.IsEmpty())
return;

2
src/BOPAlgo/BOPAlgo_MakerVolume.cxx
View File

@@ -342,7 +342,7 @@ void BOPAlgo_MakerVolume::FillInternalShapes(const TopTools_ListOfShape& theLSR)
TopTools_ListOfShape::Iterator itLA(myDS->Arguments());
for (; itLA.More(); itLA.Next())
BOPAlgo_Tools::TreatCompound(itLA.Value(), aMFence, aLSC);
BOPTools_AlgoTools::TreatCompound(itLA.Value(), aLSC, &aMFence);
// Get only edges and vertices from arguments
TopTools_ListOfShape aLVE;

2
src/BOPAlgo/BOPAlgo_RemoveFeatures.cxx
View File

@@ -181,7 +181,7 @@ void BOPAlgo_RemoveFeatures::CheckData()
TopTools_ListOfShape aShapes;
TopTools_MapOfShape aMFence;
// Extract all shapes from the compound
BOPAlgo_Tools::TreatCompound(myInputShape, aMFence, aShapes);
BOPTools_AlgoTools::TreatCompound(myInputShape, aShapes, &aMFence);
if (aShapes.IsEmpty())
{
// Add error of empty input shape

23
src/BOPAlgo/BOPAlgo_Tools.cxx
View File

@@ -1103,29 +1103,6 @@ void BOPAlgo_Tools::IntersectVertices(const TopTools_IndexedDataMapOfShapeReal&
}
}
//=======================================================================
//function : TreatCompound
//purpose :
//=======================================================================
void BOPAlgo_Tools::TreatCompound(const TopoDS_Shape& theS,
TopTools_MapOfShape& aMFence,
TopTools_ListOfShape& theLS)
{
TopAbs_ShapeEnum aType = theS.ShapeType();
if (aType != TopAbs_COMPOUND)
{
if (aMFence.Add(theS))
theLS.Append(theS);
return;
}
TopoDS_Iterator aIt(theS);
for (; aIt.More(); aIt.Next())
{
const TopoDS_Shape& aS = aIt.Value();
TreatCompound(aS, aMFence, theLS);
}
}
//=======================================================================
// Classification of the faces relatively solids
//=======================================================================

7
src/BOPAlgo/BOPAlgo_Tools.hxx
View File

@@ -165,13 +165,6 @@ public:
const Standard_Real theFuzzyValue,
TopTools_ListOfListOfShape& theChains);
//! Collect in the output list recursively all non-compound subshapes of the first level
//! of the given shape theS. If a shape presents in the map theMFence it is skipped.
//! All shapes put in the output are also added into theMFence.
Standard_EXPORT static void TreatCompound(const TopoDS_Shape& theS,
TopTools_MapOfShape& theMFence,
TopTools_ListOfShape& theLS);
//! Classifies the faces <theFaces> relatively solids <theSolids>.
//! The IN faces for solids are stored into output data map <theInParts>.
//!