X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_CompositeBoolean.cpp;h=cfe002fb0b1ff080ad3d279ac92825f87d85b8e5;hb=a13f87935d2a6f52f942790b6abc874f1016c9fc;hp=c11ed54d5fa7d021c69a1a7b7df77ad93c5bae27;hpb=9ddf765aa139febfce68653fb50282c68759591b;p=modules%2Fshaper.git

diff --git a/src/FeaturesPlugin/FeaturesPlugin_CompositeBoolean.cpp b/src/FeaturesPlugin/FeaturesPlugin_CompositeBoolean.cpp
index c11ed54d5..cfe002fb0 100644
--- a/src/FeaturesPlugin/FeaturesPlugin_CompositeBoolean.cpp
+++ b/src/FeaturesPlugin/FeaturesPlugin_CompositeBoolean.cpp
@@ -1,220 +1,423 @@
-// Copyright (C) 2014-20xx 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
+// 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
+//
 
-// File:        FeaturesPlugin_CompositeBoolean.cpp
-// Created:     11 June 2015
-// Author:      Dmitry Bobylev
-
-#include <FeaturesPlugin_CompositeBoolean.h>
+#include "FeaturesPlugin_CompositeBoolean.h"
 
 #include <ModelAPI_AttributeSelectionList.h>
-#include <ModelAPI_AttributeReference.h>
-#include <ModelAPI_ResultBody.h>
-#include <ModelAPI_ResultConstruction.h>
+#include <ModelAPI_Tools.h>
 
-#include <GeomAlgoAPI_ShapeProps.h>
+#include <GeomAlgoAPI_Boolean.h>
+#include <GeomAlgoAPI_CompoundBuilder.h>
+#include <GeomAlgoAPI_MakeShapeList.h>
+#include <GeomAlgoAPI_PaveFiller.h>
+#include <GeomAlgoAPI_ShapeTools.h>
 
-//=================================================================================================
-void FeaturesPlugin_CompositeBoolean::initAttributes()
-{
-  data()->addAttribute(SKETCH_OBJECT_ID(), ModelAPI_AttributeReference::typeId());
+#include <GeomAPI_ShapeIterator.h>
 
-  // Boolean works with solids always.
-  data()->addAttribute(BOOLEAN_OBJECTS_ID(), ModelAPI_AttributeSelectionList::typeId());
-  AttributeSelectionListPtr aSelection = data()->selectionList(BOOLEAN_OBJECTS_ID());
-  aSelection->setSelectionType("SOLID");
-
-  initMakeSolidsAttributes();
-}
+#include <map>
 
 //=================================================================================================
-std::shared_ptr<ModelAPI_Feature> FeaturesPlugin_CompositeBoolean::addFeature(std::string theID)
+void FeaturesPlugin_CompositeBoolean::initBooleanAttributes()
 {
-  std::shared_ptr<ModelAPI_Feature> aNew = document()->addFeature(theID, false);
-  if (aNew) {
-    data()->reference(SKETCH_OBJECT_ID())->setValue(aNew);
-  }
-   // set as current also after it becomes sub to set correctly enabled for other sketch subs
-  document()->setCurrentFeature(aNew, false);
-  return aNew;
+  myFeature->data()->addAttribute(OBJECTS_ID(), ModelAPI_AttributeSelectionList::typeId());
 }
 
 //=================================================================================================
-int FeaturesPlugin_CompositeBoolean::numberOfSubs(bool forTree) const
+void FeaturesPlugin_CompositeBoolean::executeCompositeBoolean()
 {
-  ObjectPtr aObj = data()->reference(SKETCH_OBJECT_ID())->value();
-  return aObj.get()? 1 : 0;
-}
+  // Make generation.
+  ListOfShape aGenBaseShapes;
+  ListOfMakeShape aGenMakeShapes;
+  if(!makeGeneration(aGenBaseShapes, aGenMakeShapes)) {
+    return;
+  }
 
