]> SALOME platform Git repositories - modules/shaper.git/blob - src/FeaturesPlugin/FeaturesPlugin_CompositeSketch.cpp
Salome HOME
Fix for the issue #2197 : additional cases where full revolution consists of 3 and...
[modules/shaper.git] / src / FeaturesPlugin / FeaturesPlugin_CompositeSketch.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_CompositeSketch.h>
22
23 #include <ModelAPI_AttributeSelectionList.h>
24 #include <ModelAPI_AttributeReference.h>
25 #include <ModelAPI_BodyBuilder.h>
26 #include <ModelAPI_ResultConstruction.h>
27 #include <ModelAPI_Session.h>
28 #include <ModelAPI_Validator.h>
29
30 #include <GeomAlgoAPI_CompoundBuilder.h>
31 #include <GeomAlgoAPI_Prism.h>
32 #include <GeomAlgoAPI_Revolution.h>
33 #include <GeomAlgoAPI_ShapeTools.h>
34 #include <GeomAlgoAPI_SketchBuilder.h>
35
36 #include <GeomAPI_PlanarEdges.h>
37 #include <GeomAPI_ShapeExplorer.h>
38
39 #include <map>
40 #include <sstream>
41
42 static void storeSubShape(ResultBodyPtr theResultBody,
43                           const GeomShapePtr theShape,
44                           const GeomAPI_Shape::ShapeType theType,
45                           const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
46                           const std::string theName,
47                           int& theShapeIndex,
48                           int& theTag);
49
50 //=================================================================================================
51 void FeaturesPlugin_CompositeSketch::initCompositeSketchAttribtues(const int theInitFlags)
52 {
53   // Initialize sketch launcher.
54   if(theInitFlags & InitSketchLauncher) {
55     data()->addAttribute(SKETCH_ID(), ModelAPI_AttributeReference::typeId());
56     ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), SKETCH_ID());
57   }
58
59   // Initialize selection list.
60   if(theInitFlags & InitBaseObjectsList) {
61     data()->addAttribute(BASE_OBJECTS_ID(), ModelAPI_AttributeSelectionList::typeId());
62   }
63 }
64
65 //=================================================================================================
66 std::shared_ptr<ModelAPI_Feature> FeaturesPlugin_CompositeSketch::addFeature(std::string theID)
67 {
68   FeaturePtr aNew = document()->addFeature(theID, false);
69   if(aNew) {
70     data()->reference(SKETCH_ID())->setValue(aNew);
71   }
72
73   // Set as current also after it becomes sub to set correctly enabled for other sketch subs.
74   document()->setCurrentFeature(aNew, false);
75   return aNew;
76 }
77
78 //=================================================================================================
79 int FeaturesPlugin_CompositeSketch::numberOfSubs(bool forTree) const
80 {
81   ObjectPtr aObj = data()->reference(SKETCH_ID())->value();
82   return aObj.get() ? 1 : 0;
83 }
84
85 //=================================================================================================
86 std::shared_ptr<ModelAPI_Feature> FeaturesPlugin_CompositeSketch::subFeature(const int theIndex,
87                                                                              bool forTree)
88 {
89   if(theIndex == 0) {
90     return std::dynamic_pointer_cast<ModelAPI_Feature>(data()->reference(SKETCH_ID())->value());
91   }
92
93   return std::shared_ptr<ModelAPI_Feature>();
94 }
95
96 //=================================================================================================
97 int FeaturesPlugin_CompositeSketch::subFeatureId(const int theIndex) const
98 {
99   if(theIndex == 0) {
100     FeaturePtr aFeature =
101       std::dynamic_pointer_cast<ModelAPI_Feature>(data()->reference(SKETCH_ID())->value());
102     if(aFeature.get()) {
103       return aFeature->data()->featureId();
104     }
105   }
106
107   return -1;
108 }
109
110 //=================================================================================================
111 bool FeaturesPlugin_CompositeSketch::isSub(ObjectPtr theObject) const
112 {
113   // Check is this feature of result
114   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
115   if(!aFeature.get()) {
116     return false;
117   }
118
119   ObjectPtr aSub = data()->reference(SKETCH_ID())->value();
120   return aSub == theObject;
121 }
122
123 //=================================================================================================
124 void FeaturesPlugin_CompositeSketch::removeFeature(std::shared_ptr<ModelAPI_Feature> theFeature)
125 {
126   AttributeSelectionListPtr aBaseObjectsSelectionList = selectionList(BASE_OBJECTS_ID());
127   if(aBaseObjectsSelectionList.get() && aBaseObjectsSelectionList->size() > 0) {
128     aBaseObjectsSelectionList->clear();
129   }
130
131   reference(SKETCH_ID())->setValue(ObjectPtr());
132 }
133
134 //=================================================================================================
135 void FeaturesPlugin_CompositeSketch::getBaseShapes(ListOfShape& theBaseShapesList,
136                                                    const bool theIsMakeShells)
137 {
138   theBaseShapesList.clear();
139
140   ListOfShape aBaseFacesList;
141   std::map<ResultConstructionPtr, ListOfShape> aSketchWiresMap;
142   AttributeSelectionListPtr aBaseObjectsSelectionList = selectionList(BASE_OBJECTS_ID());
143   if(!aBaseObjectsSelectionList.get()) {
144     setError("Error: Could not get base objects selection list.");
145     return;
146   }
147   if(aBaseObjectsSelectionList->size() == 0) {
148     setError("Error: Base objects list is empty.");
149     return;
150   }
151   for(int anIndex = 0; anIndex < aBaseObjectsSelectionList->size(); anIndex++) {
152     AttributeSelectionPtr aBaseObjectSelection = aBaseObjectsSelectionList->value(anIndex);
153     if(!aBaseObjectSelection.get()) {
154       setError("Error: Selected base object is empty.");
155       return;
156     }
157     GeomShapePtr aBaseShape = aBaseObjectSelection->value();
158     if(aBaseShape.get() && !aBaseShape->isNull()) {
159       GeomAPI_Shape::ShapeType aST = aBaseShape->shapeType();
160       if(aST == GeomAPI_Shape::SOLID || aST == GeomAPI_Shape::COMPSOLID) {
161         setError("Error: Selected shapes has unsupported type.");
162         return;
163       }
164       ResultConstructionPtr aConstruction =
165         std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aBaseObjectSelection->context());
166       if(aConstruction.get() && !aBaseShape->isEqual(aConstruction->shape()) &&
167           aST == GeomAPI_Shape::WIRE) {
168         // It is a wire on the sketch, store it to make face later.
169         aSketchWiresMap[aConstruction].push_back(aBaseShape);
170         continue;
171       } else {
172       aST == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
173                                    theBaseShapesList.push_back(aBaseShape);
174       }
175     } else {
176       // This may be the whole sketch result selected, check and get faces.
177       ResultConstructionPtr aConstruction =
178         std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aBaseObjectSelection->context());
179       if(!aConstruction.get()) {
180         setError("Error: Selected sketches does not have results.");
181         return;
182       }
183       int aFacesNum = aConstruction->facesNum();
184       if(aFacesNum == 0) {
185         // Probably it can be construction.
186         aBaseShape = aConstruction->shape();
187         if(aBaseShape.get() && !aBaseShape->isNull()) {
188           GeomAPI_Shape::ShapeType aST = aBaseShape->shapeType();
189           if(aST != GeomAPI_Shape::VERTEX && aST != GeomAPI_Shape::EDGE &&
190              aST != GeomAPI_Shape::WIRE &&
191              aST != GeomAPI_Shape::FACE && aST != GeomAPI_Shape::SHELL) {
192             setError("Error: Selected shapes has unsupported type.");
193             return;
194           }
195           aST == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
196                                        theBaseShapesList.push_back(aBaseShape);
197         }
198       } else {
199         for(int aFaceIndex = 0; aFaceIndex < aFacesNum; aFaceIndex++) {
200           GeomShapePtr aBaseFace = aConstruction->face(aFaceIndex);
201           if(!aBaseFace.get() || aBaseFace->isNull()) {
202             setError("Error: One of the faces on selected sketch is null.");
203             return;
204           }
205           aBaseFacesList.push_back(aBaseFace);
206         }
207       }
208     }
209   }
210
211   // Make faces from sketch wires.
212   for(std::map<ResultConstructionPtr, ListOfShape>::const_iterator anIt = aSketchWiresMap.cbegin();
213       anIt != aSketchWiresMap.cend(); ++anIt) {
214     const std::shared_ptr<GeomAPI_PlanarEdges> aSketchPlanarEdges =
215       std::dynamic_pointer_cast<GeomAPI_PlanarEdges>((*anIt).first->shape());
216     const ListOfShape& aWiresList = (*anIt).second;
217     ListOfShape aFaces;
218     GeomAlgoAPI_ShapeTools::makeFacesWithHoles(aSketchPlanarEdges->origin(),
219                                                aSketchPlanarEdges->norm(),
220                                                aWiresList,
221                                                aFaces);
222     aBaseFacesList.insert(aBaseFacesList.end(), aFaces.begin(), aFaces.end());
223   }
224
225   // Searching faces with common edges.
226   if(theIsMakeShells && aBaseFacesList.size() > 1) {
227     ListOfShape aShells;
228     ListOfShape aFreeFaces;
229     GeomShapePtr aFacesCompound = GeomAlgoAPI_CompoundBuilder::compound(aBaseFacesList);
230     GeomAlgoAPI_ShapeTools::combineShapes(aFacesCompound, GeomAPI_Shape::SHELL,
231                                           aShells, aFreeFaces);
232     theBaseShapesList.insert(theBaseShapesList.end(), aFreeFaces.begin(), aFreeFaces.end());
233     theBaseShapesList.insert(theBaseShapesList.end(), aShells.begin(), aShells.end());
234   } else {
235     theBaseShapesList.insert(theBaseShapesList.end(), aBaseFacesList.begin(),
236                              aBaseFacesList.end());
237   }
238 }
239
240 //=================================================================================================
241 bool FeaturesPlugin_CompositeSketch::isMakeShapeValid(
242   const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape)
243 {
244   // Check that algo is done.
245   if(!theMakeShape->isDone()) {
246     setError("Error: " + getKind() + " algorithm failed.");
247     return false;
248   }
249
250   // Check if shape is not null.
251   if(!theMakeShape->shape().get() || theMakeShape->shape()->isNull()) {
252     setError("Error: Resulting shape is null.");
253     return false;
254   }
255
256   // Check that resulting shape is valid.
257   if(!theMakeShape->isValid()) {
258     setError("Error: Resulting shape is not valid.");
259     return false;
260   }
261
262   return true;
263 }
264
265 //=================================================================================================
266 void FeaturesPlugin_CompositeSketch::storeResult(const GeomShapePtr theBaseShape,
267                                         const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
268                                         const int theIndex)
269 {
270   // Create result body.
271   ResultBodyPtr aResultBody = document()->createBody(data(), theIndex);
272
273   // Store generated shape.
274   aResultBody->storeGenerated(theBaseShape, theMakeShape->shape());
275
276   // Store generated edges/faces.
277   int aGenTag = 1;
278   storeGenerationHistory(aResultBody, theBaseShape, theMakeShape, aGenTag);
279
280   setResult(aResultBody, theIndex);
281 }
282
283 //=================================================================================================
284 void FeaturesPlugin_CompositeSketch::storeGenerationHistory(ResultBodyPtr theResultBody,
285                                         const GeomShapePtr theBaseShape,
286                                         const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
287                                         int& theTag)
288 {
289   GeomAPI_Shape::ShapeType aBaseShapeType = theBaseShape->shapeType();
290   GeomAPI_Shape::ShapeType aShapeTypeToExplode = GeomAPI_Shape::SHAPE;
291   std::string aGenName = "Generated_";
292
293   std::shared_ptr<GeomAPI_DataMapOfShapeShape> aMapOfSubShapes = theMakeShape->mapOfSubShapes();
294   switch(aBaseShapeType) {
295     case GeomAPI_Shape::EDGE: {
296             aShapeTypeToExplode = GeomAPI_Shape::VERTEX;
297       break;
298     }
299     case GeomAPI_Shape::WIRE: {
300       //std::shared_ptr<GeomAPI_Vertex> aV1, aV2;
301       //GeomAlgoAPI_ShapeTools::findBounds(theBaseShape, aV1, aV2);
302       //ListOfShape aV1History, aV2History;
303       //theMakeShape->generated(aV1, aV1History);
304       //theMakeShape->generated(aV2, aV2History);
305       //if(!aV1History.empty()) {
306       //  theResultBody->generated(aV1, aV1History.front(), aGenName + "Edge_1", theTag++);
307       //}
308       //if(!aV2History.empty()) {
309       //  theResultBody->generated(aV2, aV2History.front(), aGenName + "Edge_2", theTag++);
310       //}
311       aShapeTypeToExplode = GeomAPI_Shape::COMPOUND;
312       break;
313     }
314     case GeomAPI_Shape::FACE:
315     case GeomAPI_Shape::SHELL: {
316       aShapeTypeToExplode = GeomAPI_Shape::EDGE;
317       break;
318     }
319     case GeomAPI_Shape::COMPOUND: {
320       aShapeTypeToExplode = GeomAPI_Shape::COMPOUND;
321     }
322   }
323
324   if(aShapeTypeToExplode == GeomAPI_Shape::VERTEX ||
325       aShapeTypeToExplode == GeomAPI_Shape::COMPOUND) {
326     theResultBody->loadAndOrientGeneratedShapes(theMakeShape.get(), theBaseShape,
327                                                 GeomAPI_Shape::VERTEX,
328                                                 theTag++, aGenName + "Edge",
329                                                 *aMapOfSubShapes.get());
330   }
331   if(aShapeTypeToExplode == GeomAPI_Shape::EDGE ||
332       aShapeTypeToExplode == GeomAPI_Shape::COMPOUND) {
333     theResultBody->loadAndOrientGeneratedShapes(theMakeShape.get(),
334                                                 theBaseShape, GeomAPI_Shape::EDGE,
335                                                 theTag++, aGenName + "Face",
336                                                 *aMapOfSubShapes.get());
337   }
338   // issue #2197: make naming of edges generated from vertices
339   if (aShapeTypeToExplode == GeomAPI_Shape::EDGE) {
340     GeomAPI_DataMapOfShapeShape aFacesFromFromEdges;
341     GeomAPI_ShapeExplorer anEdgeExp(theBaseShape, GeomAPI_Shape::EDGE);
342     for(; anEdgeExp.more(); anEdgeExp.next()) {
343       ListOfShape aGenerated;
344       theMakeShape->generated(anEdgeExp.current(), aGenerated);
345       ListOfShape::iterator aGenIter = aGenerated.begin();
346       for(; aGenIter != aGenerated.end(); aGenIter++) {
347         GeomShapePtr aGen = *aGenIter;
348         if (aGen.get() && !aGen->isNull()) {
349           if ((*aGenIter)->shapeType() == GeomAPI_Shape::FACE) { // normal case
350             aFacesFromFromEdges.bind(aGen, anEdgeExp.current());
351           }
352         }
353       }
354     }
355
356     // closed revolution of 1-3 faces can not distinguish lateral and base edges
357     if (aFacesFromFromEdges.size() <= 3) {
358       bool isClosed = false; // lateral edges are closed (in full revolution)
359       GeomAPI_DataMapOfShapeShape anEdgesFromVertices;
360       GeomAPI_ShapeExplorer aVertExp(theBaseShape, GeomAPI_Shape::VERTEX);
361       for(int anIndex = 1; aVertExp.more(); aVertExp.next()) {
362         ListOfShape aGenerated;
363         theMakeShape->generated(aVertExp.current(), aGenerated);
364         ListOfShape::iterator aGenIter = aGenerated.begin();
365         for(; aGenIter != aGenerated.end(); aGenIter++) {
366           std::shared_ptr<GeomAPI_Shape> aGenerated = *aGenIter;
367           if (anEdgesFromVertices.isBound(aGenerated)) // already here
368             continue;
369           std::ostringstream aStream;
370           aStream<<"Lateral_Edge_"<<anIndex++;
371           theResultBody->generated(aGenerated, aStream.str(), theTag++);
372
373           anEdgesFromVertices.bind(aGenerated, aVertExp.current());
374           std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aGenerated));
375           isClosed = isClosed || anEdge->isClosed();
376         }
377       }
378       if (isClosed) {
379         GeomAPI_ShapeExplorer anEdgesExp(theMakeShape->shape(), GeomAPI_Shape::EDGE);
380         for(int anIndex = 1; anEdgesExp.more(); anEdgesExp.next()) {
381           if (!anEdgesFromVertices.isBound(anEdgesExp.current())) {
382             // found a base edge
383             std::ostringstream aStream;
384             aStream<<"Base_Edge_"<<anIndex++;
385             theResultBody->generated(anEdgesExp.current(), aStream.str(), theTag++);
386             // only one orientation is needed
387             anEdgesFromVertices.bind(anEdgesExp.current(), anEdgesExp.current());
388           }
389         }
390       }
391     } else { // issue #2197, test case 4 : edges that produce fully-revolved face,
392       // but contain only 2 edges (on apex of revolution)
393       GeomAPI_ShapeExplorer anEdgeExp(theBaseShape, GeomAPI_Shape::EDGE);
394       for(int anIndex = 1; anEdgeExp.more(); anEdgeExp.next()) {
395         ListOfShape aGenerated;
396         theMakeShape->generated(anEdgeExp.current(), aGenerated);
397         ListOfShape::iterator aGenIter = aGenerated.begin();
398         for(; aGenIter != aGenerated.end(); aGenIter++) {
399           GeomShapePtr aGen = (*aGenIter);
400           if (aGen.get() && !aGen->isNull()) {
401             GeomAPI_ShapeExplorer aFaceEdgeExp(aGen, GeomAPI_Shape::EDGE);
402             int aNumEdges = 0;
403             int aNumClosed = 0;
404             GeomShapePtr aNotClosedEdge;
405             GeomAPI_DataMapOfShapeShape alreadyIterated;
406             for(; aFaceEdgeExp.more(); aFaceEdgeExp.next()) {
407               std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aFaceEdgeExp.current()));
408               if (anEdge->isDegenerated() || alreadyIterated.isBound(anEdge))
409                 continue;
410               alreadyIterated.bind(anEdge, anEdge);
411               aNumEdges++;
412               if (anEdge->isClosed()) {
413                 aNumClosed++;
414               } else {
415                 aNotClosedEdge = anEdge;
416               }
417             }
418             if (aNumEdges == 2 && aNumClosed == 1) {
419               std::ostringstream aStream;
420               aStream<<"Base_Edge_"<<anIndex++;
421               theResultBody->generated(aNotClosedEdge, aStream.str(), theTag++);
422             }
423           }
424         }
425       }
426     }
427   }
428
429   std::shared_ptr<GeomAlgoAPI_MakeSweep> aMakeSweep =
430     std::dynamic_pointer_cast<GeomAlgoAPI_MakeSweep>(theMakeShape);
431   if(aMakeSweep.get()) {
432     // Store from shapes.
433     storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes,
434                 aMakeSweep->fromShapes(), "From_", theTag);
435
436     // Store to shapes.
437     storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes,
438                 aMakeSweep->toShapes(), "To_", theTag);
439   }
440 }
441
442 //=================================================================================================
443 void FeaturesPlugin_CompositeSketch::storeShapes(ResultBodyPtr theResultBody,
444                               const GeomAPI_Shape::ShapeType theBaseShapeType,
445                               const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
446                               const ListOfShape& theShapes,
447                               const std::string theName,
448                               int& theTag)
449 {
450   GeomAPI_Shape::ShapeType aShapeTypeToExplore = GeomAPI_Shape::FACE;
451   std::string aShapeTypeStr = "Face";
452   switch(theBaseShapeType) {
453     case GeomAPI_Shape::VERTEX: {
454       aShapeTypeToExplore = GeomAPI_Shape::VERTEX;
455       aShapeTypeStr = "Vertex";
456       break;
457     }
458     case GeomAPI_Shape::EDGE:
459     case GeomAPI_Shape::WIRE: {
460       aShapeTypeToExplore = GeomAPI_Shape::EDGE;
461       aShapeTypeStr = "Edge";
462       break;
463     }
464     case GeomAPI_Shape::FACE:
465     case GeomAPI_Shape::SHELL: {
466       aShapeTypeToExplore = GeomAPI_Shape::FACE;
467       aShapeTypeStr = "Face";
468       break;
469     }
470     case GeomAPI_Shape::COMPOUND: {
471       aShapeTypeToExplore = GeomAPI_Shape::COMPOUND;
472       break;
473     }
474   }
475
476   // Store shapes.
477   int aShapeIndex = 1;
478   int aFaceIndex = 1;
479   for(ListOfShape::const_iterator anIt = theShapes.cbegin(); anIt != theShapes.cend(); ++anIt) {
480     GeomShapePtr aShape = *anIt;
481
482     if(aShapeTypeToExplore == GeomAPI_Shape::COMPOUND) {
483       std::string aName = theName + (aShape->shapeType() == GeomAPI_Shape::EDGE ? "Edge" : "Face");
484       storeSubShape(theResultBody,
485                     aShape,
486                     aShape->shapeType(),
487                     theMapOfSubShapes,
488                     aName,
489                     aShape->shapeType() == GeomAPI_Shape::EDGE ? aShapeIndex : aFaceIndex,
490                     theTag);
491     } else {
492       std::string aName = theName + aShapeTypeStr;
493       storeSubShape(theResultBody, aShape, aShapeTypeToExplore,
494                     theMapOfSubShapes, aName, aShapeIndex, theTag);
495     }
496   }
497 }
498
499 void storeSubShape(ResultBodyPtr theResultBody,
500                    const GeomShapePtr theShape,
501                    const GeomAPI_Shape::ShapeType theType,
502                    const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
503                    const std::string theName,
504                    int& theShapeIndex,
505                    int& theTag)
506 {
507   for(GeomAPI_ShapeExplorer anExp(theShape, theType); anExp.more(); anExp.next()) {
508     GeomShapePtr aSubShape = anExp.current();
509     if(theMapOfSubShapes->isBound(aSubShape)) {
510       aSubShape = theMapOfSubShapes->find(aSubShape);
511     }
512     std::ostringstream aStr;
513     aStr << theName << "_" << theShapeIndex++;
514     theResultBody->generated(aSubShape, aStr.str(), theTag++);
515   }
516 }