src/FeaturesPlugin/FeaturesPlugin_Tools.cpp

   1 // Copyright (C) 2014-2019  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 email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "FeaturesPlugin_Tools.h"
  21
  22 #include <ModelAPI_AttributeSelectionList.h>
  23 #include <ModelAPI_ResultBody.h>
  24 #include <ModelAPI_ResultConstruction.h>
  25 #include <ModelAPI_ResultPart.h>
  26 #include <ModelAPI_Tools.h>
  27
  28 #include <GeomAlgoAPI_CompoundBuilder.h>
  29 #include <GeomAlgoAPI_ShapeTools.h>
  30
  31 #include <GeomAPI_PlanarEdges.h>
  32 #include <GeomAPI_ShapeIterator.h>
  33
  34 //==================================================================================================
  35 void FeaturesPlugin_Tools::loadModifiedShapes(ResultBodyPtr theResultBody,
  36                                               const ListOfShape& theBaseShapes,
  37                                               const ListOfShape& theTools,
  38                                               const GeomMakeShapePtr& theMakeShape,
  39                                               const GeomShapePtr theResultShape,
  40                                               const std::string& theNamePrefix)
  41 {
  42   theResultBody->storeModified(theBaseShapes, theResultShape, theMakeShape);
  43
  44   ListOfShape aShapes = theBaseShapes;
  45   ListOfShape::const_iterator aToolIter = theTools.cbegin();
  46   for(; aToolIter != theTools.cend(); aToolIter++)
  47     aShapes.push_back(*aToolIter);
  48
  49   for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); ++anIter)
  50   {
  51     theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::VERTEX, theNamePrefix);
  52     theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::EDGE, theNamePrefix);
  53     theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE, theNamePrefix);
  54   }
  55 }
  56
  57 //==================================================================================================
  58 void FeaturesPlugin_Tools::loadModifiedShapes(ResultBodyPtr theResultBody,
  59                                               const GeomShapePtr& theBaseShape,
  60                                               const GeomMakeShapePtr& theMakeShape,
  61                                               const std::string theName)
  62 {
  63   switch(theBaseShape->shapeType()) {
  64     case GeomAPI_Shape::COMPOUND: {
  65       for(GeomAPI_ShapeIterator anIt(theBaseShape); anIt.more(); anIt.next())
  66       {
  67         loadModifiedShapes(theResultBody,
  68                            anIt.current(),
  69                            theMakeShape,
  70                            theName);
  71       }
  72       break;
  73     }
  74     case GeomAPI_Shape::COMPSOLID:
  75     case GeomAPI_Shape::SOLID:
  76     case GeomAPI_Shape::SHELL: {
  77       theResultBody->loadModifiedShapes(theMakeShape,
  78                                         theBaseShape,
  79                                         GeomAPI_Shape::FACE,
  80                                         theName);
  81     }
  82     case GeomAPI_Shape::FACE:
  83     case GeomAPI_Shape::WIRE: {
  84       theResultBody->loadModifiedShapes(theMakeShape,
  85                                         theBaseShape,
  86                                         GeomAPI_Shape::EDGE,
  87                                         theName);
  88     }
  89     case GeomAPI_Shape::EDGE: {
  90       theResultBody->loadModifiedShapes(theMakeShape,
  91                                         theBaseShape,
  92                                         GeomAPI_Shape::VERTEX,
  93                                         theName);
  94     }
  95   }
  96 }
  97
  98 //==================================================================================================
  99 void FeaturesPlugin_Tools::loadDeletedShapes(ResultBodyPtr theResultBody,
 100   const GeomShapePtr theBaseShape,
 101   const ListOfShape& theTools,
 102   const GeomMakeShapePtr& theMakeShape,
 103   const GeomShapePtr theResultShapesCompound)
 104 {
 105   ListOfShape aShapes = theTools;
 106   if (theBaseShape.get())
 107     aShapes.push_front(theBaseShape);
 108
 109   for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); anIter++)
 110   {
 111     theResultBody->loadDeletedShapes(theMakeShape,
 112                                      *anIter,
 113                                      GeomAPI_Shape::VERTEX,
 114                                      theResultShapesCompound);
 115     theResultBody->loadDeletedShapes(theMakeShape,
 116                                      *anIter,
 117                                      GeomAPI_Shape::EDGE,
 118                                      theResultShapesCompound);
 119     theResultBody->loadDeletedShapes(theMakeShape,
 120                                      *anIter,
 121                                      GeomAPI_Shape::FACE,
 122                                      theResultShapesCompound);
 123   }
 124 }
 125
 126 //==================================================================================================
 127 void FeaturesPlugin_Tools::loadDeletedShapes(
 128   std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
 129   const ListOfShape& theTools,
 130   const GeomShapePtr theResultShapesCompound)
 131 {
 132   for (std::vector<ResultBaseAlgo>::iterator anIt = theResultBaseAlgoList.begin();
 133        anIt != theResultBaseAlgoList.end();
 134        ++anIt)
 135   {
 136     ResultBaseAlgo& aRCA = *anIt;
 137     loadDeletedShapes(aRCA.resultBody,
 138                       aRCA.baseShape,
 139                       theTools,
 140                       aRCA.makeShape,
 141                       theResultShapesCompound);
 142   }
 143 }
 144
 145 //==================================================================================================
 146 bool FeaturesPlugin_Tools::getShape(const AttributeSelectionListPtr theSelectionList,
 147                                     const bool theShareTopology,
 148                                     ListOfShape& theShapesList,
 149                                     std::string& theError)
 150 {
 151   theShapesList.clear();
 152
 153   ListOfShape aBaseFacesList;
 154   std::map<ResultConstructionPtr, ListOfShape> aSketchWiresMap;
 155   if(!theSelectionList.get()) {
 156     theError = "Error: Could not get base objects selection list.";
 157     return false;
 158   }
 159   if(theSelectionList->size() == 0) {
 160     theError = "Error: Base objects list is empty.";
 161     return false;
 162   }
 163   for(int anIndex = 0; anIndex < theSelectionList->size(); anIndex++) {
 164     AttributeSelectionPtr aBaseObjectSelection = theSelectionList->value(anIndex);
 165     if(!aBaseObjectSelection.get()) {
 166       theError = "Error: Selected base object is empty.";
 167       return false;
 168     }
 169     GeomShapePtr aBaseShape = aBaseObjectSelection->value();
 170     if(aBaseShape.get() && !aBaseShape->isNull()) {
 171       GeomAPI_Shape::ShapeType aST = aBaseShape->shapeType();
 172       if(aST == GeomAPI_Shape::SOLID || aST == GeomAPI_Shape::COMPSOLID) {
 173         theError = "Error: Selected shapes has unsupported type.";
 174         return false;
 175       }
 176       ResultConstructionPtr aConstruction =
 177         std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aBaseObjectSelection->context());
 178       if(aConstruction.get() && !aBaseShape->isEqual(aConstruction->shape()) &&
 179           aST == GeomAPI_Shape::WIRE) {
 180         // It is a wire on the sketch, store it to make face later.
 181         aSketchWiresMap[aConstruction].push_back(aBaseShape);
 182         continue;
 183       } else {
 184       aST == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
 185                                    theShapesList.push_back(aBaseShape);
 186       }
 187     } else {
 188       // This may be the whole sketch result selected, check and get faces.
 189       ResultConstructionPtr aConstruction =
 190         std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aBaseObjectSelection->context());
 191       if(!aConstruction.get()) {
 192         theError = "Error: Selected sketches does not have results.";
 193         return false;
 194       }
 195       int aFacesNum = aConstruction->facesNum();
 196       if(aFacesNum == 0) {
 197         // Probably it can be construction.
 198         aBaseShape = aConstruction->shape();
 199         if(aBaseShape.get() && !aBaseShape->isNull()) {
 200           GeomAPI_Shape::ShapeType aST = aBaseShape->shapeType();
 201           if(aST != GeomAPI_Shape::VERTEX && aST != GeomAPI_Shape::EDGE &&
 202              aST != GeomAPI_Shape::WIRE &&
 203              aST != GeomAPI_Shape::FACE && aST != GeomAPI_Shape::SHELL) {
 204             theError = "Error: Selected shapes has unsupported type.";
 205             return false;
 206           }
 207           aST == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
 208                                        theShapesList.push_back(aBaseShape);
 209         }
 210       } else {
 211         for(int aFaceIndex = 0; aFaceIndex < aFacesNum; aFaceIndex++) {
 212           GeomShapePtr aBaseFace = aConstruction->face(aFaceIndex);
 213           if(!aBaseFace.get() || aBaseFace->isNull()) {
 214             theError = "Error: One of the faces on selected sketch is null.";
 215             return false;
 216           }
 217           aBaseFacesList.push_back(aBaseFace);
 218         }
 219       }
 220     }
 221   }
 222
 223   // Make faces from sketch wires.
 224   for(std::map<ResultConstructionPtr, ListOfShape>::const_iterator anIt = aSketchWiresMap.cbegin();
 225       anIt != aSketchWiresMap.cend(); ++anIt) {
 226     const std::shared_ptr<GeomAPI_PlanarEdges> aSketchPlanarEdges =
 227         std::dynamic_pointer_cast<GeomAPI_PlanarEdges>((*anIt).first->shape());
 228     const ListOfShape& aWiresList = (*anIt).second;
 229     ListOfShape aFaces;
 230     GeomAlgoAPI_ShapeTools::makeFacesWithHoles(aSketchPlanarEdges->origin(),
 231                                                aSketchPlanarEdges->norm(),
 232                                                aWiresList,
 233                                                aFaces);
 234     aBaseFacesList.insert(aBaseFacesList.end(), aFaces.begin(), aFaces.end());
 235   }
 236
 237   // Searching faces with common edges.
 238   if(theShareTopology && aBaseFacesList.size() > 1) {
 239     GeomShapePtr aFacesCompound = GeomAlgoAPI_CompoundBuilder::compound(aBaseFacesList);
 240     GeomAlgoAPI_ShapeTools::combineShapes(aFacesCompound, GeomAPI_Shape::SHELL, theShapesList);
 241   } else {
 242     theShapesList.insert(theShapesList.end(), aBaseFacesList.begin(), aBaseFacesList.end());
 243   }
 244   return true;
 245 }
 246
 247 //==================================================================================================
 248 bool FeaturesPlugin_Tools::shapesFromSelectionList(
 249     const std::shared_ptr<ModelAPI_AttributeSelectionList> theSelectionList,
 250     const bool theStoreFullHierarchy,
 251     GeomAPI_ShapeHierarchy& theHierarchy,
 252     std::list<ResultPtr>& theParts)
 253 {
 254   int aSize = theSelectionList->size();
 255   for (int anObjectsIndex = 0; anObjectsIndex < aSize; anObjectsIndex++) {
 256     AttributeSelectionPtr anObjectAttr = theSelectionList->value(anObjectsIndex);
 257     std::shared_ptr<GeomAPI_Shape> anObject = anObjectAttr->value();
 258     if (!anObject.get()) { // may be for not-activated parts
 259       return false;
 260     }
 261     ResultPtr aContext = anObjectAttr->context();
 262     if (aContext->groupName() == ModelAPI_ResultPart::group())
 263       theParts.push_back(aContext);
 264     else {
 265       // store full shape hierarchy for the corresponding version only
 266       theHierarchy.addObject(anObject);
 267       if (theStoreFullHierarchy)
 268         ModelAPI_Tools::fillShapeHierarchy(anObject, aContext, theHierarchy);
 269     }
 270   }
 271   return true;
 272 }