-//=================================================================================================
-std::shared_ptr<ModelAPI_Feature> FeaturesPlugin_CompositeBoolean::subFeature(const int theIndex, bool forTree) const
-{
-  if (theIndex == 0)
-    return std::dynamic_pointer_cast<ModelAPI_Feature>(data()->reference(SKETCH_OBJECT_ID())->value());
-  return std::shared_ptr<ModelAPI_Feature>();
-}
+  // Getting tools.
+  ListOfShape aTools;
+  for(ListOfMakeShape::const_iterator
+      anIt = aGenMakeShapes.cbegin(); anIt != aGenMakeShapes.cend(); ++anIt) {
+    aTools.push_back((*anIt)->shape());
+  }
 
-//=================================================================================================
-int FeaturesPlugin_CompositeBoolean::subFeatureId(const int theIndex) const
-{
-  std::shared_ptr<ModelAPI_Feature> aFeature = subFeature(theIndex);
-  if (aFeature.get())
-    return aFeature->data()->featureId();
-  return -1;
-}
+  // Make boolean.
+  ListOfShape aBooleanObjects;
+  ListOfMakeShape aBooleanMakeShapes;
+  if(!makeBoolean(aTools, aBooleanObjects, aBooleanMakeShapes)) {
+    return;
+  }
 
-//=================================================================================================
-bool FeaturesPlugin_CompositeBoolean::isSub(ObjectPtr theObject) const
-{
-  // check is this feature of result
-  FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
-  if (!aFeature)
-    return false;
- 
-  ObjectPtr aSub = data()->reference(SKETCH_OBJECT_ID())->value();
-  return aSub == theObject;
-}
+  if(myOperationType == BOOL_FUSE) {
+    aTools.splice(aTools.begin(), aBooleanObjects);
+    aBooleanObjects.splice(aBooleanObjects.begin(), aTools, aTools.begin());
+  }
 
