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);
+ const std::string& theName);
//=================================================================================================
void FeaturesPlugin_CompositeSketch::initCompositeSketchAttribtues(const int theInitFlags)
aResultBody->storeGenerated(theBaseShape, theMakeShape->shape());
// Store generated edges/faces.
- int aGenTag = 1;
- storeGenerationHistory(aResultBody, theBaseShape, theMakeShape, aGenTag);
+ storeGenerationHistory(aResultBody, theBaseShape, theMakeShape);
setResult(aResultBody, theIndex);
}
//=================================================================================================
void FeaturesPlugin_CompositeSketch::storeGenerationHistory(ResultBodyPtr theResultBody,
const GeomShapePtr theBaseShape,
- const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape,
- int& theTag)
+ const std::shared_ptr<GeomAlgoAPI_MakeShape> theMakeShape)
{
GeomAPI_Shape::ShapeType aBaseShapeType = theBaseShape->shapeType();
GeomAPI_Shape::ShapeType aShapeTypeToExplode = GeomAPI_Shape::SHAPE;
- std::string aGenName = "Generated_";
- std::shared_ptr<GeomAPI_DataMapOfShapeShape> aMapOfSubShapes = theMakeShape->mapOfSubShapes();
switch(aBaseShapeType) {
case GeomAPI_Shape::EDGE: {
aShapeTypeToExplode = GeomAPI_Shape::VERTEX;
break;
}
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);
- //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;
}
}
}
+ int aLateralIndex = 1;
+ int aBaseEdgeIndex = 1;
+ int aVertexIndex = 1;
+ int aBaseVertexIndex = 1;
+
if(aShapeTypeToExplode == GeomAPI_Shape::VERTEX ||
aShapeTypeToExplode == GeomAPI_Shape::COMPOUND) {
- theResultBody->loadAndOrientGeneratedShapes(theMakeShape.get(), theBaseShape,
- GeomAPI_Shape::VERTEX,
- theTag++, aGenName + "Edge",
- *aMapOfSubShapes.get());
+ theResultBody->loadGeneratedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::VERTEX);
}
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++) {
- aFacesFromFromEdges.bind(*aGenIter, 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(int anIndex = 1; 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_Edge_"<<anIndex++;
- 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(int anIndex = 1; anEdgesExp.more(); anEdgesExp.next()) {
- if (!anEdgesFromVertices.isBound(anEdgesExp.current())) {
- // found a base edge
- std::ostringstream aStream;
- aStream<<"Base_Edge_"<<anIndex++;
- theResultBody->generated(anEdgesExp.current(), aStream.str(), theTag++);
- // only one orientation is needed
- anEdgesFromVertices.bind(anEdgesExp.current(), anEdgesExp.current());
- }
- }
- }
- }
+ theResultBody->loadGeneratedShapes(theMakeShape, theBaseShape, GeomAPI_Shape::EDGE);
}
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, aMakeSweep->fromShapes(), "From_");
// Store to shapes.
- storeShapes(theResultBody, aBaseShapeType, aMapOfSubShapes,
- aMakeSweep->toShapes(), "To_", theTag);
+ storeShapes(theResultBody, aBaseShapeType, aMakeSweep->toShapes(), "To_");
}
}
//=================================================================================================
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 std::string theName)
{
GeomAPI_Shape::ShapeType aShapeTypeToExplore = GeomAPI_Shape::FACE;
std::string aShapeTypeStr = "Face";
}
// Store shapes.
- int aShapeIndex = 1;
- int aFaceIndex = 1;
for(ListOfShape::const_iterator anIt = theShapes.cbegin(); anIt != theShapes.cend(); ++anIt) {
GeomShapePtr aShape = *anIt;
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);
+ storeSubShape(theResultBody, aShape, aShape->shapeType(), aName);
} else {
std::string aName = theName + aShapeTypeStr;
- storeSubShape(theResultBody, aShape, aShapeTypeToExplore,
- theMapOfSubShapes, aName, aShapeIndex, theTag);
+ storeSubShape(theResultBody, aShape, aShapeTypeToExplore, aName);
+ if (theBaseShapeType == GeomAPI_Shape::WIRE) { // issue 2289: special names also for vertices
+ aName = theName + "Vertex";
+ storeSubShape(theResultBody, aShape, GeomAPI_Shape::VERTEX, aName);
+ }
}
}
}
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)
+ const std::string& theName)
{
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++);
+ theResultBody->generated(aSubShape, theName);
}
}
