#include <TopExp.hxx>
#include <BRepTools.hxx>
#include <BRep_Tool.hxx>
+#include <BRepTools_History.hxx>
#include <GeomAPI_Shape.h>
+#include <GeomAPI_ShapeExplorer.h>
#include <GeomAlgoAPI_MakeShape.h>
#include <GeomAlgoAPI_SortListOfShapes.h>
#include <Config_PropManager.h>
//#include <TDF_Tool.hxx>
//#define DEB_IMPORT 1
-Model_BodyBuilder::Model_BodyBuilder(ModelAPI_Object* theOwner)
-: ModelAPI_BodyBuilder(theOwner)
-{
+static const int INVALID_TAG = -1;
+static const int GENERATED_VERTICES_TAG = 1;
+static const int GENERATED_EDGES_TAG = 2;
+static const int GENERATED_FACES_TAG = 3;
+static const int MODIFIED_VERTICES_TAG = 4;
+static const int MODIFIED_EDGES_TAG = 5;
+static const int MODIFIED_FACES_TAG = 6;
+static const int DELETED_TAG = 7;
+static const int PRIMITIVES_START_TAG = 11;
+
+static int getGenerationTag(const TopoDS_Shape& theShape) {
+ TopAbs_ShapeEnum aShapeType = theShape.ShapeType();
+ switch (aShapeType) {
+ case TopAbs_VERTEX: return GENERATED_VERTICES_TAG;
+ case TopAbs_EDGE: return GENERATED_EDGES_TAG;
+ case TopAbs_FACE: return GENERATED_FACES_TAG;
+ }
+
+ return INVALID_TAG;
}
-// Converts evolution of naming shape to selection evelution and back to avoid
-// naming support on the disabled results. Deeply in the labels tree, recursively.
-static void evolutionToSelectionRec(TDF_Label theLab, const bool theFlag) {
- std::list<std::pair<TopoDS_Shape, TopoDS_Shape> > aShapePairs; // to store old and new shapes
- Handle(TNaming_NamedShape) aName;
- int anEvolution = -1;
- if (theLab.FindAttribute(TNaming_NamedShape::GetID(), aName)) {
- TNaming_Evolution aNSEvol = aName->Evolution();
- if ((aNSEvol == TNaming_SELECTED && theFlag) ||
- (aNSEvol != TNaming_SELECTED && !theFlag)) { // nothing to do, it is already correct
- return;
- }
- anEvolution = (int)(aNSEvol);
- if (!theFlag) {
- Handle(TDataStd_Integer) anAttrEvol;
- if (theLab.FindAttribute(TDataStd_Integer::GetID(), anAttrEvol)) {
- anEvolution = anAttrEvol->Get();
- }
- } else {
- TDataStd_Integer::Set(theLab, anEvolution);
- }
-
- for(TNaming_Iterator anIter(aName); anIter.More(); anIter.Next()) {
- // iterator goes in reversed order relatively to the Builder, to, make the list reversed
- aShapePairs.push_front(std::pair<TopoDS_Shape, TopoDS_Shape>
- (anIter.OldShape(), anIter.NewShape()));
- }
-
- // create new
- TNaming_Builder aBuilder(theLab);
- TNaming_Evolution anEvol = (TNaming_Evolution)(anEvolution);
- std::list<std::pair<TopoDS_Shape, TopoDS_Shape> >::iterator aPairsIter = aShapePairs.begin();
- for(; aPairsIter != aShapePairs.end(); aPairsIter++) {
- if (theFlag) { // disabled => make selection
- if (anEvolution == TNaming_DELETE) // issue 2274 : don't put too many same null shapes
- aBuilder.Select(aPairsIter->first, aPairsIter->first);
- else if (anEvolution == TNaming_PRIMITIVE)
- aBuilder.Select(aPairsIter->second, aPairsIter->second);
- else
- aBuilder.Select(aPairsIter->second, aPairsIter->first);
- } else if (anEvol == TNaming_GENERATED) {
- aBuilder.Generated(aPairsIter->first, aPairsIter->second);
- } else if (anEvol == TNaming_MODIFY) {
- aBuilder.Modify(aPairsIter->first, aPairsIter->second);
- } else if (anEvol == TNaming_DELETE) {
- aBuilder.Delete(aPairsIter->first);
- } else if (anEvol == TNaming_PRIMITIVE) {
- aBuilder.Generated(aPairsIter->second);
- } else if (anEvol == TNaming_SELECTED) {
- aBuilder.Select(aPairsIter->second, aPairsIter->first);
- }
- }
+static int getModificationTag(const TopoDS_Shape& theShape) {
+ TopAbs_ShapeEnum aShapeType = theShape.ShapeType();
+ switch (aShapeType) {
+ case TopAbs_VERTEX: return MODIFIED_VERTICES_TAG;
+ case TopAbs_EDGE: return MODIFIED_EDGES_TAG;
+ case TopAbs_FACE: return MODIFIED_FACES_TAG;
}
- // recursive call for all sub-labels
- TDF_ChildIterator anIter(theLab, Standard_False);
- for(; anIter.More(); anIter.Next()) {
- evolutionToSelectionRec(anIter.Value(), theFlag);
+
+ return INVALID_TAG;
+}
+
+static TopAbs_ShapeEnum convertShapeType(const GeomAPI_Shape::ShapeType theType) {
+ switch (theType) {
+ case GeomAPI_Shape::VERTEX: return TopAbs_VERTEX;
+ case GeomAPI_Shape::EDGE: return TopAbs_EDGE;
+ case GeomAPI_Shape::WIRE: return TopAbs_WIRE;
+ case GeomAPI_Shape::FACE: return TopAbs_FACE;
+ case GeomAPI_Shape::SHELL: return TopAbs_SHELL;
+ case GeomAPI_Shape::SOLID: return TopAbs_SOLID;
+ case GeomAPI_Shape::COMPSOLID: return TopAbs_COMPSOLID;
+ case GeomAPI_Shape::COMPOUND: return TopAbs_COMPOUND;
+ case GeomAPI_Shape::SHAPE: return TopAbs_SHAPE;
}
+ return TopAbs_SHAPE;
}
-void Model_BodyBuilder::evolutionToSelection(const bool theFlag)
+static bool isAlreadyStored(const TNaming_Builder* theBuilder,
+ const TopoDS_Shape& theOldShape,
+ const TopoDS_Shape& theNewShape)
{
- std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
- if (!aData) // unknown case
- return;
- TDF_Label& aShapeLab = aData->shapeLab();
- evolutionToSelectionRec(aShapeLab, theFlag);
+ for (TNaming_Iterator aNamingIt(theBuilder->NamedShape());
+ aNamingIt.More();
+ aNamingIt.Next())
+ {
+ if (aNamingIt.NewShape().IsSame(theNewShape)
+ && aNamingIt.OldShape().IsSame(theOldShape))
+ {
+ return true;
+ }
+ }
+
+ return false;
}
-void Model_BodyBuilder::store(const std::shared_ptr<GeomAPI_Shape>& theShape,
+Model_BodyBuilder::Model_BodyBuilder(ModelAPI_Object* theOwner)
+: ModelAPI_BodyBuilder(theOwner),
+ myFreePrimitiveTag(PRIMITIVES_START_TAG)
+{
+}
+
+void Model_BodyBuilder::store(const GeomShapePtr& theShape,
const bool theIsStoreSameShapes)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
}
}
-void Model_BodyBuilder::storeGenerated(const std::shared_ptr<GeomAPI_Shape>& theFromShape,
- const std::shared_ptr<GeomAPI_Shape>& theToShape)
+void Model_BodyBuilder::storeGenerated(const GeomShapePtr& theFromShape,
+ const GeomShapePtr& theToShape)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
}
}
-void Model_BodyBuilder::storeModified(const std::shared_ptr<GeomAPI_Shape>& theOldShape,
- const std::shared_ptr<GeomAPI_Shape>& theNewShape, const int theDecomposeSolidsTag)
+TNaming_Builder* Model_BodyBuilder::builder(const int theTag)
+{
+ std::map<int, TNaming_Builder*>::iterator aFind = myBuilders.find(theTag);
+ if (aFind == myBuilders.end()) {
+ std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
+ myBuilders[theTag] = new TNaming_Builder(
+ theTag == 0 ? aData->shapeLab() : aData->shapeLab().FindChild(theTag));
+ aFind = myBuilders.find(theTag);
+ }
+ return aFind->second;
+}
+
+void Model_BodyBuilder::storeModified(const GeomShapePtr& theOldShape,
+ const GeomShapePtr& theNewShape,
+ const bool theIsCleanStored)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
- TDF_Label& aShapeLab = aData->shapeLab();
// clean builders
- clean();
+ if (theIsCleanStored) clean();
// store the new shape as primitive
- TNaming_Builder aBuilder(aShapeLab);
+ TNaming_Builder* aBuilder = builder(0);
if (!theOldShape || !theNewShape)
return; // bad shape
TopoDS_Shape aShapeOld = theOldShape->impl<TopoDS_Shape>();
TopoDS_Shape aShapeNew = theNewShape->impl<TopoDS_Shape>();
if (aShapeNew.IsNull())
return; // null shape inside
- aBuilder.Modify(aShapeOld, aShapeNew);
- if(!aBuilder.NamedShape()->IsEmpty()) {
+ aBuilder->Modify(aShapeOld, aShapeNew);
+ if(!aBuilder->NamedShape()->IsEmpty()) {
Handle(TDataStd_Name) anAttr;
- if(aBuilder.NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
+ if(aBuilder->NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
std::string aName (TCollection_AsciiString(anAttr->Get()).ToCString());
if(!aName.empty()) {
std::shared_ptr<Model_Document> aDoc =
std::dynamic_pointer_cast<Model_Document>(document());
- aDoc->addNamingName(aBuilder.NamedShape()->Label(), aName);
+ aDoc->addNamingName(aBuilder->NamedShape()->Label(), aName);
}
}
}
}
}
-void Model_BodyBuilder::storeWithoutNaming(const std::shared_ptr<GeomAPI_Shape>& theShape)
+void Model_BodyBuilder::storeWithoutNaming(const GeomShapePtr& theShape)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
myBuilders.clear();
// remove the old reference (if any)
aLab.ForgetAttribute(TDF_Reference::GetID());
+ myFreePrimitiveTag = PRIMITIVES_START_TAG;
}
Model_BodyBuilder::~Model_BodyBuilder()
clean();
}
-TNaming_Builder* Model_BodyBuilder::builder(const int theTag)
+void Model_BodyBuilder::buildName(const int theTag, const std::string& theName)
{
- std::map<int, TNaming_Builder*>::iterator aFind = myBuilders.find(theTag);
- if (aFind == myBuilders.end()) {
- std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
- myBuilders[theTag] = new TNaming_Builder(
- theTag == 0 ? aData->shapeLab() : aData->shapeLab().FindChild(theTag));
- aFind = myBuilders.find(theTag);
+ std::string aName = theName;
+ std::string aPrefix = "";
+ switch (theTag) {
+ case GENERATED_VERTICES_TAG: aPrefix = aName.empty() ? "Generated_Vertex" : "GV:"; break;
+ case GENERATED_EDGES_TAG: aPrefix = aName.empty() ? "Generated_Edge" : "GE:"; break;
+ case GENERATED_FACES_TAG: aPrefix = aName.empty() ? "Generated_Face" : "GF:"; break;
+ case MODIFIED_VERTICES_TAG: aPrefix = aName.empty() ? "Modified_Vertex" : "MV:"; break;
+ case MODIFIED_EDGES_TAG: aPrefix = aName.empty() ? "Modified_Edge" : "ME:"; break;
+ case MODIFIED_FACES_TAG: aPrefix = aName.empty() ? "Modified_Face" : "MF:"; break;
}
- return aFind->second;
-}
+ aName.insert(0, aPrefix);
-void Model_BodyBuilder::buildName(const int theTag, const std::string& theName)
-{
- std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(document());
- //aDoc->addNamingName(builder(theTag)->NamedShape()->Label(), theName);
- TDataStd_Name::Set(builder(theTag)->NamedShape()->Label(), theName.c_str());
+ TDataStd_Name::Set(builder(theTag)->NamedShape()->Label(), aName.c_str());
}
-void Model_BodyBuilder::generated(
- const std::shared_ptr<GeomAPI_Shape>& theNewShape, const std::string& theName, const int theTag)
+void Model_BodyBuilder::generated(const GeomShapePtr& theNewShape,
+ const std::string& theName)
{
TopoDS_Shape aShape = theNewShape->impl<TopoDS_Shape>();
- builder(theTag)->Generated(aShape);
- if(!theName.empty())
- buildName(theTag, theName);
+ builder(myFreePrimitiveTag)->Generated(aShape);
+ if (!theName.empty()) {
+ buildName(myFreePrimitiveTag, theName);
+ }
+ ++myFreePrimitiveTag;
}
-void Model_BodyBuilder::generated(const std::shared_ptr<GeomAPI_Shape>& theOldShape,
- const std::shared_ptr<GeomAPI_Shape>& theNewShape, const std::string& theName, const int theTag)
+void Model_BodyBuilder::generated(const GeomShapePtr& theOldShape,
+ const GeomShapePtr& theNewShape,
+ const std::string& theName)
{
TopoDS_Shape anOldShape = theOldShape->impl<TopoDS_Shape>();
TopoDS_Shape aNewShape = theNewShape->impl<TopoDS_Shape>();
- builder(theTag)->Generated(anOldShape, aNewShape);
- if(!theName.empty())
- buildName(theTag, theName);
- TopAbs_ShapeEnum aGenShapeType = aNewShape.ShapeType();
- if(aGenShapeType == TopAbs_WIRE || aGenShapeType == TopAbs_SHELL) {
- TopAbs_ShapeEnum anExplodeShapeType = aGenShapeType == TopAbs_WIRE ? TopAbs_EDGE : TopAbs_FACE;
- const TDF_Label aLabel = builder(theTag)->NamedShape()->Label();
- int aTag = 1;
- std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(document());
- for(TopExp_Explorer anExp(aNewShape, anExplodeShapeType); anExp.More(); anExp.Next()) {
- TDF_Label aChildLabel = aLabel.FindChild(aTag);
- TNaming_Builder aBuilder(aChildLabel);
- aBuilder.Generated(anOldShape, anExp.Current());
- TCollection_AsciiString aChildName = TCollection_AsciiString((theName + "_").c_str()) + aTag;
- //aDoc->addNamingName(aChildLabel, aChildName.ToCString());
- TDataStd_Name::Set(aChildLabel, aChildName.ToCString());
- aTag++;
- }
+ TopAbs_ShapeEnum aNewShapeType = aNewShape.ShapeType();
+ int aTag;
+ if (aNewShapeType == TopAbs_WIRE || aNewShapeType == TopAbs_SHELL) {
+ // TODO: This is a workaround. New shape should be only vertex, edge or face.
+ TopAbs_ShapeEnum aShapeTypeToExplore = aNewShapeType == TopAbs_WIRE ? TopAbs_EDGE : TopAbs_FACE;
+ aTag = TopAbs_WIRE ? GENERATED_EDGES_TAG : GENERATED_FACES_TAG;
+ for (TopExp_Explorer anExp(aNewShape, aShapeTypeToExplore); anExp.More(); anExp.Next()) {
+ builder(aTag)->Generated(anOldShape, anExp.Current());
+ }
+ buildName(aTag, theName);
+ } else {
+ aTag = getGenerationTag(aNewShape);
+ if (aTag == INVALID_TAG) return;
+ builder(aTag)->Generated(anOldShape, aNewShape);
+ buildName(aTag, theName);
}
}
-
-void Model_BodyBuilder::modified(const std::shared_ptr<GeomAPI_Shape>& theOldShape,
- const std::shared_ptr<GeomAPI_Shape>& theNewShape, const std::string& theName, const int theTag)
+void Model_BodyBuilder::modified(const GeomShapePtr& theOldShape,
+ const GeomShapePtr& theNewShape,
+ const std::string& theName)
{
TopoDS_Shape anOldShape = theOldShape->impl<TopoDS_Shape>();
TopoDS_Shape aNewShape = theNewShape->impl<TopoDS_Shape>();
- builder(theTag)->Modify(anOldShape, aNewShape);
- if(!theName.empty())
- buildName(theTag, theName);
+ int aTag = getModificationTag(aNewShape);
+ if (aTag == INVALID_TAG) return;
+ builder(aTag)->Modify(anOldShape, aNewShape);
+ buildName(aTag, theName);
}
-void Model_BodyBuilder::deleted(const std::shared_ptr<GeomAPI_Shape>& theOldShape,
- const int theTag)
+void Model_BodyBuilder::deleted(const GeomShapePtr& theOldShape)
{
TopoDS_Shape aShape = theOldShape->impl<TopoDS_Shape>();
- builder(theTag)->Delete(aShape);
+ builder(DELETED_TAG)->Delete(aShape);
+}
+
+void Model_BodyBuilder::loadDeletedShapes(const GeomMakeShapePtr& theAlgo,
+ const GeomShapePtr& theOldShape,
+ const GeomAPI_Shape::ShapeType theShapeTypeToExplore,
+ const GeomShapePtr& theShapesToExclude)
+{
+ TopTools_MapOfShape anAlreadyProcessedShapes;
+ GeomShapePtr aResultShape = shape();
+ for (GeomAPI_ShapeExplorer anExp(theOldShape, theShapeTypeToExplore);
+ anExp.more();
+ anExp.next())
+ {
+ GeomShapePtr anOldSubShape = anExp.current();
+ const TopoDS_Shape& anOldSubShape_ = anOldSubShape->impl<TopoDS_Shape>();
+ if (!anAlreadyProcessedShapes.Add(anOldSubShape_)
+ || !theAlgo->isDeleted(anOldSubShape)
+ || aResultShape->isSubShape(anOldSubShape, false)
+ || (theShapesToExclude.get() && theShapesToExclude->isSubShape(anOldSubShape, false)))
+ {
+ continue;
+ }
+
+ ListOfShape aNewShapes;
+ if (BRepTools_History::IsSupportedType(anOldSubShape_)) { // to avoid crash in #2572
+ theAlgo->modified(anOldSubShape, aNewShapes);
+ }
+
+ if (aNewShapes.size() == 0
+ || (aNewShapes.size() == 1 && aNewShapes.front()->isSame(anOldSubShape))) {
+ builder(DELETED_TAG)->Delete(anOldSubShape_);
+ }
+ }
}
-void Model_BodyBuilder::loadDeletedShapes (GeomAlgoAPI_MakeShape* theMS,
- std::shared_ptr<GeomAPI_Shape> theShapeIn,
- const int theKindOfShape,
- const int theTag)
+static void removeBadShapes(ListOfShape& theShapes)
{
- TopoDS_Shape aShapeIn = theShapeIn->impl<TopoDS_Shape>();
- TopTools_MapOfShape aView;
- TopExp_Explorer ShapeExplorer (aShapeIn, (TopAbs_ShapeEnum)theKindOfShape);
- for (; ShapeExplorer.More(); ShapeExplorer.Next ()) {
- const TopoDS_Shape& aRoot = ShapeExplorer.Current ();
- if (!aView.Add(aRoot)) continue;
- std::shared_ptr<GeomAPI_Shape> aRShape(new GeomAPI_Shape());
- aRShape->setImpl((new TopoDS_Shape(aRoot)));
- if (theMS->isDeleted (aRShape)) {
- builder(theTag)->Delete(aRoot);
+ ListOfShape::iterator anIt = theShapes.begin();
+ while (anIt != theShapes.end()) {
+ TopoDS_Shape aNewShape = (*anIt)->impl<TopoDS_Shape>();
+ bool aSkip = aNewShape.IsNull()
+ || (aNewShape.ShapeType() == TopAbs_EDGE && BRep_Tool::Degenerated(TopoDS::Edge(aNewShape)));
+ if (aSkip) {
+ ListOfShape::iterator aRemoveIt = anIt++;
+ theShapes.erase(aRemoveIt);
+ } else {
+ ++anIt;
}
}
}
// Keep only the shapes with minimal shape type
-static void keepTopLevelShapes(ListOfShape& theShapes, const TopoDS_Shape& theRoot,
- const GeomShapePtr& theResultShape = GeomShapePtr())
+static void keepTopLevelShapes(ListOfShape& theShapes,
+ const TopoDS_Shape& theRoot,
+ const GeomShapePtr& theResultShape = GeomShapePtr())
{
GeomAPI_Shape::ShapeType aKeepShapeType = GeomAPI_Shape::SHAPE;
ListOfShape::iterator anIt = theShapes.begin();
while (anIt != theShapes.end()) {
TopoDS_Shape aNewShape = (*anIt)->impl<TopoDS_Shape>();
- if (theRoot.IsSame(aNewShape) || (theResultShape &&
+ bool aSkip = aNewShape.IsNull() ||
+ (aNewShape.ShapeType() == TopAbs_EDGE && BRep_Tool::Degenerated(TopoDS::Edge(aNewShape)));
+ if (aSkip || theRoot.IsSame(aNewShape) || (theResultShape &&
(!theResultShape->isSubShape(*anIt, false) || theResultShape->isSame(*anIt)))) {
ListOfShape::iterator aRemoveIt = anIt++;
theShapes.erase(aRemoveIt);
return TopAbs_VERTEX; // bad case
}
-void Model_BodyBuilder::loadAndOrientModifiedShapes (
- GeomAlgoAPI_MakeShape* theMS,
- std::shared_ptr<GeomAPI_Shape> theShapeIn,
- const int theKindOfShape,
- const int theTag,
- const std::string& theName,
- GeomAPI_DataMapOfShapeShape& theSubShapes,
- const bool theIsStoreSeparate,
- const bool theIsStoreAsGenerated)
+void Model_BodyBuilder::loadModifiedShapes(const GeomMakeShapePtr& theAlgo,
+ const GeomShapePtr& theOldShape,
+ const GeomAPI_Shape::ShapeType theShapeTypeToExplore,
+ const std::string& theName)
{
- int anIndex = 1;
- int aTag = theTag;
- bool isBuilt = !theName.empty();
- std::string aName = theName;
- std::ostringstream aStream;
GeomShapePtr aResultShape = shape();
- TopoDS_Shape aShapeIn = theShapeIn->impl<TopoDS_Shape>();
- TopTools_MapOfShape aView;
+ GeomShapePtr aShapeToExplore = theOldShape;
+ if (theAlgo->isNewShapesCollected(theOldShape, theShapeTypeToExplore)) {
+ // use optimized set of old shapes for this
+ GeomShapePtr aCompound = theAlgo->oldShapesForNew(theOldShape,
+ aResultShape,
+ theShapeTypeToExplore);
+ if (aCompound.get()) aShapeToExplore = aCompound;
+ }
+
+ TopTools_MapOfShape anAlreadyProcessedShapes;
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
- TopExp_Explorer aShapeExplorer (aShapeIn, (TopAbs_ShapeEnum)theKindOfShape);
- for (; aShapeExplorer.More(); aShapeExplorer.Next ()) {
- const TopoDS_Shape& aRoot = aShapeExplorer.Current ();
- if (!aView.Add(aRoot)) continue;
-
- bool aNotInTree =
- TNaming_Tool::NamedShape(aRoot, aData->shapeLab()).IsNull();
- if (aNotInTree && !theIsStoreSeparate) {
- // there is no sense to write history if old shape does not exist in the document
- continue; // but if it is stored separately, it will be builded as a primitive
- }
- ListOfShape aList;
- std::shared_ptr<GeomAPI_Shape> aRShape(new GeomAPI_Shape());
- aRShape->setImpl((new TopoDS_Shape(aRoot)));
- theMS->modified(aRShape, aList);
- if (!theIsStoreSeparate)
- keepTopLevelShapes(aList, aRoot, aResultShape);
- // sort the list of images before naming
- GeomAlgoAPI_SortListOfShapes::sort(aList);
-
- // to trace situation where several objects are produced by one parent (#2317)
- int aSameParentShapes = -1;
- std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator
- anIt = aList.begin(), aLast = aList.end();
- for (; anIt != aLast; anIt++) {
- TopoDS_Shape aNewShape = (*anIt)->impl<TopoDS_Shape>();
- if (theSubShapes.isBound(*anIt)) {
- std::shared_ptr<GeomAPI_Shape> aMapShape(theSubShapes.find(*anIt));
- aNewShape.Orientation(aMapShape->impl<TopoDS_Shape>().Orientation());
+ for (GeomAPI_ShapeExplorer anOldShapeExp(aShapeToExplore, theShapeTypeToExplore);
+ anOldShapeExp.more();
+ anOldShapeExp.next())
+ {
+ GeomShapePtr anOldSubShape = anOldShapeExp.current();
+ const TopoDS_Shape& anOldSubShape_ = anOldSubShape->impl<TopoDS_Shape>();
+
+ // There is no sense to write history if shape already processed
+ // or old shape does not exist in the document.
+ bool anOldSubShapeAlreadyProcessed = !anAlreadyProcessedShapes.Add(anOldSubShape_);
+ bool anOldSubShapeNotInTree = TNaming_Tool::NamedShape(anOldSubShape_, aData->shapeLab())
+ .IsNull();
+ if (anOldSubShapeAlreadyProcessed
+ || anOldSubShapeNotInTree)
+ {
+ continue;
+ }
+
+ // Get new shapes.
+ ListOfShape aNewShapes;
+ theAlgo->modified(anOldSubShape, aNewShapes);
+
+ for (ListOfShape::const_iterator aNewShapesIt = aNewShapes.cbegin();
+ aNewShapesIt != aNewShapes.cend();
+ ++aNewShapesIt)
+ {
+ GeomShapePtr aNewShape = *aNewShapesIt;
+ const TopoDS_Shape& aNewShape_ = aNewShape->impl<TopoDS_Shape>();
+ bool isGenerated = anOldSubShape_.ShapeType() != aNewShape_.ShapeType();
+
+ bool aNewShapeIsSameAsOldShape = anOldSubShape->isSame(aNewShape);
+ bool aNewShapeIsNotInResultShape = !aResultShape->isSubShape(aNewShape, false);
+ if (aNewShapeIsSameAsOldShape
+ || aNewShapeIsNotInResultShape)
+ {
+ continue;
}
- GeomShapePtr aGeomNewShape(new GeomAPI_Shape());
- aGeomNewShape->setImpl(new TopoDS_Shape(aNewShape));
- if(!aRoot.IsSame(aNewShape) && aResultShape->isSubShape(aGeomNewShape, false) &&
- !aResultShape->isSame(*anIt)) { // to avoid put of same shape on main label and sub
- int aBuilderTag = aTag;
- if (!theIsStoreSeparate) {
- aSameParentShapes++;
- } else if (aNotInTree) { // check this new shape can not be represented as
- // a sub-shape of higher level sub-shapes
- TopAbs_ShapeEnum aNewType = aNewShape.ShapeType();
- TopAbs_ShapeEnum anAncestorType = typeOfAncestor(aNewType);
- if (anAncestorType != TopAbs_VERTEX) {
- bool aFound = false;
- TopoDS_Shape aResultTShape = aResultShape->impl<TopoDS_Shape>();
- TopExp_Explorer anAncestorExp(aResultTShape, anAncestorType);
- for(; anAncestorExp.More() && !aFound; anAncestorExp.Next()) {
- if (aResultTShape.IsSame(anAncestorExp.Current()))
- continue;
- TopExp_Explorer aSubExp(anAncestorExp.Current(), aNewType);
- for(; aSubExp.More(); aSubExp.Next()) {
- if (aNewShape.IsSame(aSubExp.Current())) {
- aFound = true;
- break;
- }
- }
- }
- if (aFound) {
- continue; // not need to store this shape in the BRep structure
- }
- }
- }
- static const int THE_ANCHOR_TAG = 100000;
- int aCurShapeType = (int)((*anIt)->shapeType());
- bool needSuffix = false; // suffix for the name based on the shape type
- if (aSameParentShapes > 0) { // store in other label
- aBuilderTag = THE_ANCHOR_TAG - aSameParentShapes * 10 - aCurShapeType;
- needSuffix = true;
- } else if (aCurShapeType != theKindOfShape) {
- // modified shape has different type => set another tag
- // to avoid shapes of different types on the same label
- aBuilderTag = THE_ANCHOR_TAG - aCurShapeType;
- needSuffix = true;
- }
- std::string aSuffix;
- if (needSuffix) {
- switch (aCurShapeType) {
- case GeomAPI_Shape::VERTEX: aSuffix = "_v"; break;
- case GeomAPI_Shape::EDGE: aSuffix = "_e"; break;
- case GeomAPI_Shape::FACE: aSuffix = "_f"; break;
- default: break;
- }
+ TNaming_Builder* aBuilder;
+ if (aResultShape->isSame(aNewShape)) {
+ // keep the modification evolution on the root level (2241 - history propagation issue)
+ aBuilder = builder(0);
+ TDF_Label aShapeLab = aBuilder->NamedShape()->Label();
+ Handle(TDF_Reference) aRef;
+ if (aShapeLab.FindAttribute(TDF_Reference::GetID(), aRef)) {
+ // Store only in case if it does not have reference.
+ continue;
}
- if(theIsStoreAsGenerated) {
- // Here we store shapes as generated, to avoid problem when one parent shape produce
- // several child shapes. In this case naming could not determine which shape to select.
- builder(aBuilderTag)->Generated(aRoot, aNewShape);
- } else if (aNotInTree) {
- // not in tree -> store as primitive (stored as separated)
- builder(aBuilderTag)->Generated(aNewShape);
- } else {
- builder(aBuilderTag)->Modify(aRoot, aNewShape);
- }
- if(isBuilt) {
- aStream.str(std::string());
- aStream.clear();
- aStream << theName;
- if(theIsStoreSeparate)
- aStream << "_" << anIndex++;
-
- if (aSameParentShapes > 0) {
- aStream.str(std::string());
- aStream.clear();
- aStream << aName << "_" << aSameParentShapes << "divided";
- }
+ // Check if new shape was already stored.
+ if (isAlreadyStored(aBuilder, anOldSubShape_, aNewShape_)) continue;
- aStream << aSuffix;
- buildName(aBuilderTag, aStream.str());
- }
- if(theIsStoreSeparate) {
- aTag++;
- }
- } else if (aResultShape->isSame(*anIt)) {
- // keep the modification evolution on the root level (2241 - history propagation issue)
- if(theIsStoreAsGenerated) {
- builder(0)->Generated(aRoot, aNewShape);
- } else {
- builder(0)->Modify(aRoot, aNewShape);
+ if (!aBuilder->NamedShape().IsNull() &&
+ ((isGenerated && aBuilder->NamedShape()->Evolution() != TNaming_GENERATED)
+ || (!isGenerated && aBuilder->NamedShape()->Evolution() != TNaming_MODIFY)))
+ {
+ myBuilders.erase(0); // clear old builder to avoid different evolutions crash
+ aBuilder = builder(0);
}
+ } else {
+ int aTag = isGenerated ? getGenerationTag(aNewShape_)
+ : getModificationTag(aNewShape_);
+ aBuilder = builder(aTag);
+
+ // Check if new shape was already stored.
+ if (isAlreadyStored(aBuilder, anOldSubShape_, aNewShape_)) continue;
+
+ buildName(aTag, theName);
}
+
+ isGenerated ? aBuilder->Generated(anOldSubShape_, aNewShape_)
+ : aBuilder->Modify(anOldSubShape_, aNewShape_);
}
}
}
-void Model_BodyBuilder::loadAndOrientGeneratedShapes (
- GeomAlgoAPI_MakeShape* theMS,
- std::shared_ptr<GeomAPI_Shape> theShapeIn,
- const int theKindOfShape,
- const int theTag,
- const std::string& theName,
- GeomAPI_DataMapOfShapeShape& theSubShapes)
+void Model_BodyBuilder::loadGeneratedShapes(const GeomMakeShapePtr& theAlgo,
+ const GeomShapePtr& theOldShape,
+ const GeomAPI_Shape::ShapeType theShapeTypeToExplore,
+ const std::string& theName)
{
- TopoDS_Shape aShapeIn = theShapeIn->impl<TopoDS_Shape>();
- TopTools_MapOfShape aView;
- bool isBuilt = !theName.empty();
- TopExp_Explorer aShapeExplorer (aShapeIn, (TopAbs_ShapeEnum)theKindOfShape);
- for (; aShapeExplorer.More(); aShapeExplorer.Next ()) {
- const TopoDS_Shape& aRoot = aShapeExplorer.Current ();
- if (!aView.Add(aRoot)) continue;
- //if (TNaming_Tool::NamedShape(aRoot, builder(theTag)->NamedShape()->Label()).IsNull())
- // continue; // there is no sense to write history if old shape does not exist in the document
- ListOfShape aList;
- std::shared_ptr<GeomAPI_Shape> aRShape(new GeomAPI_Shape());
- aRShape->setImpl((new TopoDS_Shape(aRoot)));
- theMS->generated(aRShape, aList);
- keepTopLevelShapes(aList, aRoot);
- std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator
- anIt = aList.begin(), aLast = aList.end();
- for (; anIt != aLast; anIt++) {
- TopoDS_Shape aNewShape = (*anIt)->impl<TopoDS_Shape>();
- if (theSubShapes.isBound(*anIt)) {
- std::shared_ptr<GeomAPI_Shape> aMapShape(theSubShapes.find(*anIt));
- aNewShape.Orientation(aMapShape->impl<TopoDS_Shape>().Orientation());
- }
- if (!aRoot.IsSame (aNewShape)) {
- builder(theTag)->Generated(aRoot,aNewShape);
- if(isBuilt)
- buildName(theTag, theName);
- }
- TopAbs_ShapeEnum aGenShapeType = aNewShape.ShapeType();
- if(aGenShapeType == TopAbs_WIRE || aGenShapeType == TopAbs_SHELL) {
- TopAbs_ShapeEnum anExplodeShapeType =
- aGenShapeType == TopAbs_WIRE ? TopAbs_EDGE : TopAbs_FACE;
- const TDF_Label aLabel = builder(theTag)->NamedShape()->Label();
- int aTag = 1;
- std::shared_ptr<Model_Document> aDoc =
- std::dynamic_pointer_cast<Model_Document>(document());
- for(TopExp_Explorer anExp(aNewShape, anExplodeShapeType); anExp.More(); anExp.Next()) {
- TDF_Label aChildLabel = aLabel.FindChild(aTag);
- TNaming_Builder aBuilder(aChildLabel);
- aBuilder.Generated(aRoot, anExp.Current());
- TCollection_AsciiString aChildName =
- TCollection_AsciiString((theName + "_").c_str()) + aTag;
- TDataStd_Name::Set(aChildLabel, aChildName.ToCString());
- aTag++;
+ TopTools_MapOfShape anAlreadyProcessedShapes;
+ for (GeomAPI_ShapeExplorer anOldShapeExp(theOldShape, theShapeTypeToExplore);
+ anOldShapeExp.more();
+ anOldShapeExp.next())
+ {
+ GeomShapePtr anOldSubShape = anOldShapeExp.current();
+ const TopoDS_Shape& anOldSubShape_ = anOldSubShape->impl<TopoDS_Shape>();
+
+ // There is no sense to write history if shape already processed.
+ if (!anAlreadyProcessedShapes.Add(anOldSubShape_)) continue;
+
+ // Get new shapes.
+ ListOfShape aNewShapes;
+ theAlgo->generated(anOldSubShape, aNewShapes);
+
+ keepTopLevelShapes(aNewShapes, anOldSubShape_);
+
+ for (ListOfShape::const_iterator aNewShapesIt = aNewShapes.cbegin();
+ aNewShapesIt != aNewShapes.cend();
+ ++aNewShapesIt)
+ {
+ GeomShapePtr aNewShape = *aNewShapesIt;
+ const TopoDS_Shape& aNewShape_ = aNewShape->impl<TopoDS_Shape>();
+
+ TopAbs_ShapeEnum aNewShapeType = aNewShape_.ShapeType();
+ if (aNewShapeType == TopAbs_WIRE || aNewShapeType == TopAbs_SHELL) {
+ // TODO: This is a workaround. New shape should be only edge or face.
+ TopAbs_ShapeEnum aShapeTypeToExplore = aNewShapeType == TopAbs_WIRE ? TopAbs_EDGE
+ : TopAbs_FACE;
+ int aTag = TopAbs_WIRE ? GENERATED_EDGES_TAG : GENERATED_FACES_TAG;
+ for (TopExp_Explorer anExp(aNewShape_, aShapeTypeToExplore); anExp.More(); anExp.Next()) {
+ builder(aTag)->Generated(anOldSubShape_, anExp.Current());
}
+ buildName(aTag, theName);
+ }
+ else {
+ int aTag = getGenerationTag(aNewShape_);
+ if (aTag == INVALID_TAG) return;
+ builder(aTag)->Generated(anOldSubShape_, aNewShape_);
+ buildName(aTag, theName);
}
}
}
}
//=======================================================================
-void Model_BodyBuilder::loadNextLevels(std::shared_ptr<GeomAPI_Shape> theShape,
- const std::string& theName, int& theTag)
+void Model_BodyBuilder::loadNextLevels(GeomShapePtr theShape,
+ const std::string& theName)
{
if(theShape->isNull()) return;
TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();
if (aShape.ShapeType() == TopAbs_SOLID) {
TopExp_Explorer expl(aShape, TopAbs_FACE);
for (; expl.More(); expl.Next()) {
- builder(theTag)->Generated(expl.Current());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(expl.Current());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
else if (aShape.ShapeType() == TopAbs_SHELL || aShape.ShapeType() == TopAbs_FACE) {
if (Faces.Extent() > 1 || (aShape.ShapeType() == TopAbs_SHELL && Faces.Extent() == 1)) {
TopExp_Explorer expl(aShape, TopAbs_FACE);
for (; expl.More(); expl.Next()) {
- builder(theTag)->Generated(expl.Current());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(expl.Current());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
TopTools_IndexedDataMapOfShapeListOfShape anEdgeAndNeighbourFaces;
if (aLL.Extent() < 2) {
if (BRep_Tool::Degenerated(TopoDS::Edge(anEdgeAndNeighbourFaces.FindKey(i))))
continue;
- builder(theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
} else {
TopTools_ListIteratorOfListOfShape anIter(aLL);
const TopoDS_Face& aFace = TopoDS::Face(anIter.Value());
anIter.Next();
if(aFace.IsEqual(anIter.Value())) {
- builder(theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
}
TopTools_IndexedMapOfShape Edges;
BRepTools::Map3DEdges(aShape, Edges);
if (Edges.Extent() == 1) {
- builder(theTag++)->Generated(Edges.FindKey(1));
+ builder(myFreePrimitiveTag++)->Generated(Edges.FindKey(1));
TopExp_Explorer expl(aShape, TopAbs_VERTEX);
for (; expl.More(); expl.Next()) {
- builder(theTag)->Generated(expl.Current());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(expl.Current());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
} else {
TopExp_Explorer expl(aShape, TopAbs_EDGE);
for (; expl.More(); expl.Next()) {
- builder(theTag)->Generated(expl.Current());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(expl.Current());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
// and load generated vertices.
TopTools_DataMapOfShapeShape generated;
if (getDangleShapes(aShape, TopAbs_EDGE, generated))
{
- TNaming_Builder* pBuilder = builder(theTag++);
+ TNaming_Builder* pBuilder = builder(myFreePrimitiveTag++);
loadGeneratedDangleShapes(aShape, TopAbs_EDGE, pBuilder);
}
}
} else if (aShape.ShapeType() == TopAbs_EDGE) {
TopExp_Explorer expl(aShape, TopAbs_VERTEX);
for (; expl.More(); expl.Next()) {
- builder(theTag)->Generated(expl.Current());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(expl.Current());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
}
}
//=======================================================================
-void Model_BodyBuilder::loadFirstLevel(
- std::shared_ptr<GeomAPI_Shape> theShape, const std::string& theName, int& theTag)
+void Model_BodyBuilder::loadFirstLevel(GeomShapePtr theShape, const std::string& theName)
{
if(theShape->isNull()) return;
TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();
if (aShape.ShapeType() == TopAbs_COMPOUND || aShape.ShapeType() == TopAbs_COMPSOLID) {
TopoDS_Iterator itr(aShape);
for (; itr.More(); itr.Next()) {
- builder(theTag)->Generated(itr.Value());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- if(!theName.empty()) buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(itr.Value());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
if (itr.Value().ShapeType() == TopAbs_COMPOUND ||
itr.Value().ShapeType() == TopAbs_COMPSOLID)
{
- std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+ GeomShapePtr itrShape(new GeomAPI_Shape());
itrShape->setImpl(new TopoDS_Shape(itr.Value()));
- loadFirstLevel(itrShape, theName, theTag);
+ loadFirstLevel(itrShape, theName);
} else {
- std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+ GeomShapePtr itrShape(new GeomAPI_Shape());
itrShape->setImpl(new TopoDS_Shape(itr.Value()));
- loadNextLevels(itrShape, theName, theTag);
+ loadNextLevels(itrShape, theName);
}
}
} else {
- std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+ GeomShapePtr itrShape(new GeomAPI_Shape());
itrShape->setImpl(new TopoDS_Shape(aShape));
- loadNextLevels(itrShape, theName, theTag);
+ loadNextLevels(itrShape, theName);
}
TopTools_ListOfShape aList;
if(findAmbiguities(aShape, aList)) {
TopTools_ListIteratorOfListOfShape it(aList);
- for (; it.More(); it.Next(),theTag++) {
- builder(theTag)->Generated(it.Value());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
+ for (; it.More(); it.Next(), ++myFreePrimitiveTag) {
+ builder(myFreePrimitiveTag)->Generated(it.Value());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
}
}
}
//=======================================================================
-void Model_BodyBuilder::loadDisconnectedEdges(
- std::shared_ptr<GeomAPI_Shape> theShape, const std::string& theName, int& theTag)
+void Model_BodyBuilder::loadDisconnectedEdges(GeomShapePtr theShape, const std::string& theName)
{
if(theShape->isNull()) return;
TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();
if (aLIter1.Value().IsSame(aLIter2.Value())) aMatches++;
if (aMatches == aList1.Extent()) {
aC0=Standard_True;
- builder(theTag)->Generated(anEdge2);
+ builder(myFreePrimitiveTag)->Generated(anEdge2);
anEdgesToDelete.Add(anEdge2);
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
}
edgeNaborFaces.UnBind(anEdge1);
}
if (aC0) {
- builder(theTag)->Generated(anEdge1);
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(anEdge1);
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
}
-void Model_BodyBuilder::loadDisconnectedVertexes(std::shared_ptr<GeomAPI_Shape> theShape,
- const std::string& theName, int& theTag)
+void Model_BodyBuilder::loadDisconnectedVertexes(GeomShapePtr theShape,
+ const std::string& theName)
{
if(theShape->isNull()) return;
TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();
for (; itr.More(); itr.Next()) {
const TopTools_ListOfShape& naborEdges = itr.Value();
if (naborEdges.Extent() < 2) {
- builder(theTag)->Generated(itr.Key());
- TCollection_AsciiString aStr(theTag);
- aName = theName + aStr.ToCString();
- buildName(theTag, aName);
- theTag++;
+ builder(myFreePrimitiveTag)->Generated(itr.Key());
+ TCollection_AsciiString aStr(myFreePrimitiveTag - PRIMITIVES_START_TAG + 1);
+ aName = theName + "_" + aStr.ToCString();
+ buildName(myFreePrimitiveTag, aName);
+ ++myFreePrimitiveTag;
}
}
}
-std::shared_ptr<GeomAPI_Shape> Model_BodyBuilder::shape()
+GeomShapePtr Model_BodyBuilder::shape()
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
- if (aData) {
+ if (aData && aData->isValid()) {
TDF_Label aShapeLab = aData->shapeLab();
Handle(TDF_Reference) aRef;
if (aShapeLab.FindAttribute(TDF_Reference::GetID(), aRef)) {
if (aShapeLab.FindAttribute(TNaming_NamedShape::GetID(), aName)) {
TopoDS_Shape aShape = aName->Get();
if (!aShape.IsNull()) {
- std::shared_ptr<GeomAPI_Shape> aRes(new GeomAPI_Shape);
+ GeomShapePtr aRes(new GeomAPI_Shape);
aRes->setImpl(new TopoDS_Shape(aShape));
return aRes;
}
}
}
- return std::shared_ptr<GeomAPI_Shape>();
+ return GeomShapePtr();
}
-bool Model_BodyBuilder::isLatestEqual(const std::shared_ptr<GeomAPI_Shape>& theShape)
+bool Model_BodyBuilder::isLatestEqual(const GeomShapePtr& theShape)
{
if (theShape.get()) {
TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();