-//=================================================================================================
-void FeaturesPlugin_CompositeBoolean::removeFeature(std::shared_ptr<ModelAPI_Feature> theFeature)
-{
-}
+  // Store result.
+  int aResultIndex = 0;
+  std::vector<ResultBaseAlgo> aResultBaseAlgoList;
+  ListOfShape aResultShapesList;
+  ListOfShape::const_iterator aBoolObjIt = aBooleanObjects.cbegin();
+  ListOfMakeShape::const_iterator aBoolMSIt = aBooleanMakeShapes.cbegin();
+  for(; aBoolObjIt != aBooleanObjects.cend() && aBoolMSIt != aBooleanMakeShapes.cend();
+      ++aBoolObjIt, ++aBoolMSIt) {
 
-//=================================================================================================
-void FeaturesPlugin_CompositeBoolean::erase()
-{
-  FeaturePtr aSketch =
-    std::dynamic_pointer_cast<ModelAPI_Feature>(data()->reference(SKETCH_OBJECT_ID())->value());
-  if (aSketch.get() && aSketch->data()->isValid()) {
-    document()->removeFeature(aSketch);
-  }
-  ModelAPI_CompositeFeature::erase();
-}
+    ResultBodyPtr aResultBody = myFeature->document()->createBody(myFeature->data(), aResultIndex);
 
+    if((*aBoolObjIt)->isEqual((*aBoolMSIt)->shape())) {
+      aResultBody->store((*aBoolMSIt)->shape(), false);
+    }
+    else
+    {
+      aResultBody->storeModified(*aBoolObjIt, (*aBoolMSIt)->shape());
 
-//=================================================================================================
-void FeaturesPlugin_CompositeBoolean::execute()
-{
-  // Getting faces to create solids.
-  std::shared_ptr<ModelAPI_Feature> aSketchFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(
-                                                     reference(SKETCH_OBJECT_ID())->value());
-  if(!aSketchFeature) {
-    return;
-  }
-  ResultPtr aSketchRes = aSketchFeature->results().front();
-  ResultConstructionPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aSketchRes);
-  if(!aConstruction.get()) {
-    return;
-  }
-  int aSketchFacesNum = aConstruction->facesNum();
-  if(aSketchFacesNum == 0) {
-    return; //TODO: set error message
-  }
-  ListOfShape aSketchFacesList;
-  for(int aFaceIndex = 0; aFaceIndex < aSketchFacesNum; aFaceIndex++) {
-    std::shared_ptr<GeomAPI_Shape> aFace = std::dynamic_pointer_cast<GeomAPI_Shape>(aConstruction->face(aFaceIndex));
-    aSketchFacesList.push_back(aFace);
-  }
+      // Store generation history.
+      ListOfShape::const_iterator aGenBaseIt = aGenBaseShapes.cbegin();
+      ListOfMakeShape::const_iterator aGenMSIt = aGenMakeShapes.cbegin();
+      for(; aGenBaseIt != aGenBaseShapes.cend() && aGenMSIt != aGenMakeShapes.cend();
+          ++aGenBaseIt, ++aGenMSIt) {
+        std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMSList(new GeomAlgoAPI_MakeShapeList());
+        aMSList->appendAlgo(*aGenMSIt);
+        aMSList->appendAlgo(*aBoolMSIt);
+        storeGenerationHistory(aResultBody, *aGenBaseIt, aMSList);
+      }
 
-  // Pass faces to soldis creation function.
-  ListOfShape aBooleanTools = MakeSolids(aSketchFacesList);
-  if(aBooleanTools.empty()) {
-    return;
-  }
+      storeModificationHistory(aResultBody, *aBoolObjIt, aTools, *aBoolMSIt);
 
-  // Getting objects for boolean operation.
-  ListOfShape aBooleanObjects;
-  AttributeSelectionListPtr anObjectsSelList = selectionList(BOOLEAN_OBJECTS_ID());
-  if (anObjectsSelList->size() == 0) {
-    return;
+      ResultBaseAlgo aRBA;
+      aRBA.resultBody = aResultBody;
+      aRBA.baseShape = *aBoolObjIt;
+      aRBA.makeShape = *aBoolMSIt;
+      aResultBaseAlgoList.push_back(aRBA);
+      aResultShapesList.push_back((*aBoolMSIt)->shape());
+    }
+
+    myFeature->setResult(aResultBody, aResultIndex++);
   }
+
+  // Store deleted shapes after all results has been proceeded. This is to avoid issue when in one
+  // result shape has been deleted, but in another it was modified or stayed.
+  GeomShapePtr aResultShapesCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
+  storeDeletedShapes(aResultBaseAlgoList, aTools, aResultShapesCompound);
+
+  myFeature->removeResults(aResultIndex);
+}
+
+//=================================================================================================
+bool FeaturesPlugin_CompositeBoolean::makeBoolean(const ListOfShape& theTools,
+                                                  ListOfShape& theObjects,
+                                                  ListOfMakeShape& theMakeShapes)
+{
+  // Getting objects.
+  ListOfShape anObjects, anEdgesAndFaces, aCompSolids;
+  std::map<GeomShapePtr, ListOfShape> aCompSolidsObjects;
+  AttributeSelectionListPtr anObjectsSelList = myFeature->selectionList(OBJECTS_ID());
   for(int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) {
-    std::shared_ptr<ModelAPI_AttributeSelection> anObjectAttr = anObjectsSelList->value(anObjectsIndex);
-    std::shared_ptr<GeomAPI_Shape> anObject = anObjectAttr->value();
+    AttributeSelectionPtr anObjectAttr = anObjectsSelList->value(anObjectsIndex);
+    GeomShapePtr anObject = anObjectAttr->value();
     if(!anObject.get()) {
-      return;
+      myFeature->setError("Error: Could not get object.");
+      return false;
+    }
+    ResultPtr aContext = anObjectAttr->context();
+    ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext);
+    if(aResCompSolidPtr.get()) {
+      GeomShapePtr aContextShape = aResCompSolidPtr->shape();
+      std::map<GeomShapePtr, 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);
+        aCompSolids.push_back(aContextShape);
+      }
+    } else {
+      if(anObject->shapeType() == GeomAPI_Shape::EDGE ||
+         anObject->shapeType() == GeomAPI_Shape::FACE) {
+        anEdgesAndFaces.push_back(anObject);
+      } else {
+        anObjects.push_back(anObject);
+      }
     }
