X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Boolean.cpp;h=63a7834b008c638ce8d1285f03fc9ff96b4dcdb0;hb=65fb6fac9731831e7197d0841e4444e69eb7d7ce;hp=6a9e9392910deaa12c63215ad17528248acb242a;hpb=2a232230cb243c76c34315623d6e6689f57e83f4;p=modules%2Fshaper.git diff --git a/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp b/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp index 6a9e93929..63a7834b0 100644 --- a/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp +++ b/src/FeaturesPlugin/FeaturesPlugin_Boolean.cpp @@ -1,8 +1,22 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D --> - -// File: FeaturesPlugin_Boolean.cpp -// Created: 02 Sept 2014 -// Author: Vitaly SMETANNIKOV +// Copyright (C) 2014-2017 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 +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// 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 +// +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com +// #include "FeaturesPlugin_Boolean.h" @@ -17,33 +31,33 @@ #include #include +#include #include +#include #include #include +#include #include +#include #include +#include //================================================================================================= -FeaturesPlugin_Boolean::FeaturesPlugin_Boolean() +FeaturesPlugin_Boolean::FeaturesPlugin_Boolean(const OperationType theOperationType) +: myOperationType(theOperationType) { } //================================================================================================= void FeaturesPlugin_Boolean::initAttributes() { - data()->addAttribute(FeaturesPlugin_Boolean::TYPE_ID(), ModelAPI_AttributeInteger::typeId()); - - AttributeSelectionListPtr aSelection = + AttributeSelectionListPtr aSelection = std::dynamic_pointer_cast(data()->addAttribute( FeaturesPlugin_Boolean::OBJECT_LIST_ID(), ModelAPI_AttributeSelectionList::typeId())); - // extrusion works with faces always - aSelection->setSelectionType("SOLID"); aSelection = std::dynamic_pointer_cast(data()->addAttribute( FeaturesPlugin_Boolean::TOOL_LIST_ID(), ModelAPI_AttributeSelectionList::typeId())); - // extrusion works with faces always - aSelection->setSelectionType("SOLID"); ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), OBJECT_LIST_ID()); ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), TOOL_LIST_ID()); @@ -64,20 +78,20 @@ std::shared_ptr FeaturesPlugin_Boolean::getShape(const std::strin } //================================================================================================= -void FeaturesPlugin_Boolean::execute() +FeaturesPlugin_Boolean::OperationType FeaturesPlugin_Boolean::operationType() { - // Getting operation type. - std::shared_ptr aTypeAttr = std::dynamic_pointer_cast< - ModelAPI_AttributeInteger>(data()->attribute(FeaturesPlugin_Boolean::TYPE_ID())); - if (!aTypeAttr) - return; - GeomAlgoAPI_Boolean::OperationType aType = (GeomAlgoAPI_Boolean::OperationType)aTypeAttr->value(); + return myOperationType; +} - ListOfShape anObjects, aTools; +//================================================================================================= +void FeaturesPlugin_Boolean::execute() +{ + ListOfShape anObjects, aTools, anEdgesAndFaces, aPlanes; std::map, ListOfShape> aCompSolidsObjects; // Getting objects. - AttributeSelectionListPtr anObjectsSelList = selectionList(FeaturesPlugin_Boolean::OBJECT_LIST_ID()); + 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(); @@ -85,10 +99,12 @@ void FeaturesPlugin_Boolean::execute() return; } ResultPtr aContext = anObjectAttr->context(); - ResultCompSolidPtr aResCompSolidPtr = ModelAPI_Tools::compSolidOwner(aContext); - if(aResCompSolidPtr.get()) { + ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext); + if(aResCompSolidPtr.get() + && aResCompSolidPtr->shape()->shapeType() == GeomAPI_Shape::COMPSOLID) { std::shared_ptr aContextShape = aResCompSolidPtr->shape(); - std::map, ListOfShape>::iterator anIt = aCompSolidsObjects.begin(); + std::map, ListOfShape>::iterator + anIt = aCompSolidsObjects.begin(); for(; anIt != aCompSolidsObjects.end(); anIt++) { if(anIt->first->isEqual(aContextShape)) { aCompSolidsObjects[anIt->first].push_back(anObject); @@ -99,7 +115,16 @@ void FeaturesPlugin_Boolean::execute() aCompSolidsObjects[aContextShape].push_back(anObject); } } else { - anObjects.push_back(anObject); + if(myOperationType != BOOL_FILL + && (anObject->shapeType() == GeomAPI_Shape::EDGE + || anObject->shapeType() == GeomAPI_Shape::FACE)) + { + anEdgesAndFaces.push_back(anObject); + } + else + { + anObjects.push_back(anObject); + } } } @@ -107,65 +132,145 @@ void FeaturesPlugin_Boolean::execute() AttributeSelectionListPtr aToolsSelList = selectionList(FeaturesPlugin_Boolean::TOOL_LIST_ID()); for(int aToolsIndex = 0; aToolsIndex < aToolsSelList->size(); aToolsIndex++) { AttributeSelectionPtr aToolAttr = aToolsSelList->value(aToolsIndex); - std::shared_ptr aTool = aToolAttr->value(); + GeomShapePtr aTool = aToolAttr->value(); if(!aTool.get()) { - return; + // 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); } - aTools.push_back(aTool); } int aResultIndex = 0; - switch(aType) { - case GeomAlgoAPI_Boolean::BOOL_CUT: - case GeomAlgoAPI_Boolean::BOOL_COMMON:{ - if((anObjects.empty() && aCompSolidsObjects.empty()) || aTools.empty()) { - std::string aFeatureError = "Not enough objects for boolean operation"; + 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++) { + for(ListOfShape::iterator + anObjectsIt = anObjects.begin(); anObjectsIt != anObjects.end(); anObjectsIt++) { std::shared_ptr anObject = *anObjectsIt; ListOfShape aListWithObject; aListWithObject.push_back(anObject); - GeomAlgoAPI_Boolean aBoolAlgo(aListWithObject, aTools, aType); + std::shared_ptr aMakeShapeList(new GeomAlgoAPI_MakeShapeList()); + 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.get() && 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 = "Boolean algorithm failed"; + if(!aBoolAlgo->isDone()) { + static const std::string aFeatureError = "Error: Boolean algorithm failed."; setError(aFeatureError); return; } - if(aBoolAlgo.shape()->isNull()) { - static const std::string aShapeError = "Resulting shape is Null"; + if(aResShape->isNull()) { + static const std::string aShapeError = "Error: Resulting shape is Null."; setError(aShapeError); return; } - if(!aBoolAlgo.isValid()) { - std::string aFeatureError = "Warning: resulting shape is not valid"; + if(!aBoolAlgo->isValid()) { + std::string aFeatureError = "Error: Resulting shape is not valid."; setError(aFeatureError); return; } - if(GeomAlgoAPI_ShapeTools::volume(aBoolAlgo.shape()) > 1.e-7) { - std::shared_ptr aResultBody = document()->createBody(data(), aResultIndex); - loadNamingDS(aResultBody, anObject, aTools, aBoolAlgo.shape(), *aBoolAlgo.makeShape(), *aBoolAlgo.mapOfShapes()); + 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); setResult(aResultBody, aResultIndex); aResultIndex++; } } // Compsolids handling - for(std::map, ListOfShape>::iterator anIt = aCompSolidsObjects.begin(); - anIt != aCompSolidsObjects.end(); anIt++) { + 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()) { + 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++) { @@ -178,55 +283,108 @@ void FeaturesPlugin_Boolean::execute() } } - GeomAlgoAPI_Boolean aBoolAlgo(aUsedInOperationSolids, aTools, aType); + std::shared_ptr aMakeShapeList(new GeomAlgoAPI_MakeShapeList()); + 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 = "Boolean algorithm failed"; + if(!aBoolAlgo->isDone()) { + static const std::string aFeatureError = "Error: Boolean algorithm failed."; setError(aFeatureError); return; } - if(aBoolAlgo.shape()->isNull()) { - static const std::string aShapeError = "Resulting shape is Null"; + if(aBoolAlgo->shape()->isNull()) { + static const std::string aShapeError = "Error: Resulting shape is Null."; setError(aShapeError); return; } - if(!aBoolAlgo.isValid()) { - std::string aFeatureError = "Warning: resulting shape is not valid"; + if(!aBoolAlgo->isValid()) { + std::string aFeatureError = "Error: Resulting shape is not valid."; setError(aFeatureError); return; } - GeomAlgoAPI_MakeShapeList aMakeShapeList; - aMakeShapeList.appendAlgo(aBoolAlgo.makeShape()); - GeomAPI_DataMapOfShapeShape aMapOfShapes; - aMapOfShapes.merge(aBoolAlgo.mapOfShapes()); + aMakeShapeList->appendAlgo(aBoolAlgo); + GeomShapePtr aResultShape = aBoolAlgo->shape(); // Add result to not used solids from compsolid. - ListOfShape aShapesToAdd = aNotUsedSolids; - aShapesToAdd.push_back(aBoolAlgo.shape()); - GeomAlgoAPI_PaveFiller aFillerAlgo(aShapesToAdd, true); - if(!aFillerAlgo.isDone()) { - std::string aFeatureError = "PaveFiller algorithm failed"; - setError(aFeatureError); - return; + 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); + aResultShape = aFillerAlgo->shape(); } - aMakeShapeList.appendAlgo(aFillerAlgo.makeShape()); - aMapOfShapes.merge(aFillerAlgo.mapOfShapes()); + 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()); + } - if(GeomAlgoAPI_ShapeTools::volume(aFillerAlgo.shape()) > 1.e-7) { - std::shared_ptr aResultBody = document()->createBody(data(), aResultIndex); - loadNamingDS(aResultBody, aCompSolid, aTools, aFillerAlgo.shape(), aMakeShapeList, aMapOfShapes); + loadNamingDS(aResultBody, + aCompSolid, + aUsedTools, + aResultShape, + aMakeShapeList); setResult(aResultBody, aResultIndex); aResultIndex++; } } break; } - case GeomAlgoAPI_Boolean::BOOL_FUSE: { - if((anObjects.size() + aTools.size() + aCompSolidsObjects.size()) < 2) { - std::string aFeatureError = "Not enough objects for boolean operation"; + 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; } @@ -236,16 +394,20 @@ void FeaturesPlugin_Boolean::execute() 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. - ListOfShape aNotUsedSolids; - for(std::map, ListOfShape>::iterator anIt = aCompSolidsObjects.begin(); - anIt != aCompSolidsObjects.end(); anIt++) { + // 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()); + 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()) { + 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++) { @@ -254,94 +416,256 @@ void FeaturesPlugin_Boolean::execute() } } if(anIt == aUsedInOperationSolids.end()) { - aNotUsedSolids.push_back(aSolidInCompSolid); + aShapesToAdd.push_back(aSolidInCompSolid); } } } - ListOfShape anOriginalSolids = aSolidsToFuse; - anOriginalSolids.insert(anOriginalSolids.end(), aNotUsedSolids.begin(), aNotUsedSolids.end()); - GeomAlgoAPI_MakeShapeList aMakeShapeList; - GeomAPI_DataMapOfShapeShape aMapOfShapes; + ListOfShape anOriginalShapes = aSolidsToFuse; + anOriginalShapes.insert(anOriginalShapes.end(), aShapesToAdd.begin(), aShapesToAdd.end()); + + // Cut edges and faces(if we have any) with solids. + std::shared_ptr aMakeShapeList(new GeomAlgoAPI_MakeShapeList()); + 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); + } + } + anOriginalShapes.insert(anOriginalShapes.end(), anEdgesAndFaces.begin(), + anEdgesAndFaces.end()); // If we have compsolids then cut with not used solids all others. - if(!aNotUsedSolids.empty()) { + if(!aShapesToAdd.empty()) { aSolidsToFuse.clear(); - for(ListOfShape::iterator anIt = anOriginalSolids.begin(); anIt != anOriginalSolids.end(); anIt++) { + for(ListOfShape::iterator + anIt = anOriginalShapes.begin(); anIt != anOriginalShapes.end(); anIt++) { ListOfShape aOneObjectList; aOneObjectList.push_back(*anIt); - GeomAlgoAPI_Boolean aCutAlgo(aOneObjectList, aNotUsedSolids, GeomAlgoAPI_Boolean::BOOL_CUT); + std::shared_ptr aCutAlgo( + new GeomAlgoAPI_Boolean(aOneObjectList, aShapesToAdd, GeomAlgoAPI_Boolean::BOOL_CUT)); - if(GeomAlgoAPI_ShapeTools::volume(aCutAlgo.shape()) > 1.e-7) { - aSolidsToFuse.push_back(aCutAlgo.shape()); - aMakeShapeList.appendAlgo(aCutAlgo.makeShape()); - aMapOfShapes.merge(aCutAlgo.mapOfShapes()); + if(GeomAlgoAPI_ShapeTools::volume(aCutAlgo->shape()) > 1.e-27) { + aSolidsToFuse.push_back(aCutAlgo->shape()); + aMakeShapeList->appendAlgo(aCutAlgo); } } } - anObjects.clear(); - anObjects.push_back(aSolidsToFuse.back()); - aSolidsToFuse.pop_back(); - aTools = aSolidsToFuse; + if(!aSolidsToFuse.empty()) { + anObjects.clear(); + anObjects.push_back(aSolidsToFuse.back()); + aSolidsToFuse.pop_back(); + aTools = aSolidsToFuse; + } // Fuse all objects and all tools. - GeomAlgoAPI_Boolean aFuseAlgo(anObjects, aTools, aType); + 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 = "Boolean algorithm failed"; - setError(aFeatureError); - return; - } - if(aFuseAlgo.shape()->isNull()) { - static const std::string aShapeError = "Resulting shape is Null"; - setError(aShapeError); - return; - } - if(!aFuseAlgo.isValid()) { - std::string aFeatureError = "Warning: resulting shape is not valid"; - setError(aFeatureError); - return; - } + // 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; + } - std::shared_ptr aShape = aFuseAlgo.shape(); - aMakeShapeList.appendAlgo(aFuseAlgo.makeShape()); - aMapOfShapes.merge(aFuseAlgo.mapOfShapes()); + aShape = aFuseAlgo->shape(); + aMakeShapeList->appendAlgo(aFuseAlgo); + } - // Add result to not used solids from compsolid (if we have any). - if(!aNotUsedSolids.empty()) { - aNotUsedSolids.push_back(aShape); - GeomAlgoAPI_PaveFiller aFillerAlgo(aNotUsedSolids, true); - if(!aFillerAlgo.isDone()) { - std::string aFeatureError = "PaveFiller algorithm failed"; + // 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 = "Resulting shape is Null"; + if(aFillerAlgo->shape()->isNull()) { + static const std::string aShapeError = "Error: Resulting shape is Null."; setError(aShapeError); return; } - if(!aFillerAlgo.isValid()) { - std::string aFeatureError = "Warning: resulting shape is not valid"; + if(!aFillerAlgo->isValid()) { + std::string aFeatureError = "Error: Resulting shape is not valid."; setError(aFeatureError); return; } - aShape = aFillerAlgo.shape(); - aMakeShapeList.appendAlgo(aFillerAlgo.makeShape()); - aMapOfShapes.merge(aFillerAlgo.mapOfShapes()); + aShape = aFillerAlgo->shape(); + aMakeShapeList->appendAlgo(aFillerAlgo); } - std::shared_ptr aResultBody = document()->createBody(data(), aResultIndex); - loadNamingDS(aResultBody, anOriginalSolids.front(), anOriginalSolids, aShape, aMakeShapeList, aMapOfShapes); + std::shared_ptr aBackShape = anOriginalShapes.back(); + anOriginalShapes.pop_back(); + std::shared_ptr aResultBody = + document()->createBody(data(), aResultIndex); + loadNamingDS(aResultBody, aBackShape, anOriginalShapes, + aShape, aMakeShapeList); 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); + } + } + } + + std::shared_ptr aMakeShapeList; + 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); + } + + // 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); + } + } + + // 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); + + // 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); + + std::shared_ptr aFrontShape = anOriginalShapes.front(); + anOriginalShapes.pop_front(); + std::shared_ptr aResultBody = + document()->createBody(data(), aResultIndex); + loadNamingDS(aResultBody, aFrontShape, anOriginalShapes, aShape, aMakeShapeList); + setResult(aResultBody, aResultIndex); + aResultIndex++; + + break; + } default: { - std::string anOperationError = "Error: wrong type of operation"; + std::string anOperationError = "Error: Wrong type of operation"; setError(anOperationError); return; } @@ -355,28 +679,30 @@ void FeaturesPlugin_Boolean::loadNamingDS(std::shared_ptr t const std::shared_ptr theBaseShape, const ListOfShape& theTools, const std::shared_ptr theResultShape, - GeomAlgoAPI_MakeShape& theMakeShape, - GeomAPI_DataMapOfShapeShape& theMapOfShapes) + const GeomMakeShapePtr& theMakeShape) { //load result if(theBaseShape->isEqual(theResultShape)) { - theResultBody->store(theResultShape); - } else { - const int aModifyTag = 1; - const int aDeletedTag = 2; - const int aSubsolidsTag = 3; /// sub solids will be placed at labels 3, 4, etc. if result is compound of solids - - theResultBody->storeModified(theBaseShape, theResultShape, aSubsolidsTag); - - std::string aModName = "Modified"; - theResultBody->loadAndOrientModifiedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::FACE, - aModifyTag, aModName, theMapOfShapes); - theResultBody->loadDeletedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::FACE, aDeletedTag); - - for(ListOfShape::const_iterator anIter = theTools.begin(); anIter != theTools.end(); anIter++) { - theResultBody->loadAndOrientModifiedShapes(&theMakeShape, *anIter, GeomAPI_Shape::FACE, - aModifyTag, aModName, theMapOfShapes); - theResultBody->loadDeletedShapes(&theMakeShape, *anIter, GeomAPI_Shape::FACE, aDeletedTag); - } + theResultBody->store(theResultShape, false); + return; + } + + theResultBody->storeModified(theBaseShape, theResultShape); + + theResultBody->loadModifiedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::EDGE); + theResultBody->loadModifiedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::FACE); + + theResultBody->loadDeletedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::FACE); + + 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); } }