src/FeaturesPlugin/FeaturesPlugin_BooleanSmash.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "FeaturesPlugin_BooleanSmash.h"
  22
  23 #include <ModelAPI_ResultBody.h>
  24 #include <ModelAPI_AttributeSelectionList.h>
  25 #include <ModelAPI_Tools.h>
  26
  27 #include <GeomAlgoAPI_Boolean.h>
  28 #include <GeomAlgoAPI_CompoundBuilder.h>
  29 #include <GeomAlgoAPI_MakeShapeList.h>
  30 #include <GeomAlgoAPI_PaveFiller.h>
  31 #include <GeomAlgoAPI_ShapeTools.h>
  32 #include <GeomAPI_ShapeExplorer.h>
  33 #include <GeomAPI_ShapeIterator.h>
  34
  35 //==================================================================================================
  36 FeaturesPlugin_BooleanSmash::FeaturesPlugin_BooleanSmash()
  37 : FeaturesPlugin_Boolean(FeaturesPlugin_Boolean::BOOL_SMASH)
  38 {
  39 }
  40
  41 //==================================================================================================
  42 void FeaturesPlugin_BooleanSmash::initAttributes()
  43 {
  44   data()->addAttribute(OBJECT_LIST_ID(), ModelAPI_AttributeSelectionList::typeId());
  45   data()->addAttribute(TOOL_LIST_ID(), ModelAPI_AttributeSelectionList::typeId());
  46 }
  47
  48 //==================================================================================================
  49 void FeaturesPlugin_BooleanSmash::execute()
  50 {
  51   ListOfShape anObjects, aTools;
  52   std::map<std::shared_ptr<GeomAPI_Shape>, ListOfShape> aCompSolidsObjects;
  53
  54   // Getting objects.
  55   AttributeSelectionListPtr anObjectsSelList = selectionList(OBJECT_LIST_ID());
  56   for(int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) {
  57     AttributeSelectionPtr anObjectAttr = anObjectsSelList->value(anObjectsIndex);
  58     std::shared_ptr<GeomAPI_Shape> anObject = anObjectAttr->value();
  59     if(!anObject.get()) {
  60       return;
  61     }
  62     ResultPtr aContext = anObjectAttr->context();
  63     ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext);
  64     if (aResCompSolidPtr.get())
  65     {
  66       std::shared_ptr<GeomAPI_Shape> aContextShape = aResCompSolidPtr->shape();
  67
  68       std::map<std::shared_ptr<GeomAPI_Shape>, ListOfShape>::iterator
  69         anIt = aCompSolidsObjects.begin();
  70       for (; anIt != aCompSolidsObjects.end(); anIt++) {
  71         if (anIt->first->isEqual(aContextShape)) {
  72           aCompSolidsObjects[anIt->first].push_back(anObject);
  73           break;
  74         }
  75       }
  76       if (anIt == aCompSolidsObjects.end()) {
  77         aCompSolidsObjects[aContextShape].push_back(anObject);
  78       }
  79
  80     } else {
  81       anObjects.push_back(anObject);
  82     }
  83   }
  84
  85   // Getting tools.
  86   AttributeSelectionListPtr aToolsSelList = selectionList(TOOL_LIST_ID());
  87   for(int aToolsIndex = 0; aToolsIndex < aToolsSelList->size(); aToolsIndex++) {
  88     AttributeSelectionPtr aToolAttr = aToolsSelList->value(aToolsIndex);
  89     GeomShapePtr aTool = aToolAttr->value();
  90     if(!aTool.get()) {
  91       return;
  92     }
  93     aTools.push_back(aTool);
  94   }
  95
  96   int aResultIndex = 0;
  97
  98   if((anObjects.empty() && aCompSolidsObjects.empty())
  99      || aTools.empty()) {
 100     std::string aFeatureError = "Error: Not enough objects for boolean operation.";
 101     setError(aFeatureError);
 102     return;
 103   }
 104
 105   // List of original shapes for naming.
 106   ListOfShape anOriginalShapes;
 107   anOriginalShapes.insert(anOriginalShapes.end(), anObjects.begin(), anObjects.end());
 108   anOriginalShapes.insert(anOriginalShapes.end(), aTools.begin(), aTools.end());
 109
 110   // Collecting all shapes which will be smashed.
 111   ListOfShape aShapesToSmash;
 112   aShapesToSmash.insert(aShapesToSmash.end(), anObjects.begin(), anObjects.end());
 113
 114   // Collecting solids from compsolids which will not be modified in
 115   // boolean operation and will be added to result.
 116   ListOfShape aShapesToAdd;
 117   for (std::map<std::shared_ptr<GeomAPI_Shape>, ListOfShape>::iterator
 118        anIt = aCompSolidsObjects.begin();
 119        anIt != aCompSolidsObjects.end();
 120        ++anIt)
 121   {
 122     std::shared_ptr<GeomAPI_Shape> aCompSolid = anIt->first;
 123     ListOfShape& aUsedInOperationSolids = anIt->second;
 124     anOriginalShapes.push_back(aCompSolid);
 125     aShapesToSmash.insert(aShapesToSmash.end(),
 126                           aUsedInOperationSolids.begin(),
 127                           aUsedInOperationSolids.end());
 128
 129     // Collect solids from compsolid which will not be modified in boolean operation.
 130     for (GeomAPI_ShapeExplorer anExp(aCompSolid, GeomAPI_Shape::SOLID);
 131          anExp.more();
 132          anExp.next())
 133     {
 134       std::shared_ptr<GeomAPI_Shape> aSolidInCompSolid = anExp.current();
 135       ListOfShape::iterator anIt = aUsedInOperationSolids.begin();
 136       for (; anIt != aUsedInOperationSolids.end(); anIt++) {
 137         if (aSolidInCompSolid->isEqual(*anIt)) {
 138           break;
 139         }
 140       }
 141       if (anIt == aUsedInOperationSolids.end()) {
 142         aShapesToAdd.push_back(aSolidInCompSolid);
 143       }
 144     }
 145   }
 146
 147   GeomAlgoAPI_MakeShapeList aMakeShapeList;
 148   GeomAPI_DataMapOfShapeShape aMapOfShapes;
 149   if (!aShapesToAdd.empty()) {
 150     // Cut objects with not used solids.
 151     std::shared_ptr<GeomAlgoAPI_Boolean> anObjectsCutAlgo(
 152       new GeomAlgoAPI_Boolean(aShapesToSmash,
 153                               aShapesToAdd,
 154                               GeomAlgoAPI_Boolean::BOOL_CUT));
 155
 156     if (GeomAlgoAPI_ShapeTools::volume(anObjectsCutAlgo->shape()) > 1.e-27) {
 157       aShapesToSmash.clear();
 158       aShapesToSmash.push_back(anObjectsCutAlgo->shape());
 159       aMakeShapeList.appendAlgo(anObjectsCutAlgo);
 160       aMapOfShapes.merge(anObjectsCutAlgo->mapOfSubShapes());
 161     }
 162
 163     // Cut tools with not used solids.
 164     std::shared_ptr<GeomAlgoAPI_Boolean> aToolsCutAlgo(
 165       new GeomAlgoAPI_Boolean(aTools,
 166                               aShapesToAdd,
 167                               GeomAlgoAPI_Boolean::BOOL_CUT));
 168
 169     if (GeomAlgoAPI_ShapeTools::volume(aToolsCutAlgo->shape()) > 1.e-27) {
 170       aTools.clear();
 171       aTools.push_back(aToolsCutAlgo->shape());
 172       aMakeShapeList.appendAlgo(aToolsCutAlgo);
 173       aMapOfShapes.merge(aToolsCutAlgo->mapOfSubShapes());
 174     }
 175   }
 176
 177   // Cut objects with tools.
 178   std::shared_ptr<GeomAlgoAPI_Boolean> aBoolAlgo(
 179     new GeomAlgoAPI_Boolean(aShapesToSmash,
 180                             aTools,
 181                             GeomAlgoAPI_Boolean::BOOL_CUT));
 182
 183   // Checking that the algorithm worked properly.
 184   if (!aBoolAlgo->isDone()) {
 185     static const std::string aFeatureError = "Error: Boolean algorithm failed.";
 186     setError(aFeatureError);
 187     return;
 188   }
 189   if (aBoolAlgo->shape()->isNull()) {
 190     static const std::string aShapeError = "Error: Resulting shape is Null.";
 191     setError(aShapeError);
 192     return;
 193   }
 194   if (!aBoolAlgo->isValid()) {
 195     std::string aFeatureError = "Error: Resulting shape is not valid.";
 196     setError(aFeatureError);
 197     return;
 198   }
 199   aMakeShapeList.appendAlgo(aBoolAlgo);
 200   aMapOfShapes.merge(aBoolAlgo->mapOfSubShapes());
 201
 202   // Put all (cut result, tools and not used solids) to PaveFiller.
 203   GeomShapePtr aShape = aBoolAlgo->shape();
 204   GeomAPI_ShapeIterator anIt(aShape);
 205   if (anIt.more() || aShape->shapeType() == GeomAPI_Shape::VERTEX) {
 206     aShapesToAdd.push_back(aShape);
 207   }
 208   aShapesToAdd.insert(aShapesToAdd.end(), aTools.begin(), aTools.end());
 209
 210   if (aShapesToAdd.size() == 1) {
 211     aShape = aShapesToAdd.front();
 212   }
 213   else {
 214     std::shared_ptr<GeomAlgoAPI_PaveFiller> aFillerAlgo(
 215       new GeomAlgoAPI_PaveFiller(aShapesToAdd, true));
 216     if (!aFillerAlgo->isDone()) {
 217       std::string aFeatureError = "Error: PaveFiller algorithm failed.";
 218       setError(aFeatureError);
 219       return;
 220     }
 221     if (aFillerAlgo->shape()->isNull()) {
 222       static const std::string aShapeError = "Error: Resulting shape is Null.";
 223       setError(aShapeError);
 224       return;
 225     }
 226     if (!aFillerAlgo->isValid()) {
 227       std::string aFeatureError = "Error: Resulting shape is not valid.";
 228       setError(aFeatureError);
 229       return;
 230     }
 231
 232     aShape = aFillerAlgo->shape();
 233     aMakeShapeList.appendAlgo(aFillerAlgo);
 234     aMapOfShapes.merge(aFillerAlgo->mapOfSubShapes());
 235   }
 236
 237   std::shared_ptr<GeomAPI_Shape> aFrontShape = anOriginalShapes.front();
 238   anOriginalShapes.pop_front();
 239   std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
 240   loadNamingDS(aResultBody,
 241                aFrontShape,
 242                anOriginalShapes,
 243                aShape,
 244                aMakeShapeList,
 245                aMapOfShapes);
 246
 247   setResult(aResultBody, aResultIndex);
 248   aResultIndex++;
 249
 250   // remove the rest results if there were produced in the previous pass
 251   removeResults(aResultIndex);
 252 }
 253
 254 //==================================================================================================
 255 void FeaturesPlugin_BooleanSmash::loadNamingDS(ResultBodyPtr theResultBody,
 256                                              const GeomShapePtr theBaseShape,
 257                                              const ListOfShape& theTools,
 258                                              const GeomShapePtr theResultShape,
 259                                              GeomAlgoAPI_MakeShape& theMakeShape,
 260                                              GeomAPI_DataMapOfShapeShape& theMapOfShapes)
 261 {
 262   //load result
 263   if (theBaseShape->isEqual(theResultShape)) {
 264     theResultBody->store(theResultShape, false);
 265   } else if (theResultShape->isEqual(theTools.front())) {
 266     theResultBody->store(theResultShape, false);
 267   } else {
 268     const int aModifyVTag = 1;
 269     const int aModifyETag = 2;
 270     const int aModifyFTag = 3;
 271     const int aDeletedTag = 4;
 272     /// sub solids will be placed at labels 5, 6, etc. if result is compound of solids
 273     const int aSubsolidsTag = 5;
 274
 275     theResultBody->storeModified(theBaseShape, theResultShape, aSubsolidsTag);
 276
 277     const std::string aModVName = "Modified_Vertex";
 278     const std::string aModEName = "Modified_Edge";
 279     const std::string aModFName = "Modified_Face";
 280
 281     theResultBody->loadAndOrientModifiedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::VERTEX,
 282                                                aModifyVTag, aModVName, theMapOfShapes, false,
 283                                                true, true);
 284     theResultBody->loadAndOrientModifiedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::EDGE,
 285                                                aModifyETag, aModEName, theMapOfShapes, false,
 286                                                true, true);
 287     theResultBody->loadAndOrientModifiedShapes(&theMakeShape, theBaseShape, GeomAPI_Shape::FACE,
 288                                                aModifyFTag, aModFName, theMapOfShapes, false,
 289                                                true, true);
 290
 291     theResultBody->loadDeletedShapes(&theMakeShape, theBaseShape,
 292                                      GeomAPI_Shape::VERTEX, aDeletedTag);
 293     theResultBody->loadDeletedShapes(&theMakeShape, theBaseShape,
 294                                      GeomAPI_Shape::EDGE, aDeletedTag);
 295     theResultBody->loadDeletedShapes(&theMakeShape, theBaseShape,
 296                                      GeomAPI_Shape::FACE, aDeletedTag);
 297
 298     for (ListOfShape::const_iterator anIter = theTools.begin(); anIter != theTools.end(); anIter++)
 299     {
 300       theResultBody->loadAndOrientModifiedShapes(&theMakeShape, *anIter, GeomAPI_Shape::VERTEX,
 301                                                  aModifyVTag, aModVName, theMapOfShapes, false,
 302                                                  true, true);
 303
 304       theResultBody->loadAndOrientModifiedShapes(&theMakeShape, *anIter, GeomAPI_Shape::EDGE,
 305                                                  aModifyETag, aModEName, theMapOfShapes, false,
 306                                                  true, true);
 307
 308       theResultBody->loadAndOrientModifiedShapes(&theMakeShape, *anIter, GeomAPI_Shape::FACE,
 309                                                  aModifyFTag, aModFName, theMapOfShapes, false,
 310                                                  true, true);
 311
 312       theResultBody->loadDeletedShapes(&theMakeShape, *anIter, GeomAPI_Shape::VERTEX, aDeletedTag);
 313       theResultBody->loadDeletedShapes(&theMakeShape, *anIter, GeomAPI_Shape::EDGE, aDeletedTag);
 314       theResultBody->loadDeletedShapes(&theMakeShape, *anIter, GeomAPI_Shape::FACE, aDeletedTag);
 315     }
 316   }
 317 }