-    aBooleanObjects.push_back(anObject);
   }
 
-  // Cut from each object solids.
-  int aResultIndex = 0;
+  switch(myOperationType) {
+    case BOOL_CUT: {
+      if((anObjects.empty() && aCompSolidsObjects.empty()) || theTools.empty()) {
+        myFeature->setError("Error: Not enough objects for boolean operation.");
+        return false;
+      }
 
-  switch(myBooleanOperationType) {
-    case GeomAlgoAPI_Boolean::BOOL_CUT:
-    case GeomAlgoAPI_Boolean::BOOL_COMMON:{
-      // Cut each object with all tools
-      for(ListOfShape::iterator anObjectsIt = aBooleanObjects.begin(); anObjectsIt != aBooleanObjects.end(); anObjectsIt++) {
-        std::shared_ptr<GeomAPI_Shape> anObject = *anObjectsIt;
+      // For solids cut each object with all tools.
+      for(ListOfShape::const_iterator
+          anIt = anObjects.cbegin(); anIt != anObjects.cend(); ++anIt) {
+        GeomShapePtr anObject = *anIt;
         ListOfShape aListWithObject;
         aListWithObject.push_back(anObject);
-        GeomAlgoAPI_Boolean aBoolAlgo(aListWithObject, aBooleanTools, myBooleanOperationType);
+        std::shared_ptr<GeomAlgoAPI_Boolean> aBoolAlgo(new GeomAlgoAPI_Boolean(aListWithObject,
+                                                                theTools,
+                                                                GeomAlgoAPI_Tools::BOOL_CUT));
 
         // Checking that the algorithm worked properly.
-        if(!aBoolAlgo.isDone() || aBoolAlgo.shape()->isNull() || !aBoolAlgo.isValid()) {
-          setError("Boolean algorithm failed");
-          return;
+        if(!aBoolAlgo->isDone() || aBoolAlgo->shape()->isNull() || !aBoolAlgo->isValid()) {
+          myFeature->setError("Error: Boolean algorithm failed.");
+          return false;
         }
 
-        if(GeomAlgoAPI_ShapeProps::volume(aBoolAlgo.shape()) > 1.e-7) {
-          std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
-          LoadNamingDS(aResultBody, anObject, aBooleanTools, aBoolAlgo);
-          setResult(aResultBody, aResultIndex);
-          aResultIndex++;
+        if(GeomAlgoAPI_ShapeTools::volume(aBoolAlgo->shape()) > 1.e-27) {
+          theObjects.push_back(anObject);
+          theMakeShapes.push_back(aBoolAlgo);
+        }
+      }
+
+      // Compsolids handling
+      for(std::map<GeomShapePtr, ListOfShape>::const_iterator anIt = aCompSolidsObjects.cbegin();
+          anIt != aCompSolidsObjects.cend(); ++anIt) {
+        GeomShapePtr aCompSolid = anIt->first;
+        const ListOfShape& aUsedShapes = anIt->second;
+
+        // Collecting solids from compsolids which will not be modified in boolean operation.
+        ListOfShape aShapesToAdd;
+        for (GeomAPI_ShapeIterator aCompSolidIt(aCompSolid);
+             aCompSolidIt.more();
+             aCompSolidIt.next())
+        {
+          GeomShapePtr aSolidInCompSolid = aCompSolidIt.current();
+          ListOfShape::const_iterator aUsedShapesIt = aUsedShapes.cbegin();
+          for(; aUsedShapesIt != aUsedShapes.cend(); ++aUsedShapesIt) {
+            if(aSolidInCompSolid->isEqual(*aUsedShapesIt)) {
+              break;
+            }
+          }
+          if(aUsedShapesIt == aUsedShapes.end()) {
+            aShapesToAdd.push_back(aSolidInCompSolid);
+          }
+        }
+
+        std::shared_ptr<GeomAlgoAPI_Boolean> aBoolAlgo(new GeomAlgoAPI_Boolean(aUsedShapes,
+                                                                  theTools,
+                                                                  GeomAlgoAPI_Tools::BOOL_CUT));
+
+        // Checking that the algorithm worked properly.
+        if(!aBoolAlgo->isDone() || aBoolAlgo->shape()->isNull() || !aBoolAlgo->isValid()) {
+          myFeature->setError("Error: Boolean algorithm failed.");
+          return false;
+        }
+
+        std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
+        aMakeShapeList->appendAlgo(aBoolAlgo);
+
+        // Add result to not used solids from compsolid.
+        GeomShapePtr aBoolRes = aBoolAlgo->shape();
+        if (!aShapesToAdd.empty()) {
+          aShapesToAdd.push_back(aBoolRes);
+          std::shared_ptr<GeomAlgoAPI_PaveFiller> aFillerAlgo(
+            new GeomAlgoAPI_PaveFiller(aShapesToAdd, true));
+          if(!aFillerAlgo->isDone() || aFillerAlgo->shape()->isNull() || !aFillerAlgo->isValid()) {
+            myFeature->setError("Error: PaveFiller algorithm failed.");
+            return false;
+          }
+          aBoolRes = aFillerAlgo->shape();
+          aMakeShapeList->appendAlgo(aFillerAlgo);
+        }
+
+        if(GeomAlgoAPI_ShapeTools::volume(aBoolRes) > 1.e-27) {
+          theObjects.push_back(aCompSolid);
+          theMakeShapes.push_back(aMakeShapeList);
         }
       }
       break;
     }
-    case GeomAlgoAPI_Boolean::BOOL_FUSE: {
+    case BOOL_FUSE: {
+      // Set objects.
+      theObjects.insert(theObjects.end(), anEdgesAndFaces.begin(), anEdgesAndFaces.end());
+      theObjects.insert(theObjects.end(), anObjects.begin(), anObjects.end());
+      theObjects.insert(theObjects.end(), aCompSolids.begin(), aCompSolids.end());
+
+      // Filter edges and faces in tools.
+      ListOfShape aTools;
+      for(ListOfShape::const_iterator anIt = theTools.cbegin(); anIt != theTools.cend(); ++anIt) {
+        if((*anIt)->shapeType() == GeomAPI_Shape::EDGE ||
+           (*anIt)->shapeType() == GeomAPI_Shape::FACE) {
+          anEdgesAndFaces.push_back(*anIt);
+        } else {
+          aTools.push_back(*anIt);
+        }
+      }
+
+      if((anObjects.size() + aTools.size() +
+          aCompSolidsObjects.size() + anEdgesAndFaces.size()) < 2) {
+        myFeature->setError("Error: Not enough objects for boolean operation.");
+        return false;
+      }
+
+      // 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<GeomShapePtr, ListOfShape>::iterator anIt = aCompSolidsObjects.begin();
+          anIt != aCompSolidsObjects.end(); anIt++) {
+        GeomShapePtr aCompSolid = anIt->first;
+        ListOfShape& aUsedShapes = anIt->second;
+        aSolidsToFuse.insert(aSolidsToFuse.end(), aUsedShapes.begin(), aUsedShapes.end());
+
+        // Collect solids from compsolid which will not be modified in boolean operation.
+        for (GeomAPI_ShapeIterator aCompSolidIt(aCompSolid);
+             aCompSolidIt.more();
+             aCompSolidIt.next())
+        {
+          GeomShapePtr aSolidInCompSolid = aCompSolidIt.current();
+          ListOfShape::iterator anIt = aUsedShapes.begin();
+          for(; anIt != aUsedShapes.end(); anIt++) {
+            if(aSolidInCompSolid->isEqual(*anIt)) {
+              break;
+            }
+          }
+          if(anIt == aUsedShapes.end()) {
+            aShapesToAdd.push_back(aSolidInCompSolid);
+          }
+        }
+      }
+
+      // Cut edges and faces(if we have any) with solids.
+      ListOfShape aCutTools;
+      aCutTools.insert(aCutTools.end(), anObjects.begin(), anObjects.end());
+      aCutTools.insert(aCutTools.end(), aCompSolids.begin(), aCompSolids.end());
+      aCutTools.insert(aCutTools.end(), aTools.begin(), aTools.end());
+
+      std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
+      if(!anEdgesAndFaces.empty() && !aCutTools.empty()) {
+        std::shared_ptr<GeomAlgoAPI_Boolean> aCutAlgo(new GeomAlgoAPI_Boolean(anEdgesAndFaces,
+                                                              aCutTools,
+                                                              GeomAlgoAPI_Tools::BOOL_CUT));
+        if(aCutAlgo->isDone() && !aCutAlgo->shape()->isNull() && aCutAlgo->isValid()) {
+          anEdgesAndFaces.clear();
+          anEdgesAndFaces.push_back(aCutAlgo->shape());
+          aMakeShapeList->appendAlgo(aCutAlgo);
+        }
+      }
+
+      // If we have compsolids then cut with not used solids all others.
+      if(!aShapesToAdd.empty()) {
+        std::shared_ptr<GeomAlgoAPI_Boolean> aCutAlgo(new GeomAlgoAPI_Boolean(aSolidsToFuse,
+                                                              aShapesToAdd,
+                                                              GeomAlgoAPI_Tools::BOOL_CUT));
+        if(aCutAlgo->isDone() && GeomAlgoAPI_ShapeTools::volume(aCutAlgo->shape()) > 1.e-27) {
+          aSolidsToFuse.clear();
+          aSolidsToFuse.push_back(aCutAlgo->shape());
+          aMakeShapeList->appendAlgo(aCutAlgo);
+        }
+      }
+
       // Fuse all objects and all tools.
-      GeomAlgoAPI_Boolean aBoolAlgo(aBooleanObjects, aBooleanTools, myBooleanOperationType);
+      GeomShapePtr aFusedShape;
+      if(aSolidsToFuse.size() == 1) {
+        aFusedShape = aSolidsToFuse.front();
+      } else if(aSolidsToFuse.size() > 1){
+        anObjects.clear();
+        anObjects.push_back(aSolidsToFuse.front());
+        aSolidsToFuse.pop_front();
+        aTools = aSolidsToFuse;
+
+        std::shared_ptr<GeomAlgoAPI_Boolean> aFuseAlgo(new GeomAlgoAPI_Boolean(anObjects,
+                                                          aTools,
+                                                          GeomAlgoAPI_Tools::BOOL_FUSE));
+
+        // Checking that the algorithm worked properly.
+        if(!aFuseAlgo->isDone() || aFuseAlgo->shape()->isNull() || !aFuseAlgo->isValid()) {
+          myFeature->setError("Error: Boolean algorithm failed.");
+          return false;
+        }
 
-      // Checking that the algorithm worked properly.
-      if(!aBoolAlgo.isDone() || aBoolAlgo.shape()->isNull() || !aBoolAlgo.isValid()) {
-        setError("Boolean algorithm failed");
-        return;
+        aFusedShape = aFuseAlgo->shape();
+        aMakeShapeList->appendAlgo(aFuseAlgo);
       }
 
-      std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
-      LoadNamingDS(aResultBody, aBooleanObjects.front(), aBooleanTools, aBoolAlgo);
-      setResult(aResultBody, aResultIndex);
-      aResultIndex++;
+      // Combine result with not used solids from compsolid and edges and faces (if we have any).
+      aShapesToAdd.insert(aShapesToAdd.end(), anEdgesAndFaces.begin(), anEdgesAndFaces.end());
+      if(!aShapesToAdd.empty()) {
+        if(aFusedShape.get()) {
+          aShapesToAdd.push_back(aFusedShape);
+        }
+
+        std::shared_ptr<GeomAlgoAPI_PaveFiller> aFillerAlgo(
+          new GeomAlgoAPI_PaveFiller(aShapesToAdd, true));
+        if(!aFillerAlgo->isDone() || aFillerAlgo->shape()->isNull() || !aFillerAlgo->isValid()) {
+          myFeature->setError("Error: PaveFiller algorithm failed.");
+          return false;
+        }
+
+        aMakeShapeList->appendAlgo(aFillerAlgo);
+      }
+
+      theMakeShapes.push_back(aMakeShapeList);
       break;
     }
-    default: {
-      setError("Error: wrong type of boolean operation");
-      return;
-    }
   }
 
-  // Remove the rest results if there were produced in the previous pass.
-  removeResults(aResultIndex);
+  return true;
 }
 
 //=================================================================================================
-void FeaturesPlugin_CompositeBoolean::LoadNamingDS(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
-                                                   const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
-                                                   const ListOfShape& theTools,
-                                                   const GeomAlgoAPI_Boolean& theAlgo)
+void FeaturesPlugin_CompositeBoolean::storeModificationHistory(ResultBodyPtr theResultBody,
+                                const GeomShapePtr theObject,
+                                const ListOfShape& theTools,
+                                const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape)
 {
-  //load result
-  if(theBaseShape->isEqual(theAlgo.shape())) {
-    theResultBody->store(theAlgo.shape());
-  } else {
-    theResultBody->storeModified(theBaseShape, theAlgo.shape());
-
-    GeomAPI_DataMapOfShapeShape* aSubShapes = new GeomAPI_DataMapOfShapeShape();
-
-    const int aModTag = 1;
-    const int aDeleteTag = 2;
-    const std::string aModName = "Modified";
-    theResultBody->loadAndOrientModifiedShapes(theAlgo.makeShape().get(), theBaseShape, GeomAPI_Shape::FACE,
-                                               aModTag, aModName, *theAlgo.mapOfShapes().get());
-    theResultBody->loadDeletedShapes(theAlgo.makeShape().get(), theBaseShape, GeomAPI_Shape::FACE, aDeleteTag);
-
-    for(ListOfShape::const_iterator anIter = theTools.begin(); anIter != theTools.end(); anIter++) {
-      theResultBody->loadAndOrientModifiedShapes(theAlgo.makeShape().get(), *anIter, GeomAPI_Shape::FACE,
-                                                 aModTag, aModName, *theAlgo.mapOfShapes().get());
-      theResultBody->loadDeletedShapes(theAlgo.makeShape().get(), *anIter, GeomAPI_Shape::FACE, aDeleteTag);
+  ListOfShape aTools = theTools;
+  aTools.push_back(theObject);
+
+  for(ListOfShape::const_iterator anIt = aTools.begin(); anIt != aTools.end(); anIt++) {
+    theResultBody->loadModifiedShapes(theMakeShape, *anIt,
+                                      (*anIt)->shapeType() == GeomAPI_Shape::EDGE ?
+                                                              GeomAPI_Shape::EDGE :
+                                                              GeomAPI_Shape::FACE);
+  }
+}
+
+//==================================================================================================
+void FeaturesPlugin_CompositeBoolean::storeDeletedShapes(
+  std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
+  const ListOfShape& theTools,
+  const GeomShapePtr theResultShapesCompound)
+{
+  for (std::vector<ResultBaseAlgo>::iterator anIt = theResultBaseAlgoList.begin();
+    anIt != theResultBaseAlgoList.end();
+    ++anIt)
+  {
+    ResultBaseAlgo& aRCA = *anIt;
+    aRCA.resultBody->loadDeletedShapes(aRCA.makeShape,
+      aRCA.baseShape,
+      GeomAPI_Shape::FACE,
+      theResultShapesCompound);
+
+    for (ListOfShape::const_iterator anIter = theTools.begin(); anIter != theTools.end(); anIter++)
+    {
+      aRCA.resultBody->loadDeletedShapes(aRCA.makeShape,
+        *anIter,
+        GeomAPI_Shape::FACE,
+        theResultShapesCompound);
     }
   }
 }