X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Boolean.cpp;h=d3fcd0ba506dd41acd7efc5474a7b9b8c8da09d3;hb=95375993f1f35e4716475c0b0c8e265c082c875d;hp=7a765a11c74412b503e7a2a4f9235bd05dc85741;hpb=e65bf14e2ff3cf853884bf8998fadcece6e3b34c;p=modules%2Fshaper.git diff --git a/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp b/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp index 7a765a11c..d3fcd0ba5 100644 --- a/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp +++ b/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -12,10 +12,9 @@ // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or -// email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include "FeaturesPlugin_Boolean.h" @@ -24,7 +23,6 @@ #include #include #include -#include #include #include #include @@ -32,11 +30,14 @@ #include #include +#include #include #include #include #include +#include #include +#include #include #include #include @@ -64,683 +65,77 @@ void FeaturesPlugin_Boolean::initAttributes() ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), TOOL_LIST_ID()); } -//================================================================================================= -std::shared_ptr FeaturesPlugin_Boolean::getShape(const std::string& theAttrName) -{ - std::shared_ptr aObjRef = std::dynamic_pointer_cast< - ModelAPI_AttributeReference>(data()->attribute(theAttrName)); - if (aObjRef) { - std::shared_ptr aConstr = std::dynamic_pointer_cast< - ModelAPI_ResultBody>(aObjRef->value()); - if (aConstr) - return aConstr->shape(); - } - return std::shared_ptr(); -} - //================================================================================================= FeaturesPlugin_Boolean::OperationType FeaturesPlugin_Boolean::operationType() { return myOperationType; } -//================================================================================================= -void FeaturesPlugin_Boolean::execute() -{ - ListOfShape anObjects, aTools, anEdgesAndFaces, aPlanes; - std::map, ListOfShape> aCompSolidsObjects; - - // Getting objects. - AttributeSelectionListPtr anObjectsSelList = - selectionList(FeaturesPlugin_Boolean::OBJECT_LIST_ID()); - for(int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) { - AttributeSelectionPtr anObjectAttr = anObjectsSelList->value(anObjectsIndex); - std::shared_ptr anObject = anObjectAttr->value(); - if(!anObject.get()) { - return; - } - ResultPtr aContext = anObjectAttr->context(); - ResultCompSolidPtr aResCompSolidPtr = ModelAPI_Tools::compSolidOwner(aContext); - if(aResCompSolidPtr.get() - && aResCompSolidPtr->shape()->shapeType() == GeomAPI_Shape::COMPSOLID) { - std::shared_ptr aContextShape = aResCompSolidPtr->shape(); - std::map, ListOfShape>::iterator - anIt = aCompSolidsObjects.begin(); - for(; anIt != aCompSolidsObjects.end(); anIt++) { - if(anIt->first->isEqual(aContextShape)) { - aCompSolidsObjects[anIt->first].push_back(anObject); - break; - } - } - if(anIt == aCompSolidsObjects.end()) { - aCompSolidsObjects[aContextShape].push_back(anObject); - } - } else { - if(myOperationType != BOOL_FILL - && (anObject->shapeType() == GeomAPI_Shape::EDGE - || anObject->shapeType() == GeomAPI_Shape::FACE)) - { - anEdgesAndFaces.push_back(anObject); - } - else - { - anObjects.push_back(anObject); - } - } - } - - // Getting tools. - AttributeSelectionListPtr aToolsSelList = selectionList(FeaturesPlugin_Boolean::TOOL_LIST_ID()); - for(int aToolsIndex = 0; aToolsIndex < aToolsSelList->size(); aToolsIndex++) { - AttributeSelectionPtr aToolAttr = aToolsSelList->value(aToolsIndex); - GeomShapePtr aTool = aToolAttr->value(); - if(!aTool.get()) { - // It could be a construction plane. - ResultPtr aContext = aToolAttr->context(); - aPlanes.push_back(aToolAttr->context()->shape()); - } - else if (myOperationType != BOOL_FILL - && (aTool->shapeType() == GeomAPI_Shape::EDGE - || aTool->shapeType() == GeomAPI_Shape::FACE)) - { - anEdgesAndFaces.push_back(aTool); - } else { - aTools.push_back(aTool); - } - } - - int aResultIndex = 0; - - switch(myOperationType) { - case BOOL_CUT: - case BOOL_COMMON: - case BOOL_FILL: { - if((anObjects.empty() && aCompSolidsObjects.empty()) - || (aTools.empty() && aPlanes.empty())) { - std::string aFeatureError = "Error: Not enough objects for boolean operation."; - setError(aFeatureError); - return; - } - - // For solids cut each object with all tools. - for(ListOfShape::iterator - anObjectsIt = anObjects.begin(); anObjectsIt != anObjects.end(); anObjectsIt++) { - std::shared_ptr anObject = *anObjectsIt; - ListOfShape aListWithObject; - aListWithObject.push_back(anObject); - GeomAlgoAPI_MakeShapeList aMakeShapeList; - std::shared_ptr aBoolAlgo; - GeomShapePtr aResShape; - - switch(myOperationType) { - case BOOL_CUT: { - aBoolAlgo.reset(new GeomAlgoAPI_Boolean(aListWithObject, - aTools, - GeomAlgoAPI_Boolean::BOOL_CUT)); - aResShape = aBoolAlgo->shape(); - break; - } - case BOOL_COMMON: { - aBoolAlgo.reset(new GeomAlgoAPI_Boolean(aListWithObject, - aTools, - GeomAlgoAPI_Boolean::BOOL_COMMON)); - aResShape = aBoolAlgo->shape(); - break; - } - case BOOL_FILL: { - std::list > aBoundingPoints = - GeomAlgoAPI_ShapeTools::getBoundingBox(aListWithObject, 1.0); - - // Resize planes. - ListOfShape aToolsWithPlanes = aTools; - for(ListOfShape::const_iterator anIt = aPlanes.cbegin(); - anIt != aPlanes.cend(); - ++anIt) - { - GeomShapePtr aPlane = *anIt; - GeomShapePtr aTool = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPlane, aBoundingPoints); - std::shared_ptr aMkShCustom( - new GeomAlgoAPI_MakeShapeCustom); - aMkShCustom->addModified(aPlane, aTool); - aMakeShapeList.appendAlgo(aMkShCustom); - aToolsWithPlanes.push_back(aTool); - } - - aBoolAlgo.reset(new GeomAlgoAPI_Partition(aListWithObject, aToolsWithPlanes)); - aResShape = aBoolAlgo->shape(); - if(aResShape->shapeType() == GeomAPI_Shape::COMPOUND) { - int aSubResultsNb = 0; - GeomAPI_ShapeIterator anIt(aResShape); - for(; anIt.more(); anIt.next()) { - ++aSubResultsNb; - } - if(aSubResultsNb == 1) { - anIt.init(aResShape); - if(anIt.more()) { - aResShape = anIt.current(); - } - } - } - break; - } - } - - // Checking that the algorithm worked properly. - if(!aBoolAlgo->isDone()) { - static const std::string aFeatureError = "Error: Boolean algorithm failed."; - setError(aFeatureError); - return; - } - if(aResShape->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); - return; - } - if(!aBoolAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); - return; - } - - aMakeShapeList.appendAlgo(aBoolAlgo); - - if(GeomAlgoAPI_ShapeTools::volume(aResShape) > 1.e-27 - || (myOperationType != BOOL_CUT && myOperationType != BOOL_COMMON)) - { - std::shared_ptr aResultBody = - document()->createBody(data(), aResultIndex); - - ListOfShape aUsedTools = aTools; - if (myOperationType == BOOL_FILL) { - aUsedTools.insert(aUsedTools.end(), aPlanes.begin(), aPlanes.end()); - } - - loadNamingDS(aResultBody, anObject, aUsedTools, aResShape, - aMakeShapeList, *(aBoolAlgo->mapOfSubShapes()), - myOperationType == BOOL_FILL); - setResult(aResultBody, aResultIndex); - aResultIndex++; - } - } - - // Compsolids handling - for(std::map, ListOfShape>::iterator - anIt = aCompSolidsObjects.begin(); - anIt != aCompSolidsObjects.end(); anIt++) { - std::shared_ptr aCompSolid = anIt->first; - ListOfShape& aUsedInOperationSolids = anIt->second; - - // Collecting solids from compsolids which will not be modified in boolean operation. - ListOfShape aNotUsedSolids; - for(GeomAPI_ShapeExplorer - anExp(aCompSolid, GeomAPI_Shape::SOLID); anExp.more(); anExp.next()) { - std::shared_ptr aSolidInCompSolid = anExp.current(); - ListOfShape::iterator anIt = aUsedInOperationSolids.begin(); - for(; anIt != aUsedInOperationSolids.end(); anIt++) { - if(aSolidInCompSolid->isEqual(*anIt)) { - break; - } - } - if(anIt == aUsedInOperationSolids.end()) { - aNotUsedSolids.push_back(aSolidInCompSolid); - } - } - - GeomAlgoAPI_MakeShapeList aMakeShapeList; - std::shared_ptr aBoolAlgo; - - switch(myOperationType) { - case BOOL_CUT: { - aBoolAlgo.reset(new GeomAlgoAPI_Boolean(aUsedInOperationSolids, - aTools, - GeomAlgoAPI_Boolean::BOOL_CUT)); - break; - } - case BOOL_COMMON: { - aBoolAlgo.reset(new GeomAlgoAPI_Boolean(aUsedInOperationSolids, - aTools, - GeomAlgoAPI_Boolean::BOOL_COMMON)); - break; - } - case BOOL_FILL: { - std::list > aBoundingPoints = - GeomAlgoAPI_ShapeTools::getBoundingBox(aUsedInOperationSolids, 1.0); - - // Resize planes. - ListOfShape aToolsWithPlanes = aTools; - for(ListOfShape::const_iterator anIt = aPlanes.cbegin(); - anIt != aPlanes.cend(); - ++anIt) - { - GeomShapePtr aPlane = *anIt; - GeomShapePtr aTool = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPlane, aBoundingPoints); - std::shared_ptr aMkShCustom( - new GeomAlgoAPI_MakeShapeCustom); - aMkShCustom->addModified(aPlane, aTool); - aMakeShapeList.appendAlgo(aMkShCustom); - aToolsWithPlanes.push_back(aTool); - } - - aBoolAlgo.reset(new GeomAlgoAPI_Partition(aUsedInOperationSolids, aToolsWithPlanes)); - break; - } - } - - // Checking that the algorithm worked properly. - if(!aBoolAlgo->isDone()) { - static const std::string aFeatureError = "Error: Boolean algorithm failed."; - setError(aFeatureError); - return; - } - if(aBoolAlgo->shape()->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); - return; - } - if(!aBoolAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); - return; - } - - aMakeShapeList.appendAlgo(aBoolAlgo); - GeomAPI_DataMapOfShapeShape aMapOfShapes; - aMapOfShapes.merge(aBoolAlgo->mapOfSubShapes()); - GeomShapePtr aResultShape = aBoolAlgo->shape(); - - // Add result to not used solids from compsolid. - if(!aNotUsedSolids.empty()) { - ListOfShape aShapesToAdd = aNotUsedSolids; - aShapesToAdd.push_back(aBoolAlgo->shape()); - std::shared_ptr aFillerAlgo( - new GeomAlgoAPI_PaveFiller(aShapesToAdd, true)); - if(!aFillerAlgo->isDone()) { - std::string aFeatureError = "Error: PaveFiller algorithm failed."; - setError(aFeatureError); - return; - } - - aMakeShapeList.appendAlgo(aFillerAlgo); - aMapOfShapes.merge(aFillerAlgo->mapOfSubShapes()); - aResultShape = aFillerAlgo->shape(); - } - - if(GeomAlgoAPI_ShapeTools::volume(aResultShape) > 1.e-27 - || (myOperationType != BOOL_CUT && myOperationType != BOOL_COMMON)) - { - std::shared_ptr aResultBody = - document()->createBody(data(), aResultIndex); - - ListOfShape aUsedTools = aTools; - if (myOperationType == BOOL_FILL) { - aUsedTools.insert(aUsedTools.end(), aPlanes.begin(), aPlanes.end()); - } - - loadNamingDS(aResultBody, - aCompSolid, - aUsedTools, - aResultShape, - aMakeShapeList, - aMapOfShapes, - myOperationType == BOOL_FILL); - setResult(aResultBody, aResultIndex); - aResultIndex++; - } - } - break; - } - case BOOL_FUSE: { - if((anObjects.size() + aTools.size() + - aCompSolidsObjects.size() + anEdgesAndFaces.size()) < 2) { - std::string aFeatureError = "Error: Not enough objects for boolean operation."; - setError(aFeatureError); - return; - } - - // Collecting all solids which will be fused. - ListOfShape aSolidsToFuse; - aSolidsToFuse.insert(aSolidsToFuse.end(), anObjects.begin(), anObjects.end()); - aSolidsToFuse.insert(aSolidsToFuse.end(), aTools.begin(), aTools.end()); - - // Collecting solids from compsolids which will not be modified - // in boolean operation and will be added to result. - ListOfShape aShapesToAdd; - for(std::map, ListOfShape>::iterator - anIt = aCompSolidsObjects.begin(); - anIt != aCompSolidsObjects.end(); anIt++) { - std::shared_ptr aCompSolid = anIt->first; - ListOfShape& aUsedInOperationSolids = anIt->second; - aSolidsToFuse.insert(aSolidsToFuse.end(), aUsedInOperationSolids.begin(), - aUsedInOperationSolids.end()); - - // Collect solids from compsolid which will not be modified in boolean operation. - for(GeomAPI_ShapeExplorer - anExp(aCompSolid, GeomAPI_Shape::SOLID); anExp.more(); anExp.next()) { - std::shared_ptr aSolidInCompSolid = anExp.current(); - ListOfShape::iterator anIt = aUsedInOperationSolids.begin(); - for(; anIt != aUsedInOperationSolids.end(); anIt++) { - if(aSolidInCompSolid->isEqual(*anIt)) { - break; - } - } - if(anIt == aUsedInOperationSolids.end()) { - aShapesToAdd.push_back(aSolidInCompSolid); - } - } - } - - ListOfShape anOriginalShapes = aSolidsToFuse; - anOriginalShapes.insert(anOriginalShapes.end(), aShapesToAdd.begin(), aShapesToAdd.end()); - - // Cut edges and faces(if we have any) with solids. - GeomAlgoAPI_MakeShapeList aMakeShapeList; - GeomAPI_DataMapOfShapeShape aMapOfShapes; - std::shared_ptr aCuttedEdgesAndFaces; - if(!anEdgesAndFaces.empty()) { - std::shared_ptr aCutAlgo(new GeomAlgoAPI_Boolean(anEdgesAndFaces, - anOriginalShapes, GeomAlgoAPI_Boolean::BOOL_CUT)); - if(aCutAlgo->isDone()) { - aCuttedEdgesAndFaces = aCutAlgo->shape(); - aMakeShapeList.appendAlgo(aCutAlgo); - aMapOfShapes.merge(aCutAlgo->mapOfSubShapes()); - } - } - anOriginalShapes.insert(anOriginalShapes.end(), anEdgesAndFaces.begin(), - anEdgesAndFaces.end()); - - // If we have compsolids then cut with not used solids all others. - if(!aShapesToAdd.empty()) { - aSolidsToFuse.clear(); - for(ListOfShape::iterator - anIt = anOriginalShapes.begin(); anIt != anOriginalShapes.end(); anIt++) { - ListOfShape aOneObjectList; - aOneObjectList.push_back(*anIt); - std::shared_ptr aCutAlgo( - new GeomAlgoAPI_Boolean(aOneObjectList, aShapesToAdd, GeomAlgoAPI_Boolean::BOOL_CUT)); - - if(GeomAlgoAPI_ShapeTools::volume(aCutAlgo->shape()) > 1.e-27) { - aSolidsToFuse.push_back(aCutAlgo->shape()); - aMakeShapeList.appendAlgo(aCutAlgo); - aMapOfShapes.merge(aCutAlgo->mapOfSubShapes()); - } - } - } - - if(!aSolidsToFuse.empty()) { - anObjects.clear(); - anObjects.push_back(aSolidsToFuse.back()); - aSolidsToFuse.pop_back(); - aTools = aSolidsToFuse; - } - - // Fuse all objects and all tools. - std::shared_ptr aShape; - if(anObjects.size() == 1 && aTools.empty()) { - aShape = anObjects.front(); - } else if(anObjects.empty() && aTools.size() == 1) { - aShape = aTools.front(); - } else if((anObjects.size() + aTools.size()) > 1){ - std::shared_ptr aFuseAlgo(new GeomAlgoAPI_Boolean(anObjects, - aTools, - GeomAlgoAPI_Boolean::BOOL_FUSE)); - - // Checking that the algorithm worked properly. - if(!aFuseAlgo->isDone()) { - static const std::string aFeatureError = "Error: Boolean algorithm failed."; - setError(aFeatureError); - return; - } - if(aFuseAlgo->shape()->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); - return; - } - if(!aFuseAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); - return; - } - - aShape = aFuseAlgo->shape(); - aMakeShapeList.appendAlgo(aFuseAlgo); - aMapOfShapes.merge(aFuseAlgo->mapOfSubShapes()); - } - - // Combine result with not used solids from compsolid and edges and faces (if we have any). - if(aCuttedEdgesAndFaces.get() && !aCuttedEdgesAndFaces->isNull()) { - aShapesToAdd.push_back(aCuttedEdgesAndFaces); - } else { - aShapesToAdd.insert(aShapesToAdd.end(), anEdgesAndFaces.begin(), anEdgesAndFaces.end()); - } - if(!aShapesToAdd.empty()) { - if(aShape.get()) { - aShapesToAdd.push_back(aShape); - } - std::shared_ptr aFillerAlgo( - new GeomAlgoAPI_PaveFiller(aShapesToAdd, true)); - if(!aFillerAlgo->isDone()) { - std::string aFeatureError = "Error: PaveFiller algorithm failed."; - setError(aFeatureError); - return; - } - if(aFillerAlgo->shape()->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); - return; - } - if(!aFillerAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); - return; - } - - aShape = aFillerAlgo->shape(); - aMakeShapeList.appendAlgo(aFillerAlgo); - aMapOfShapes.merge(aFillerAlgo->mapOfSubShapes()); - } - - std::shared_ptr aBackShape = anOriginalShapes.back(); - anOriginalShapes.pop_back(); - std::shared_ptr aResultBody = - document()->createBody(data(), aResultIndex); - loadNamingDS(aResultBody, aBackShape, anOriginalShapes, - aShape, aMakeShapeList, aMapOfShapes); - setResult(aResultBody, aResultIndex); - aResultIndex++; - break; - } - case BOOL_SMASH: { - if((anObjects.empty() && aCompSolidsObjects.empty()) || aTools.empty()) { - std::string aFeatureError = "Error: Not enough objects for boolean operation."; - setError(aFeatureError); - return; - } - - // List of original solids for naming. - ListOfShape anOriginalShapes; - anOriginalShapes.insert(anOriginalShapes.end(), anObjects.begin(), anObjects.end()); - anOriginalShapes.insert(anOriginalShapes.end(), aTools.begin(), aTools.end()); - - // Collecting all solids which will be smashed. - ListOfShape aShapesToSmash; - aShapesToSmash.insert(aShapesToSmash.end(), anObjects.begin(), anObjects.end()); - - // Collecting solids from compsolids which will not be modified in - // boolean operation and will be added to result. - ListOfShape aShapesToAdd; - for(std::map, ListOfShape>::iterator - anIt = aCompSolidsObjects.begin(); - anIt != aCompSolidsObjects.end(); anIt++) { - std::shared_ptr aCompSolid = anIt->first; - ListOfShape& aUsedInOperationSolids = anIt->second; - anOriginalShapes.push_back(aCompSolid); - aShapesToSmash.insert(aShapesToSmash.end(), aUsedInOperationSolids.begin(), - aUsedInOperationSolids.end()); - - // Collect solids from compsolid which will not be modified in boolean operation. - for(GeomAPI_ShapeExplorer - anExp(aCompSolid, GeomAPI_Shape::SOLID); anExp.more(); anExp.next()) { - std::shared_ptr aSolidInCompSolid = anExp.current(); - ListOfShape::iterator anIt = aUsedInOperationSolids.begin(); - for(; anIt != aUsedInOperationSolids.end(); anIt++) { - if(aSolidInCompSolid->isEqual(*anIt)) { - break; - } - } - if(anIt == aUsedInOperationSolids.end()) { - aShapesToAdd.push_back(aSolidInCompSolid); - } - } - } - - GeomAlgoAPI_MakeShapeList aMakeShapeList; - GeomAPI_DataMapOfShapeShape aMapOfShapes; - if(!aShapesToAdd.empty()) { - // Cut objects with not used solids. - std::shared_ptr anObjectsCutAlgo(new GeomAlgoAPI_Boolean( - aShapesToSmash, - aShapesToAdd, - GeomAlgoAPI_Boolean::BOOL_CUT)); - - if(GeomAlgoAPI_ShapeTools::volume(anObjectsCutAlgo->shape()) > 1.e-27) { - aShapesToSmash.clear(); - aShapesToSmash.push_back(anObjectsCutAlgo->shape()); - aMakeShapeList.appendAlgo(anObjectsCutAlgo); - aMapOfShapes.merge(anObjectsCutAlgo->mapOfSubShapes()); - } - - // Cut tools with not used solids. - std::shared_ptr aToolsCutAlgo(new GeomAlgoAPI_Boolean(aTools, - aShapesToAdd, - GeomAlgoAPI_Boolean::BOOL_CUT)); - - if(GeomAlgoAPI_ShapeTools::volume(aToolsCutAlgo->shape()) > 1.e-27) { - aTools.clear(); - aTools.push_back(aToolsCutAlgo->shape()); - aMakeShapeList.appendAlgo(aToolsCutAlgo); - aMapOfShapes.merge(aToolsCutAlgo->mapOfSubShapes()); - } - } - - // Cut objects with tools. - std::shared_ptr aBoolAlgo(new GeomAlgoAPI_Boolean(aShapesToSmash, - aTools, - GeomAlgoAPI_Boolean::BOOL_CUT)); - - // Checking that the algorithm worked properly. - if(!aBoolAlgo->isDone()) { - static const std::string aFeatureError = "Error: Boolean algorithm failed."; - setError(aFeatureError); - return; - } - if(aBoolAlgo->shape()->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); - return; - } - if(!aBoolAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); - return; - } - aMakeShapeList.appendAlgo(aBoolAlgo); - aMapOfShapes.merge(aBoolAlgo->mapOfSubShapes()); - - // Put all (cut result, tools and not used solids) to PaveFiller. - aShapesToAdd.push_back(aBoolAlgo->shape()); - aShapesToAdd.insert(aShapesToAdd.end(), aTools.begin(), aTools.end()); - - std::shared_ptr aFillerAlgo(new GeomAlgoAPI_PaveFiller(aShapesToAdd, - true)); - if(!aFillerAlgo->isDone()) { - std::string aFeatureError = "Error: PaveFiller algorithm failed."; - setError(aFeatureError); - return; - } - if(aFillerAlgo->shape()->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); - return; - } - if(!aFillerAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); - return; - } - - std::shared_ptr aShape = aFillerAlgo->shape(); - aMakeShapeList.appendAlgo(aFillerAlgo); - aMapOfShapes.merge(aFillerAlgo->mapOfSubShapes()); - - std::shared_ptr aFrontShape = anOriginalShapes.front(); - anOriginalShapes.pop_front(); - std::shared_ptr aResultBody = - document()->createBody(data(), aResultIndex); - loadNamingDS(aResultBody, aFrontShape, anOriginalShapes, - aShape, aMakeShapeList, aMapOfShapes); - setResult(aResultBody, aResultIndex); - aResultIndex++; - - break; - } - default: { - std::string anOperationError = "Error: Wrong type of operation"; - setError(anOperationError); - return; - } - } - // remove the rest results if there were produced in the previous pass - removeResults(aResultIndex); -} - //================================================================================================= void FeaturesPlugin_Boolean::loadNamingDS(std::shared_ptr theResultBody, const std::shared_ptr theBaseShape, const ListOfShape& theTools, const std::shared_ptr theResultShape, - GeomAlgoAPI_MakeShape& theMakeShape, - GeomAPI_DataMapOfShapeShape& theMapOfShapes, - const bool theIsStoreAsGenerated) + const GeomMakeShapePtr& theMakeShape) { //load result if(theBaseShape->isEqual(theResultShape)) { theResultBody->store(theResultShape, false); - } else { - const int aModifyTag = 1; - const int aModifyEdgeTag = 2; - const int aModifyFaceTag = 3; - const int aDeletedTag = 4; - /// sub solids will be placed at labels 5, 6, etc. if result is compound of solids - const int aSubsolidsTag = 5; + return; + } - theResultBody->storeModified(theBaseShape, theResultShape, aSubsolidsTag); + theResultBody->storeModified(theBaseShape, theResultShape); - const std::string aModName = "Modified"; - const std::string aModEName = "Modified_Edge"; - const std::string aModFName = "Modified_Face"; + theResultBody->loadModifiedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::EDGE); + theResultBody->loadModifiedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::FACE); - theResultBody->loadAndOrientModifiedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::EDGE, - aModifyEdgeTag, aModEName, theMapOfShapes, false, theIsStoreAsGenerated, true); - theResultBody->loadAndOrientModifiedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::FACE, - aModifyFaceTag, aModFName, theMapOfShapes, false, theIsStoreAsGenerated, true); - theResultBody->loadDeletedShapes(&theMakeShape, theBaseShape, - GeomAPI_Shape::FACE, aDeletedTag); + theResultBody->loadDeletedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::FACE); - int aTag; - std::string aName; - for(ListOfShape::const_iterator - anIter = theTools.begin(); anIter != theTools.end(); anIter++) { - if((*anIter)->shapeType() <= GeomAPI_Shape::FACE) { - aTag = aModifyFaceTag; - aName = aModFName; - } else { - aTag = aModifyEdgeTag; - aName = aModEName; - } - theResultBody->loadAndOrientModifiedShapes(&theMakeShape, *anIter, - aName == aModEName ? GeomAPI_Shape::EDGE : GeomAPI_Shape::FACE, - aTag, aName, theMapOfShapes, false, theIsStoreAsGenerated, true); - theResultBody->loadDeletedShapes(&theMakeShape, *anIter, GeomAPI_Shape::FACE, aDeletedTag); - } + for (ListOfShape::const_iterator anIter = theTools.begin(); + anIter != theTools.end(); + ++anIter) + { + GeomAPI_Shape::ShapeType aShapeType = + (*anIter)->shapeType() <= GeomAPI_Shape::FACE ? GeomAPI_Shape::FACE + : GeomAPI_Shape::EDGE; + theResultBody->loadModifiedShapes(theMakeShape, *anIter, aShapeType); + + theResultBody->loadDeletedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE); + } +} + +//================================================================================================= +void FeaturesPlugin_Boolean::storeResult( + const ListOfShape& theObjects, + const ListOfShape& theTools, + const GeomShapePtr theResultShape, + int& theResultIndex, + std::shared_ptr theMakeShapeList, + std::vector& theResultBaseAlgoList) +{ + if (!theResultShape) + return; + + std::shared_ptr aResultBody = + document()->createBody(data(), theResultIndex); + + FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, + theObjects, + theTools, + theMakeShapeList, + theResultShape); + setResult(aResultBody, theResultIndex++); + + // merge algorithms + FeaturesPlugin_Tools::ResultBaseAlgo aRBA; + aRBA.resultBody = aResultBody; + aRBA.baseShape = theObjects.front(); + for (std::vector::iterator + aRBAIt = theResultBaseAlgoList.begin(); + aRBAIt != theResultBaseAlgoList.end(); ++aRBAIt) { + theMakeShapeList->appendAlgo(aRBAIt->makeShape); } + aRBA.makeShape = theMakeShapeList; + theResultBaseAlgoList.clear(); + theResultBaseAlgoList.push_back(aRBA); }