-// 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
//
// 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<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "FeaturesPlugin_Boolean.h"
#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_Boolean.h>
+#include <GeomAlgoAPI_CompoundBuilder.h>
#include <GeomAlgoAPI_MakeShapeCustom.h>
#include <GeomAlgoAPI_MakeShapeList.h>
#include <GeomAlgoAPI_Partition.h>
#include <GeomAlgoAPI_PaveFiller.h>
+#include <GeomAlgoAPI_ShapeBuilder.h>
#include <GeomAlgoAPI_ShapeTools.h>
+#include <GeomAlgoAPI_Tools.h>
#include <GeomAPI_Face.h>
#include <GeomAPI_ShapeExplorer.h>
#include <GeomAPI_ShapeIterator.h>
ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), TOOL_LIST_ID());
}
-//=================================================================================================
-std::shared_ptr<GeomAPI_Shape> FeaturesPlugin_Boolean::getShape(const std::string& theAttrName)
-{
- std::shared_ptr<ModelAPI_AttributeReference> aObjRef = std::dynamic_pointer_cast<
- ModelAPI_AttributeReference>(data()->attribute(theAttrName));
- if (aObjRef) {
- std::shared_ptr<ModelAPI_ResultBody> aConstr = std::dynamic_pointer_cast<
- ModelAPI_ResultBody>(aObjRef->value());
- if (aConstr)
- return aConstr->shape();
- }
- return std::shared_ptr<GeomAPI_Shape>();
-}
-
//=================================================================================================
FeaturesPlugin_Boolean::OperationType FeaturesPlugin_Boolean::operationType()
{
}
//=================================================================================================
-void FeaturesPlugin_Boolean::execute()
+void FeaturesPlugin_Boolean::parentForShape(const GeomShapePtr& theShape,
+ const ResultPtr& theContext,
+ ObjectHierarchy& theShapesHierarchy)
{
- ListOfShape anObjects, aTools, anEdgesAndFaces, aPlanes;
- std::map<std::shared_ptr<GeomAPI_Shape>, ListOfShape> aCompSolidsObjects;
+ ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(theContext);
+ if (aResCompSolidPtr.get()) {
+ std::shared_ptr<GeomAPI_Shape> aContextShape = aResCompSolidPtr->shape();
+ if (aContextShape->shapeType() <= GeomAPI_Shape::COMPSOLID) {
+ theShapesHierarchy.AddParent(theShape, aContextShape);
+ parentForShape(aContextShape, aResCompSolidPtr, theShapesHierarchy);
+ }
+ }
+}
- // Getting objects.
- AttributeSelectionListPtr anObjectsSelList =
- selectionList(FeaturesPlugin_Boolean::OBJECT_LIST_ID());
- for(int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) {
+bool FeaturesPlugin_Boolean::processAttribute(const std::string& theAttributeName,
+ ObjectHierarchy& theObjects,
+ ListOfShape& thePlanesList)
+{
+ AttributeSelectionListPtr anObjectsSelList = selectionList(theAttributeName);
+ for (int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) {
AttributeSelectionPtr anObjectAttr = anObjectsSelList->value(anObjectsIndex);
- std::shared_ptr<GeomAPI_Shape> anObject = anObjectAttr->value();
- if(!anObject.get()) {
- return;
+ GeomShapePtr anObject = anObjectAttr->value();
+ if (!anObject.get()) {
+ // It could be a construction plane.
+ ResultPtr aContext = anObjectAttr->context();
+ anObject = anObjectAttr->context()->shape();
+ if (anObject.get()) {
+ thePlanesList.push_back(anObject);
+ continue;
+ } else
+ return false;
}
+
+ theObjects.AddObject(anObject);
+
ResultPtr aContext = anObjectAttr->context();
- ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext);
- if(aResCompSolidPtr.get()
- && aResCompSolidPtr->shape()->shapeType() == GeomAPI_Shape::COMPSOLID) {
- std::shared_ptr<GeomAPI_Shape> aContextShape = aResCompSolidPtr->shape();
- std::map<std::shared_ptr<GeomAPI_Shape>, 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);
- }
+ parentForShape(anObject, aContext, theObjects);
+ }
+ return true;
+}
+
+//=================================================================================================
+void FeaturesPlugin_Boolean::loadNamingDS(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::shared_ptr<GeomAPI_Shape> theBaseShape,
+ const ListOfShape& theTools,
+ const std::shared_ptr<GeomAPI_Shape> theResultShape,
+ const GeomMakeShapePtr& theMakeShape)
+{
+ //load result
+ if(theBaseShape->isEqual(theResultShape)) {
+ 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);
+ }
+}
+
+//=================================================================================================
+bool FeaturesPlugin_Boolean::processObject(
+ const GeomAlgoAPI_Tools::BOPType theBooleanType,
+ const GeomShapePtr& theObject,
+ const ListOfShape& theTools,
+ const ListOfShape& thePlanes,
+ int& theResultIndex,
+ std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ ListOfShape& theResultShapesList,
+ GeomShapePtr theResultCompound)
+{
+ ListOfShape aListWithObject;
+ aListWithObject.push_back(theObject);
+ std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
+ std::shared_ptr<GeomAlgoAPI_MakeShape> aBoolAlgo;
+ GeomShapePtr aResShape;
+
+ std::list<std::shared_ptr<GeomAPI_Pnt> > aBoundingPoints =
+ GeomAlgoAPI_ShapeTools::getBoundingBox(aListWithObject, 1.0);
+
+ // Resize planes.
+ ListOfShape aToolsWithPlanes = theTools;
+ for (ListOfShape::const_iterator anIt = thePlanes.begin(); anIt != thePlanes.end(); ++anIt) {
+ GeomShapePtr aPlane = *anIt;
+ GeomShapePtr aTool = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPlane, aBoundingPoints);
+ std::shared_ptr<GeomAlgoAPI_MakeShapeCustom> aMkShCustom(
+ new GeomAlgoAPI_MakeShapeCustom);
+ aMkShCustom->addModified(aPlane, aTool);
+ aMakeShapeList->appendAlgo(aMkShCustom);
+ aToolsWithPlanes.push_back(aTool);
+ }
+
+ if (theBooleanType == GeomAlgoAPI_Tools::BOOL_PARTITION)
+ aBoolAlgo.reset(new GeomAlgoAPI_Partition(aListWithObject, aToolsWithPlanes));
+ else
+ aBoolAlgo.reset(new GeomAlgoAPI_Boolean(aListWithObject,
+ aToolsWithPlanes,
+ theBooleanType));
+
+ // Checking that the algorithm worked properly.
+ std::string anError;
+ if (GeomAlgoAPI_Tools::AlgoError::isAlgorithmFailed(aBoolAlgo, getKind(), anError)) {
+ setError(anError);
+ return false;
+ }
+
+ 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();
}
}
- // 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());
+ aMakeShapeList->appendAlgo(aBoolAlgo);
+
+ GeomAPI_ShapeIterator aShapeIt(aResShape);
+ if (aShapeIt.more() || aResShape->shapeType() == GeomAPI_Shape::VERTEX) {
+ std::shared_ptr<ModelAPI_ResultBody> aResultBody;
+
+ if (theResultCompound) { // store BOP result to the compound
+ std::shared_ptr<GeomAlgoAPI_ShapeBuilder> aBuilder(new GeomAlgoAPI_ShapeBuilder);
+ aBuilder->add(theResultCompound, aResShape);
+ aMakeShapeList->appendAlgo(aBuilder);
}
- else if (myOperationType != BOOL_FILL
- && (aTool->shapeType() == GeomAPI_Shape::EDGE
- || aTool->shapeType() == GeomAPI_Shape::FACE))
- {
- anEdgesAndFaces.push_back(aTool);
- } else {
- aTools.push_back(aTool);
+ else { // create a separate ResultBody
+ aResultBody = document()->createBody(data(), theResultIndex);
+
+ // tools should be added to the list to fulfill the correct history of modification
+ aListWithObject.insert(aListWithObject.end(), theTools.begin(), theTools.end());
+
+ ListOfShape aUsedTools = theTools;
+ aUsedTools.insert(aUsedTools.end(), thePlanes.begin(), thePlanes.end());
+
+ FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ aListWithObject,
+ aUsedTools,
+ aMakeShapeList,
+ aResShape);
+ setResult(aResultBody, theResultIndex);
+ ++theResultIndex;
}
+
+
+ FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ aRBA.resultBody = aResultBody;
+ aRBA.baseShape = theObject;
+ aRBA.makeShape = aMakeShapeList;
+ theResultBaseAlgoList.push_back(aRBA);
+ theResultShapesList.push_back(aResShape);
}
+ return true;
+}
- 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;
- }
+//=================================================================================================
+bool FeaturesPlugin_Boolean::processCompsolid(
+ const GeomAlgoAPI_Tools::BOPType theBooleanType,
+ const ObjectHierarchy& theCompsolidHierarchy,
+ const GeomShapePtr& theCompsolid,
+ const ListOfShape& theTools,
+ const ListOfShape& thePlanes,
+ int& theResultIndex,
+ std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ ListOfShape& theResultShapesList,
+ GeomShapePtr theResultCompound)
+{
+ ListOfShape aUsedInOperationSolids;
+ ListOfShape aNotUsedSolids;
+ theCompsolidHierarchy.SplitCompound(theCompsolid, aUsedInOperationSolids, aNotUsedSolids);
- // For solids cut each object with all tools.
- for(ListOfShape::iterator
- anObjectsIt = anObjects.begin(); anObjectsIt != anObjects.end(); anObjectsIt++) {
- std::shared_ptr<GeomAPI_Shape> anObject = *anObjectsIt;
- ListOfShape aListWithObject;
- aListWithObject.push_back(anObject);
- std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- std::shared_ptr<GeomAlgoAPI_MakeShape> 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<std::shared_ptr<GeomAPI_Pnt> > 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<GeomAlgoAPI_MakeShapeCustom> 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 = "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<ModelAPI_ResultBody> 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++;
- }
- }
+ std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- // Compsolids handling
- for(std::map<std::shared_ptr<GeomAPI_Shape>, ListOfShape>::iterator
- anIt = aCompSolidsObjects.begin();
- anIt != aCompSolidsObjects.end(); anIt++) {
- std::shared_ptr<GeomAPI_Shape> 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<GeomAPI_Shape> 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);
- }
- }
-
- std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- std::shared_ptr<GeomAlgoAPI_MakeShape> 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<std::shared_ptr<GeomAPI_Pnt> > 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<GeomAlgoAPI_MakeShapeCustom> 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);
- 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<GeomAlgoAPI_PaveFiller> 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();
- }
-
- if(GeomAlgoAPI_ShapeTools::volume(aResultShape) > 1.e-27
- || (myOperationType != BOOL_CUT && myOperationType != BOOL_COMMON))
- {
- std::shared_ptr<ModelAPI_ResultBody> 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);
- 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;
- }
+ std::list<std::shared_ptr<GeomAPI_Pnt> > aBoundingPoints =
+ GeomAlgoAPI_ShapeTools::getBoundingBox(aUsedInOperationSolids, 1.0);
- // 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<std::shared_ptr<GeomAPI_Shape>, ListOfShape>::iterator
- anIt = aCompSolidsObjects.begin();
- anIt != aCompSolidsObjects.end(); anIt++) {
- std::shared_ptr<GeomAPI_Shape> 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<GeomAPI_Shape> 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);
- }
- }
- }
+ // Resize planes.
+ ListOfShape aToolsWithPlanes = theTools;
+ for (ListOfShape::const_iterator anIt = thePlanes.begin(); anIt != thePlanes.end(); ++anIt)
+ {
+ GeomShapePtr aPlane = *anIt;
+ GeomShapePtr aTool = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPlane, aBoundingPoints);
+ std::shared_ptr<GeomAlgoAPI_MakeShapeCustom> aMkShCustom(
+ new GeomAlgoAPI_MakeShapeCustom);
+ aMkShCustom->addModified(aPlane, aTool);
+ aMakeShapeList->appendAlgo(aMkShCustom);
+ aToolsWithPlanes.push_back(aTool);
+ }
- ListOfShape anOriginalShapes = aSolidsToFuse;
- anOriginalShapes.insert(anOriginalShapes.end(), aShapesToAdd.begin(), aShapesToAdd.end());
-
- // Cut edges and faces(if we have any) with solids.
- std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- std::shared_ptr<GeomAPI_Shape> aCuttedEdgesAndFaces;
- if(!anEdgesAndFaces.empty()) {
- std::shared_ptr<GeomAlgoAPI_Boolean> 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(!aShapesToAdd.empty()) {
- aSolidsToFuse.clear();
- for(ListOfShape::iterator
- anIt = anOriginalShapes.begin(); anIt != anOriginalShapes.end(); anIt++) {
- ListOfShape aOneObjectList;
- aOneObjectList.push_back(*anIt);
- std::shared_ptr<GeomAlgoAPI_Boolean> 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);
- }
- }
- }
+ std::shared_ptr<GeomAlgoAPI_MakeShape> aBoolAlgo;
+ if (theBooleanType == GeomAlgoAPI_Tools::BOOL_PARTITION)
+ aBoolAlgo.reset(new GeomAlgoAPI_Partition(aUsedInOperationSolids, aToolsWithPlanes));
+ else
+ aBoolAlgo.reset(new GeomAlgoAPI_Boolean(aUsedInOperationSolids,
+ aToolsWithPlanes,
+ theBooleanType));
+
+ // Checking that the algorithm worked properly.
+ std::string anError;
+ if (GeomAlgoAPI_Tools::AlgoError::isAlgorithmFailed(aBoolAlgo, getKind(), anError)) {
+ setError(anError);
+ return false;
+ }
- if(!aSolidsToFuse.empty()) {
- anObjects.clear();
- anObjects.push_back(aSolidsToFuse.back());
- aSolidsToFuse.pop_back();
- aTools = aSolidsToFuse;
- }
+ aMakeShapeList->appendAlgo(aBoolAlgo);
+ 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<GeomAlgoAPI_PaveFiller> aFillerAlgo(
+ new GeomAlgoAPI_PaveFiller(aShapesToAdd, true));
+ if (!aFillerAlgo->isDone()) {
+ std::string aFeatureError = "Error: PaveFiller algorithm failed.";
+ setError(aFeatureError);
+ return false;
+ }
- // Fuse all objects and all tools.
- std::shared_ptr<GeomAPI_Shape> 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<GeomAlgoAPI_Boolean> 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);
- }
+ aMakeShapeList->appendAlgo(aFillerAlgo);
+ aResultShape = aFillerAlgo->shape();
+ }
- // 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<GeomAlgoAPI_PaveFiller> 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);
- }
+ GeomAPI_ShapeIterator aShapeIt(aResultShape);
+ if (aShapeIt.more() || aResultShape->shapeType() == GeomAPI_Shape::VERTEX)
+ {
+ std::shared_ptr<ModelAPI_ResultBody> aResultBody;
- std::shared_ptr<GeomAPI_Shape> aBackShape = anOriginalShapes.back();
- anOriginalShapes.pop_back();
- std::shared_ptr<ModelAPI_ResultBody> aResultBody =
- document()->createBody(data(), aResultIndex);
- loadNamingDS(aResultBody, aBackShape, anOriginalShapes,
- aShape, aMakeShapeList);
- setResult(aResultBody, aResultIndex);
- aResultIndex++;
- break;
+ if (theResultCompound) { // store BOP result to the compound
+ std::shared_ptr<GeomAlgoAPI_ShapeBuilder> aBuilder(new GeomAlgoAPI_ShapeBuilder);
+ aBuilder->add(theResultCompound, aResultShape);
+ aMakeShapeList->appendAlgo(aBuilder);
+ }
+ else { // create a separate ResultBody
+ aResultBody = document()->createBody(data(), theResultIndex);
+
+ ListOfShape aCompSolidList;
+ aCompSolidList.push_back(theCompsolid);
+ // tools should be added to the list to fulfill the correct history of modification
+ aCompSolidList.insert(aCompSolidList.end(), theTools.begin(), theTools.end());
+
+ ListOfShape aUsedTools = theTools;
+ aUsedTools.insert(aUsedTools.end(), thePlanes.begin(), thePlanes.end());
+
+ FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ aCompSolidList,
+ aUsedTools,
+ aMakeShapeList,
+ aResultShape);
+ setResult(aResultBody, theResultIndex);
+ ++theResultIndex;
}
- 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<std::shared_ptr<GeomAPI_Shape>, ListOfShape>::iterator
- anIt = aCompSolidsObjects.begin();
- anIt != aCompSolidsObjects.end(); anIt++) {
- std::shared_ptr<GeomAPI_Shape> 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<GeomAPI_Shape> 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);
- }
- }
- }
+ FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ aRBA.resultBody = aResultBody;
+ aRBA.baseShape = theCompsolid;
+ aRBA.makeShape = aMakeShapeList;
+ theResultBaseAlgoList.push_back(aRBA);
+ theResultShapesList.push_back(aResultShape);
+ }
+ return true;
+}
- std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList;
- if(!aShapesToAdd.empty()) {
- // Cut objects with not used solids.
- std::shared_ptr<GeomAlgoAPI_Boolean> 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<GeomAlgoAPI_Boolean> 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);
- }
- }
+//=================================================================================================
+bool FeaturesPlugin_Boolean::processCompound(
+ const GeomAlgoAPI_Tools::BOPType theBooleanType,
+ const ObjectHierarchy& theCompoundHierarchy,
+ const GeomShapePtr& theCompound,
+ const ListOfShape& theTools,
+ int& theResultIndex,
+ std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ ListOfShape& theResultShapesList,
+ GeomShapePtr theResultCompound)
+{
+ ListOfShape aUsedInOperationShapes;
+ ListOfShape aNotUsedShapes;
+ theCompoundHierarchy.SplitCompound(theCompound, aUsedInOperationShapes, aNotUsedShapes);
+
+ std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
+ std::shared_ptr<GeomAlgoAPI_Boolean> aBoolAlgo(
+ new GeomAlgoAPI_Boolean(aUsedInOperationShapes,
+ theTools,
+ theBooleanType));
+
+ // Checking that the algorithm worked properly.
+ std::string anError;
+ if (GeomAlgoAPI_Tools::AlgoError::isAlgorithmFailed(aBoolAlgo, getKind(), anError)) {
+ setError(anError);
+ return false;
+ }
- // Cut objects with tools.
- std::shared_ptr<GeomAlgoAPI_Boolean> aBoolAlgo(new GeomAlgoAPI_Boolean(aShapesToSmash,
- aTools,
- GeomAlgoAPI_Boolean::BOOL_CUT));
+ aMakeShapeList->appendAlgo(aBoolAlgo);
+ GeomShapePtr aResultShape = aBoolAlgo->shape();
- // 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<GeomAlgoAPI_PaveFiller> 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;
+ // Add result to not used shape from compound.
+ if (!aNotUsedShapes.empty()) {
+ ListOfShape aShapesForResult = aNotUsedShapes;
+ if (aResultShape->shapeType() == GeomAPI_Shape::COMPOUND) {
+ for (GeomAPI_ShapeIterator aResultIt(aResultShape); aResultIt.more(); aResultIt.next()) {
+ aShapesForResult.push_back(aResultIt.current());
}
+ }
+ else {
+ aShapesForResult.push_back(aResultShape);
+ }
- std::shared_ptr<GeomAPI_Shape> aShape = aFillerAlgo->shape();
- aMakeShapeList->appendAlgo(aFillerAlgo);
+ if (aShapesForResult.size() == 1) {
+ aResultShape = aShapesForResult.front();
+ }
+ else {
+ aResultShape = GeomAlgoAPI_CompoundBuilder::compound(aShapesForResult);
+ }
+ }
- std::shared_ptr<GeomAPI_Shape> aFrontShape = anOriginalShapes.front();
- anOriginalShapes.pop_front();
- std::shared_ptr<ModelAPI_ResultBody> aResultBody =
- document()->createBody(data(), aResultIndex);
- loadNamingDS(aResultBody, aFrontShape, anOriginalShapes, aShape, aMakeShapeList);
- setResult(aResultBody, aResultIndex);
- aResultIndex++;
+ GeomAPI_ShapeIterator aShapeIt(aResultShape);
+ if (aShapeIt.more() || aResultShape->shapeType() == GeomAPI_Shape::VERTEX) {
+ std::shared_ptr<ModelAPI_ResultBody> aResultBody;
- break;
+ if (theResultCompound) { // store BOP result to the compound
+ std::shared_ptr<GeomAlgoAPI_ShapeBuilder> aBuilder(new GeomAlgoAPI_ShapeBuilder);
+ aBuilder->add(theResultCompound, aResultShape);
+ aMakeShapeList->appendAlgo(aBuilder);
}
- default: {
- std::string anOperationError = "Error: Wrong type of operation";
- setError(anOperationError);
- return;
+ else { // create a separate ResultBody
+ aResultBody = document()->createBody(data(), theResultIndex);
+
+ ListOfShape aCompoundList;
+ aCompoundList.push_back(theCompound);
+ FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ aCompoundList,
+ theTools,
+ aMakeShapeList,
+ aResultShape);
+ setResult(aResultBody, theResultIndex);
+ ++theResultIndex;
}
+
+ FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ aRBA.resultBody = aResultBody;
+ aRBA.baseShape = theCompound;
+ aRBA.makeShape = aMakeShapeList;
+ theResultBaseAlgoList.push_back(aRBA);
+ theResultShapesList.push_back(aResultShape);
}
- // remove the rest results if there were produced in the previous pass
- removeResults(aResultIndex);
+ return true;
+}
+
+//==================================================================================================
+GeomShapePtr FeaturesPlugin_Boolean::keepUnusedSubsOfCompound(
+ const GeomShapePtr& theResult,
+ const ObjectHierarchy& theObjectsHierarchy,
+ const ObjectHierarchy& theToolsHierarchy,
+ std::shared_ptr<GeomAlgoAPI_MakeShapeList> theMakeShapeList)
+{
+ ListOfShape aCompounds;
+ theObjectsHierarchy.CompoundsOfUnusedObjects(aCompounds);
+ theToolsHierarchy.CompoundsOfUnusedObjects(aCompounds);
+
+ GeomShapePtr aResultShape = theResult;
+ if (!aCompounds.empty()) {
+ aResultShape = aCompounds.front();
+ aCompounds.pop_front();
+
+ std::shared_ptr<GeomAlgoAPI_ShapeBuilder> aBuilder(new GeomAlgoAPI_ShapeBuilder);
+ for (ListOfShape::iterator anIt = aCompounds.begin(); anIt != aCompounds.end(); ++anIt) {
+ for (GeomAPI_ShapeIterator aSub(*anIt); aSub.more(); aSub.next())
+ aBuilder->add(aResultShape, aSub.current());
+ }
+
+ if (theResult)
+ aBuilder->add(aResultShape, theResult);
+
+ theMakeShapeList->appendAlgo(aBuilder);
+ }
+ return aResultShape;
}
//=================================================================================================
-void FeaturesPlugin_Boolean::loadNamingDS(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- const std::shared_ptr<GeomAPI_Shape> theBaseShape,
- const ListOfShape& theTools,
- const std::shared_ptr<GeomAPI_Shape> theResultShape,
- const GeomMakeShapePtr& theMakeShape)
+int FeaturesPlugin_Boolean::version()
{
- //load result
- if(theBaseShape->isEqual(theResultShape)) {
- theResultBody->store(theResultShape, false);
+ AttributeIntegerPtr aVersionAttr = integer(VERSION_ID());
+ int aVersion = 0;
+ if (aVersionAttr && aVersionAttr->isInitialized())
+ aVersion = aVersionAttr->value();
+ return aVersion;
+}
+
+//=================================================================================================
+
+void FeaturesPlugin_Boolean::ObjectHierarchy::AddObject(const GeomShapePtr& theObject)
+{
+ myObjects.push_back(theObject);
+}
+
+void FeaturesPlugin_Boolean::ObjectHierarchy::AddParent(const GeomShapePtr& theShape,
+ const GeomShapePtr& theParent)
+{
+ myParent[theShape] = theParent;
+
+ MapShapeToIndex::iterator aFound = myParentIndices.find(theParent);
+ size_t anIndex = myParentIndices.size();
+ if (aFound == myParentIndices.end()) {
+ myParentIndices[theParent] = anIndex;
+ mySubshapes.push_back(ShapeAndSubshapes(theParent, ListOfShape()));
+ } else
+ anIndex = aFound->second;
+
+ mySubshapes[anIndex].second.push_back(theShape);
+}
+
+GeomShapePtr FeaturesPlugin_Boolean::ObjectHierarchy::Parent(const GeomShapePtr& theShape,
+ bool theMarkProcessed)
+{
+ MapShapeToParent::const_iterator aFound = myParent.find(theShape);
+ GeomShapePtr aParent;
+ if (aFound != myParent.end()) {
+ aParent = aFound->second;
+ if (theMarkProcessed) {
+ // mark the parent and all its subs as processed by Boolean algorithm
+ myProcessedObjects.insert(aParent);
+ const ListOfShape& aSubs = mySubshapes[myParentIndices[aParent]].second;
+ for (ListOfShape::const_iterator anIt = aSubs.begin(); anIt != aSubs.end(); ++anIt)
+ myProcessedObjects.insert(*anIt);
+ }
+ }
+ return aParent;
+}
+
+void FeaturesPlugin_Boolean::ObjectHierarchy::ObjectsByType(
+ ListOfShape& theShapesByType,
+ ListOfShape& theOtherShapes,
+ const GeomAPI_Shape::ShapeType theMinType,
+ const GeomAPI_Shape::ShapeType theMaxType) const
+{
+ if (theMinType > theMaxType)
+ return ObjectsByType(theShapesByType, theOtherShapes, theMaxType, theMinType);
+
+ // no need to select objects if whole range is specified
+ if (theMinType == GeomAPI_Shape::COMPOUND && theMaxType == GeomAPI_Shape::SHAPE) {
+ theShapesByType.insert(theShapesByType.end(), myObjects.begin(), myObjects.end());
return;
}
- theResultBody->storeModified(theBaseShape, theResultShape);
+ for (ListOfShape::const_iterator anIt = myObjects.begin(); anIt != myObjects.end(); ++anIt) {
+ GeomAPI_Shape::ShapeType aType = (*anIt)->shapeType();
+ if (aType >= theMinType && aType <= theMaxType)
+ theShapesByType.push_back(*anIt);
+ else
+ theOtherShapes.push_back(*anIt);
+ }
+}
- theResultBody->loadModifiedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::EDGE);
- theResultBody->loadModifiedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::FACE);
- theResultBody->loadDeletedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::FACE);
+void FeaturesPlugin_Boolean::ObjectHierarchy::SplitCompound(const GeomShapePtr& theCompShape,
+ ListOfShape& theUsed,
+ ListOfShape& theNotUsed) const
+{
+ theUsed.clear();
+ theNotUsed.clear();
+
+ MapShapeToIndex::const_iterator aFoundIndex = myParentIndices.find(theCompShape);
+ if (aFoundIndex == myParentIndices.end())
+ return; // no such shape
+
+ const ListOfShape& aSubs = mySubshapes[aFoundIndex->second].second;
+ SetOfShape aSubsSet;
+ aSubsSet.insert(aSubs.begin(), aSubs.end());
+
+ for (GeomAPI_ShapeIterator anExp(theCompShape); anExp.more(); anExp.next()) {
+ GeomShapePtr aCurrent = anExp.current();
+ if (aSubsSet.find(aCurrent) == aSubsSet.end())
+ theNotUsed.push_back(aCurrent);
+ else
+ theUsed.push_back(aCurrent);
+ }
+}
- 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);
+bool FeaturesPlugin_Boolean::ObjectHierarchy::IsEmpty() const
+{
+ return myObjects.empty();
+}
- theResultBody->loadDeletedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE);
+void FeaturesPlugin_Boolean::ObjectHierarchy::CompoundsOfUnusedObjects(
+ ListOfShape& theDestination) const
+{
+ SetOfShape aUsedObjects;
+ aUsedObjects.insert(myObjects.begin(), myObjects.end());
+
+ for (std::vector<ShapeAndSubshapes>::const_iterator anIt = mySubshapes.begin();
+ anIt != mySubshapes.end(); ++anIt) {
+ MapShapeToParent::const_iterator aParent = myParent.find(anIt->first);
+ if ((aParent == myParent.end() || !aParent->second) &&
+ anIt->first->shapeType() == GeomAPI_Shape::COMPOUND) {
+ // this is a top-level compound
+ GeomShapePtr aCompound = collectUnusedSubs(anIt->first, aUsedObjects);
+ // add to destination non-empty compounds only
+ if (aCompound)
+ theDestination.push_back(aCompound);
+ }
}
}
+
+GeomShapePtr FeaturesPlugin_Boolean::ObjectHierarchy::collectUnusedSubs(
+ GeomShapePtr theTopLevelCompound,
+ const SetOfShape& theUsed) const
+{
+ GeomShapePtr aResult = theTopLevelCompound->emptyCopied();
+ bool isResultEmpty = true;
+
+ for (GeomAPI_ShapeIterator aSub(theTopLevelCompound); aSub.more(); aSub.next()) {
+ GeomShapePtr aCurrent = aSub.current();
+ if (theUsed.find(aCurrent) != theUsed.end())
+ continue; // already used
+
+ MapShapeToIndex::const_iterator aFoundIndex = myParentIndices.find(aCurrent);
+ if (aCurrent->shapeType() > GeomAPI_Shape::COMPOUND ||
+ aFoundIndex == myParentIndices.end()) {
+ bool isAddShape = true;
+ // check compsolid is fully unused in the Boolean operation
+ if (aCurrent->shapeType() == GeomAPI_Shape::COMPSOLID) {
+ for (GeomAPI_ShapeIterator anIt(aCurrent); isAddShape && anIt.more(); anIt.next())
+ isAddShape = theUsed.find(anIt.current()) == theUsed.end();
+ }
+
+ if (isAddShape) { // low-level shape, add it
+ GeomAlgoAPI_ShapeBuilder::add(aResult, aCurrent);
+ isResultEmpty = false;
+ }
+ } else {
+ GeomShapePtr aCompound = collectUnusedSubs(aCurrent, theUsed);
+ if (aCompound) {
+ GeomAlgoAPI_ShapeBuilder::add(theTopLevelCompound, aCompound);
+ isResultEmpty = false;
+ }
+ }
+ }
+ return isResultEmpty ? GeomShapePtr() : aResult;
+}
+
+
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator FeaturesPlugin_Boolean::ObjectHierarchy::Begin()
+{
+ return Iterator(this);
+}
+
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator FeaturesPlugin_Boolean::ObjectHierarchy::End()
+{
+ return Iterator(this, false);
+}
+
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::Iterator(
+ FeaturesPlugin_Boolean::ObjectHierarchy* theHierarchy, bool isBegin)
+ : myHierarchy(theHierarchy)
+{
+ if (isBegin) {
+ myObject = myHierarchy->myObjects.begin();
+ SkipAlreadyProcessed();
+ } else
+ myObject = myHierarchy->myObjects.end();
+}
+
+void FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::SkipAlreadyProcessed()
+{
+ while (myObject != myHierarchy->myObjects.end() &&
+ myHierarchy->myProcessedObjects.find(*myObject) != myHierarchy->myProcessedObjects.end())
+ ++myObject;
+}
+
+bool FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::operator==(const Iterator& theOther) const
+{
+ return myObject == theOther.myObject;
+}
+
+bool FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::operator!=(const Iterator& theOther) const
+{
+ return !operator==(theOther);
+}
+
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator&
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::operator++()
+{
+ ++myObject;
+ SkipAlreadyProcessed();
+ return *this;
+}
+
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator
+FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::operator++(int)
+{
+ Iterator aCurrent;
+ aCurrent.myHierarchy = myHierarchy;
+ aCurrent.myObject = myObject;
+
+ // increase iterator
+ operator++();
+
+ return aCurrent;
+}
+
+GeomShapePtr FeaturesPlugin_Boolean::ObjectHierarchy::Iterator::operator*() const
+{
+ myHierarchy->myProcessedObjects.insert(*myObject);
+ return *myObject;
+}