-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: FeaturesPlugin_CompositeSketch.cpp
-// Created: 11 September 2015
-// Author: Dmitry Bobylev
+// Copyright (C) 2014-2017 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<mailto:webmaster.salome@opencascade.com>
+//
#include <FeaturesPlugin_CompositeSketch.h>
#include <GeomAlgoAPI_Prism.h>
#include <GeomAlgoAPI_Revolution.h>
#include <GeomAlgoAPI_ShapeTools.h>
+#include <GeomAlgoAPI_SketchBuilder.h>
+
+#include <GeomAPI_PlanarEdges.h>
#include <GeomAPI_ShapeExplorer.h>
+#include <map>
#include <sstream>
+static void storeSubShape(ResultBodyPtr theResultBody,
+ const GeomShapePtr theShape,
+ const GeomAPI_Shape::ShapeType theType,
+ const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
+ const std::string theName,
+ int& theShapeIndex,
+ int& theTag);
+
//=================================================================================================
void FeaturesPlugin_CompositeSketch::initCompositeSketchAttribtues(const int theInitFlags)
{
}
//=================================================================================================
-std::shared_ptr<ModelAPI_Feature> FeaturesPlugin_CompositeSketch::subFeature(const int theIndex, bool forTree)
+std::shared_ptr<ModelAPI_Feature> FeaturesPlugin_CompositeSketch::subFeature(const int theIndex,
+ bool forTree)
{
if(theIndex == 0) {
return std::dynamic_pointer_cast<ModelAPI_Feature>(data()->reference(SKETCH_ID())->value());
reference(SKETCH_ID())->setValue(ObjectPtr());
}
-//=================================================================================================
-void FeaturesPlugin_CompositeSketch::erase()
-{
- if(data().get() && data()->isValid()) { // on abort of sketch of this composite it may be invalid
- FeaturePtr aSketch = std::dynamic_pointer_cast<ModelAPI_Feature>(reference(SKETCH_ID())->value());
- if(aSketch.get() && aSketch->data()->isValid()) {
- document()->removeFeature(aSketch);
- }
- }
-
- ModelAPI_CompositeFeature::erase();
-}
-
-//=================================================================================================
-void FeaturesPlugin_CompositeSketch::setSketchObjectToList()
-{
- AttributeSelectionListPtr aBaseObjectsSelectionList = selectionList(BASE_OBJECTS_ID());
- if(!aBaseObjectsSelectionList.get() || aBaseObjectsSelectionList->isInitialized()) {
- return;
- }
-
- AttributeReferencePtr aSketchLauncherRef = reference(SKETCH_ID());
- if(!aSketchLauncherRef.get() || !aSketchLauncherRef->isInitialized()) {
- return;
- }
-
- FeaturePtr aSketchFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aSketchLauncherRef->value());
-
- if(!aSketchFeature.get() || aSketchFeature->results().empty()) {
- return;
- }
-
- ResultPtr aSketchRes = aSketchFeature->results().front();
- ResultConstructionPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aSketchRes);
- if(!aConstruction.get()) {
- return;
- }
-
- if(aBaseObjectsSelectionList->size() == 0) {
- aBaseObjectsSelectionList->append(aSketchRes, GeomShapePtr());
- }
-}
-
//=================================================================================================
void FeaturesPlugin_CompositeSketch::getBaseShapes(ListOfShape& theBaseShapesList,
const bool theIsMakeShells)
theBaseShapesList.clear();
ListOfShape aBaseFacesList;
+ std::map<ResultConstructionPtr, ListOfShape> aSketchWiresMap;
AttributeSelectionListPtr aBaseObjectsSelectionList = selectionList(BASE_OBJECTS_ID());
if(!aBaseObjectsSelectionList.get()) {
setError("Error: Could not get base objects selection list.");
for(int anIndex = 0; anIndex < aBaseObjectsSelectionList->size(); anIndex++) {
AttributeSelectionPtr aBaseObjectSelection = aBaseObjectsSelectionList->value(anIndex);
if(!aBaseObjectSelection.get()) {
- setError("Error: One of the selected base objects is empty.");
+ setError("Error: Selected base object is empty.");
return;
}
GeomShapePtr aBaseShape = aBaseObjectSelection->value();
if(aBaseShape.get() && !aBaseShape->isNull()) {
- aBaseShape->shapeType() == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
- theBaseShapesList.push_back(aBaseShape);
+ GeomAPI_Shape::ShapeType aST = aBaseShape->shapeType();
+ if(aST == GeomAPI_Shape::SOLID || aST == GeomAPI_Shape::COMPSOLID) {
+ setError("Error: Selected shapes has unsupported type.");
+ return;
+ }
+ ResultConstructionPtr aConstruction =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aBaseObjectSelection->context());
+ if(aConstruction.get() && !aBaseShape->isEqual(aConstruction->shape()) &&
+ aST == GeomAPI_Shape::WIRE) {
+ // It is a wire on the sketch, store it to make face later.
+ aSketchWiresMap[aConstruction].push_back(aBaseShape);
+ continue;
+ } else {
+ aST == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
+ theBaseShapesList.push_back(aBaseShape);
+ }
} else {
// This may be the whole sketch result selected, check and get faces.
ResultConstructionPtr aConstruction =
std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aBaseObjectSelection->context());
if(!aConstruction.get()) {
- setError("Error: One of selected sketches does not have results.");
+ setError("Error: Selected sketches does not have results.");
return;
}
int aFacesNum = aConstruction->facesNum();
// Probably it can be construction.
aBaseShape = aConstruction->shape();
if(aBaseShape.get() && !aBaseShape->isNull()) {
- aBaseShape->shapeType() == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
- theBaseShapesList.push_back(aBaseShape);
+ GeomAPI_Shape::ShapeType aST = aBaseShape->shapeType();
+ if(aST != GeomAPI_Shape::VERTEX && aST != GeomAPI_Shape::EDGE &&
+ aST != GeomAPI_Shape::WIRE &&
+ aST != GeomAPI_Shape::FACE && aST != GeomAPI_Shape::SHELL) {
+ setError("Error: Selected shapes has unsupported type.");
+ return;
+ }
+ aST == GeomAPI_Shape::FACE ? aBaseFacesList.push_back(aBaseShape) :
+ theBaseShapesList.push_back(aBaseShape);
}
} else {
for(int aFaceIndex = 0; aFaceIndex < aFacesNum; aFaceIndex++) {
GeomShapePtr aBaseFace = aConstruction->face(aFaceIndex);
if(!aBaseFace.get() || aBaseFace->isNull()) {
- setError("Error: One of the faces on selected sketch is Null.");
+ setError("Error: One of the faces on selected sketch is null.");
return;
}
aBaseFacesList.push_back(aBaseFace);
}
}
+ // Make faces from sketch wires.
+ for(std::map<ResultConstructionPtr, ListOfShape>::const_iterator anIt = aSketchWiresMap.cbegin();
+ anIt != aSketchWiresMap.cend(); ++anIt) {
+ const std::shared_ptr<GeomAPI_PlanarEdges> aSketchPlanarEdges =
+ std::dynamic_pointer_cast<GeomAPI_PlanarEdges>((*anIt).first->shape());
+ const ListOfShape& aWiresList = (*anIt).second;
+ ListOfShape aFaces;
+ GeomAlgoAPI_ShapeTools::makeFacesWithHoles(aSketchPlanarEdges->origin(),
+ aSketchPlanarEdges->norm(),
+ aWiresList,
+ aFaces);
+ aBaseFacesList.insert(aBaseFacesList.end(), aFaces.begin(), aFaces.end());
+ }
+
// Searching faces with common edges.
- if(theIsMakeShells) {
+ if(theIsMakeShells && aBaseFacesList.size() > 1) {
ListOfShape aShells;
ListOfShape aFreeFaces;
GeomShapePtr aFacesCompound = GeomAlgoAPI_CompoundBuilder::compound(aBaseFacesList);
- GeomAlgoAPI_ShapeTools::combineShapes(aFacesCompound, GeomAPI_Shape::SHELL, aShells, aFreeFaces);
+ GeomAlgoAPI_ShapeTools::combineShapes(aFacesCompound, GeomAPI_Shape::SHELL,
+ aShells, aFreeFaces);
theBaseShapesList.insert(theBaseShapesList.end(), aFreeFaces.begin(), aFreeFaces.end());
theBaseShapesList.insert(theBaseShapesList.end(), aShells.begin(), aShells.end());
} else {
- theBaseShapesList.insert(theBaseShapesList.end(), aBaseFacesList.begin(), aBaseFacesList.end());
+ theBaseShapesList.insert(theBaseShapesList.end(), aBaseFacesList.begin(),
+ aBaseFacesList.end());
}
}
//=================================================================================================
-bool FeaturesPlugin_CompositeSketch::isMakeShapeValid(const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape)
+bool FeaturesPlugin_CompositeSketch::isMakeShapeValid(
+ const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape)
{
// Check that algo is done.
if(!theMakeShape->isDone()) {
- setError("Error:" + getKind() + "algorithm failed.");
+ setError("Error: " + getKind() + " algorithm failed.");
return false;
}
//=================================================================================================
void FeaturesPlugin_CompositeSketch::storeResult(const GeomShapePtr theBaseShape,
- const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
- const int theResultIndex)
+ const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
+ const int theIndex)
{
// Create result body.
- ResultBodyPtr aResultBody = document()->createBody(data(), theResultIndex);
+ ResultBodyPtr aResultBody = document()->createBody(data(), theIndex);
// Store generated shape.
aResultBody->storeGenerated(theBaseShape, theMakeShape->shape());
int aGenTag = 1;
storeGenerationHistory(aResultBody, theBaseShape, theMakeShape, aGenTag);
- setResult(aResultBody, theResultIndex);
+ setResult(aResultBody, theIndex);
}
//=================================================================================================
void FeaturesPlugin_CompositeSketch::storeGenerationHistory(ResultBodyPtr theResultBody,
- const GeomShapePtr theBaseShape,
- const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
- int& theTag)
+ const GeomShapePtr theBaseShape,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
+ int& theTag)
{
GeomAPI_Shape::ShapeType aBaseShapeType = theBaseShape->shapeType();
- GeomAPI_Shape::ShapeType aShapeTypeToExplode;
+ GeomAPI_Shape::ShapeType aShapeTypeToExplode = GeomAPI_Shape::SHAPE;
std::string aGenName = "Generated_";
std::shared_ptr<GeomAPI_DataMapOfShapeShape> aMapOfSubShapes = theMakeShape->mapOfSubShapes();
switch(aBaseShapeType) {
- case GeomAPI_Shape::VERTEX: {
- aShapeTypeToExplode = GeomAPI_Shape::VERTEX;
- aGenName += "Edge";
+ case GeomAPI_Shape::EDGE: {
+ aShapeTypeToExplode = GeomAPI_Shape::VERTEX;
break;
}
- case GeomAPI_Shape::EDGE:
case GeomAPI_Shape::WIRE: {
- std::shared_ptr<GeomAPI_Vertex> aV1, aV2;
- GeomAlgoAPI_ShapeTools::findBounds(theBaseShape, aV1, aV2);
- ListOfShape aV1History, aV2History;
- theMakeShape->generated(aV1, aV1History);
- theMakeShape->generated(aV2, aV2History);
- theResultBody->generated(aV1, aV1History.front(), aGenName + "Edge_1", theTag++);
- theResultBody->generated(aV2, aV2History.front(), aGenName + "Edge_2", theTag++);
+ //std::shared_ptr<GeomAPI_Vertex> aV1, aV2;
+ //GeomAlgoAPI_ShapeTools::findBounds(theBaseShape, aV1, aV2);
+ //ListOfShape aV1History, aV2History;
+ //theMakeShape->generated(aV1, aV1History);
+ //theMakeShape->generated(aV2, aV2History);
+ //if(!aV1History.empty()) {
+ // theResultBody->generated(aV1, aV1History.front(), aGenName + "Edge_1", theTag++);
+ //}
+ //if(!aV2History.empty()) {
+ // theResultBody->generated(aV2, aV2History.front(), aGenName + "Edge_2", theTag++);
+ //}
+ aShapeTypeToExplode = GeomAPI_Shape::COMPOUND;
+ break;
}
case GeomAPI_Shape::FACE:
case GeomAPI_Shape::SHELL: {
aShapeTypeToExplode = GeomAPI_Shape::EDGE;
- aGenName += "Face";
break;
}
+ case GeomAPI_Shape::COMPOUND: {
+ aShapeTypeToExplode = GeomAPI_Shape::COMPOUND;
+ }
}
- theResultBody->loadAndOrientGeneratedShapes(theMakeShape.get(), theBaseShape, aShapeTypeToExplode,
- theTag++, aGenName, *aMapOfSubShapes.get());
- std::shared_ptr<GeomAlgoAPI_MakeSweep> aMakeSweep = std::dynamic_pointer_cast<GeomAlgoAPI_MakeSweep>(theMakeShape);
+ if(aShapeTypeToExplode == GeomAPI_Shape::VERTEX ||
+ aShapeTypeToExplode == GeomAPI_Shape::COMPOUND) {
+ theResultBody->loadAndOrientGeneratedShapes(theMakeShape.get(), theBaseShape,
+ GeomAPI_Shape::VERTEX,
+ theTag++, aGenName + "Edge",
+ *aMapOfSubShapes.get());
+ }
+ if(aShapeTypeToExplode == GeomAPI_Shape::EDGE ||
+ aShapeTypeToExplode == GeomAPI_Shape::COMPOUND) {
+ theResultBody->loadAndOrientGeneratedShapes(theMakeShape.get(),
+ theBaseShape, GeomAPI_Shape::EDGE,
+ theTag++, aGenName + "Face",
+ *aMapOfSubShapes.get());
+ }
+ // issue #2197: make naming of edges generated from vertices
+ if (aShapeTypeToExplode == GeomAPI_Shape::EDGE) {
+ GeomAPI_DataMapOfShapeShape aFacesFromFromEdges;
+ GeomAPI_ShapeExplorer anEdgeExp(theBaseShape, GeomAPI_Shape::EDGE);
+ for(; anEdgeExp.more(); anEdgeExp.next()) {
+ ListOfShape aGenerated;
+ theMakeShape->generated(anEdgeExp.current(), aGenerated);
+ ListOfShape::iterator aGenIter = aGenerated.begin();
+ for(; aGenIter != aGenerated.end(); aGenIter++) {
+ GeomShapePtr aGen = *aGenIter;
+ if (aGen.get() && !aGen->isNull()) {
+ if ((*aGenIter)->shapeType() == GeomAPI_Shape::FACE) { // normal case
+ aFacesFromFromEdges.bind(aGen, anEdgeExp.current());
+ }
+ }
+ }
+ }
+
+ // closed revolution of 1-3 faces can not distinguish lateral and base edges
+ if (aFacesFromFromEdges.size() <= 3) {
+ bool isClosed = false; // lateral edges are closed (in full revolution)
+ GeomAPI_DataMapOfShapeShape anEdgesFromVertices;
+ GeomAPI_ShapeExplorer aVertExp(theBaseShape, GeomAPI_Shape::VERTEX);
+ for(; aVertExp.more(); aVertExp.next()) {
+ ListOfShape aGenerated;
+ theMakeShape->generated(aVertExp.current(), aGenerated);
+ ListOfShape::iterator aGenIter = aGenerated.begin();
+ for(; aGenIter != aGenerated.end(); aGenIter++) {
+ std::shared_ptr<GeomAPI_Shape> aGenerated = *aGenIter;
+ if (anEdgesFromVertices.isBound(aGenerated)) // already here
+ continue;
+ std::ostringstream aStream;
+ aStream<<"Lateral_"<<theTag++;
+ theResultBody->generated(aGenerated, aStream.str(), theTag++);
+
+ anEdgesFromVertices.bind(aGenerated, aVertExp.current());
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aGenerated));
+ isClosed = isClosed || anEdge->isClosed();
+ }
+ }
+ if (isClosed) {
+ GeomAPI_ShapeExplorer anEdgesExp(theMakeShape->shape(), GeomAPI_Shape::EDGE);
+ for(; anEdgesExp.more(); anEdgesExp.next()) {
+ if (!anEdgesFromVertices.isBound(anEdgesExp.current())) {
+ // found a base edge
+ std::ostringstream aStream;
+ aStream<<"Base_Edge_"<<theTag++;
+ theResultBody->generated(anEdgesExp.current(), aStream.str(), theTag++);
+ // only one orientation is needed
+ anEdgesFromVertices.bind(anEdgesExp.current(), anEdgesExp.current());
+ }
+ }
+ } else if (aFacesFromFromEdges.size() == 1) { // 2233: sphere created by the revolution:
+ // vertices at degenerated edges will have the same name
+ GeomAPI_DataMapOfShapeShape aVertices;
+ GeomAPI_ShapeExplorer aVertExp(theMakeShape->shape(), GeomAPI_Shape::VERTEX);
+ for(int anIndex = 1; aVertExp.more(); aVertExp.next()) {
+ if (!aVertices.isBound(aVertExp.current())) {
+ // found a base edge
+ std::ostringstream aStream;
+ aStream<<"Vertex_"<<theTag++;
+ theResultBody->generated(aVertExp.current(), aStream.str(), theTag++);
+ // only one orientation is needed
+ aVertices.bind(aVertExp.current(), aVertExp.current());
+ }
+ }
+ }
+ } else { // issue #2197, test case 4 : edges that produce fully-revolved face,
+ // but contain only 2 edges (on apex of revolution)
+ GeomAPI_ShapeExplorer anEdgeExp(theBaseShape, GeomAPI_Shape::EDGE);
+ for(; anEdgeExp.more(); anEdgeExp.next()) {
+ ListOfShape aGenerated;
+ theMakeShape->generated(anEdgeExp.current(), aGenerated);
+ ListOfShape::iterator aGenIter = aGenerated.begin();
+ for(; aGenIter != aGenerated.end(); aGenIter++) {
+ GeomShapePtr aGen = (*aGenIter);
+ if (aGen.get() && !aGen->isNull()) {
+ GeomAPI_ShapeExplorer aFaceEdgeExp(aGen, GeomAPI_Shape::EDGE);
+ int aNumEdges = 0;
+ int aNumClosed = 0;
+ GeomShapePtr aNotClosedEdge;
+ GeomEdgePtr aDegenerateEdge;
+ GeomAPI_DataMapOfShapeShape alreadyIterated;
+ for(; aFaceEdgeExp.more(); aFaceEdgeExp.next()) {
+ std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aFaceEdgeExp.current()));
+ if (anEdge->isDegenerated()) {
+ aDegenerateEdge = anEdge;
+ continue;
+ }
+ if (alreadyIterated.isBound(anEdge))
+ continue;
+ alreadyIterated.bind(anEdge, anEdge);
+ aNumEdges++;
+ if (anEdge->isClosed()) {
+ aNumClosed++;
+ } else {
+ aNotClosedEdge = anEdge;
+ }
+ }
+ if (aNumEdges == 2 && aNumClosed == 1) {
+ std::ostringstream aStream;
+ aStream<<"Base_Edge_"<<theTag++;
+ theResultBody->generated(aNotClosedEdge, aStream.str(), theTag++);
+ if (aDegenerateEdge.get()) { // export vertex of the degenerated edge (apex) #2520
+ GeomAPI_ShapeExplorer anEdgeExp(aDegenerateEdge, GeomAPI_Shape::VERTEX);
+ if (anEdgeExp.more()) {
+ std::ostringstream aStream;
+ aStream << "Base_Vertex_" << theTag++;
+ theResultBody->generated(anEdgeExp.current(), aStream.str(), theTag++);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ std::shared_ptr<GeomAlgoAPI_MakeSweep> aMakeSweep =
+ std::dynamic_pointer_cast<GeomAlgoAPI_MakeSweep>(theMakeShape);
if(aMakeSweep.get()) {
// Store from shapes.
- storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes, aMakeSweep->fromShapes(), "From_", theTag);
+ storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes,
+ aMakeSweep->fromShapes(), "From_", theTag);
// Store to shapes.
- storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes, aMakeSweep->toShapes(), "To_", theTag);
+ storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes,
+ aMakeSweep->toShapes(), "To_", theTag);
}
}
//=================================================================================================
void FeaturesPlugin_CompositeSketch::storeShapes(ResultBodyPtr theResultBody,
- const GeomAPI_Shape::ShapeType theBaseShapeType,
- const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
- const ListOfShape& theShapes,
- const std::string theName,
- int& theTag)
+ const GeomAPI_Shape::ShapeType theBaseShapeType,
+ const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
+ const ListOfShape& theShapes,
+ const std::string theName,
+ int& theTag)
{
GeomAPI_Shape::ShapeType aShapeTypeToExplore = GeomAPI_Shape::FACE;
std::string aShapeTypeStr = "Face";
aShapeTypeStr = "Face";
break;
}
+ case GeomAPI_Shape::COMPOUND: {
+ aShapeTypeToExplore = GeomAPI_Shape::COMPOUND;
+ break;
+ }
}
// Store shapes.
int aShapeIndex = 1;
- std::string aName = theName + aShapeTypeStr;
+ int aFaceIndex = 1;
for(ListOfShape::const_iterator anIt = theShapes.cbegin(); anIt != theShapes.cend(); ++anIt) {
GeomShapePtr aShape = *anIt;
- for(GeomAPI_ShapeExplorer anExp(aShape, aShapeTypeToExplore); anExp.more(); anExp.next()) {
- GeomShapePtr aSubShape = anExp.current();
- if(theMapOfSubShapes->isBound(aSubShape)) {
- aSubShape = theMapOfSubShapes->find(aSubShape);
+
+ if(aShapeTypeToExplore == GeomAPI_Shape::COMPOUND) {
+ std::string aName = theName + (aShape->shapeType() == GeomAPI_Shape::EDGE ? "Edge" : "Face");
+ storeSubShape(theResultBody,
+ aShape,
+ aShape->shapeType(),
+ theMapOfSubShapes,
+ aName,
+ aShape->shapeType() == GeomAPI_Shape::EDGE ? aShapeIndex : aFaceIndex,
+ theTag);
+ } else {
+ std::string aName = theName + aShapeTypeStr;
+ storeSubShape(theResultBody, aShape, aShapeTypeToExplore,
+ theMapOfSubShapes, aName, aShapeIndex, theTag);
+ if (theBaseShapeType == GeomAPI_Shape::WIRE) { // issue 2289: special names also for vertices
+ aName = theName + "Vertex";
+ storeSubShape(theResultBody, aShape, GeomAPI_Shape::VERTEX,
+ theMapOfSubShapes, aName, aShapeIndex, theTag);
}
- std::ostringstream aStr;
- aStr << aName << "_" << aShapeIndex++;
- theResultBody->generated(aSubShape, aStr.str(), theTag++);
}
}
-}
\ No newline at end of file
+}
+
+void storeSubShape(ResultBodyPtr theResultBody,
+ const GeomShapePtr theShape,
+ const GeomAPI_Shape::ShapeType theType,
+ const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theMapOfSubShapes,
+ const std::string theName,
+ int& theShapeIndex,
+ int& theTag)
+{
+ for(GeomAPI_ShapeExplorer anExp(theShape, theType); anExp.more(); anExp.next()) {
+ GeomShapePtr aSubShape = anExp.current();
+ if(theMapOfSubShapes->isBound(aSubShape)) {
+ aSubShape = theMapOfSubShapes->find(aSubShape);
+ }
+ std::ostringstream aStr;
+ aStr << theName << "_" << theShapeIndex++;
+ theResultBody->generated(aSubShape, aStr.str(), theTag++);
+ }
+}
