#include <Model_Data.h>
#include <Model_Document.h>
+#include <ModelAPI_Session.h>
#include <TNaming_Builder.hxx>
#include <TNaming_NamedShape.hxx>
#include <TNaming_Iterator.hxx>
#include <TNaming_Tool.hxx>
+#include <TNaming_SameShapeIterator.hxx>
#include <TDataStd_Name.hxx>
#include <TDataStd_Integer.hxx>
+#include <TDataStd_ExtStringList.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <TDF_ChildIterator.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_Reference.hxx>
+#include <TDF_Tool.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Config_PropManager.h>
// DEB
//#include <TCollection_AsciiString.hxx>
-//#include <TDF_Tool.hxx>
//#define DEB_IMPORT 1
+/// reference to the shape in external document: sting list attribute identifier
+static const Standard_GUID kEXTERNAL_SHAPE_REF("9aa5dd14-6d34-4a8d-8786-05842fd7bbbd");
+
static const int INVALID_TAG = -1;
static const int GENERATED_VERTICES_TAG = 1;
static const int GENERATED_EDGES_TAG = 2;
Model_BodyBuilder::Model_BodyBuilder(ModelAPI_Object* theOwner)
: ModelAPI_BodyBuilder(theOwner),
- myPrimitiveTag(PRIMITIVES_START_TAG),
- myDividedIndex(1),
- myVIndex(1),
- myEIndex(1),
- myFIndex(1)
+ myFreePrimitiveTag(PRIMITIVES_START_TAG)
{
}
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
- TDF_Label& aShapeLab = aData->shapeLab();
+ TDF_Label aShapeLab = aData->shapeLab();
// clean builders
clean();
// store the new shape as primitive
if(!theIsStoreSameShapes) {
Handle(TNaming_NamedShape) aNS = TNaming_Tool::NamedShape(aShape, aShapeLab);
- if(!aNS.IsNull() && !aNS->IsEmpty()) {
+ // the last condition is for the issue 2751 : existing shape may be found in compound-NS
+ if(!aNS.IsNull() && !aNS->IsEmpty() && aNS->Get().IsSame(aShape)) {
// This shape is already in document, store reference instead of shape;
const TDF_Label aFoundLabel = aNS->Label();
TDF_Reference::Set(aShapeLab, aFoundLabel);
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
- TDF_Label& aShapeLab = aData->shapeLab();
+ TDF_Label aShapeLab = aData->shapeLab();
// clean builders
clean();
// store the new shape as primitive
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
- TDF_Label& aShapeLab = aData->shapeLab();
// clean builders
if (theIsCleanStored) clean();
// store the new shape as primitive
return;
std::map<int, TNaming_Builder*>::iterator aBuilder = myBuilders.begin();
for(; aBuilder != myBuilders.end(); aBuilder++) {
+ Handle(TNaming_NamedShape) aNS = aBuilder->second->NamedShape();
delete aBuilder->second;
- // clear also shapes on cleaned sub-labels (#2241)
- Handle(TNaming_NamedShape) aNS;
- if (aLab.FindChild(aBuilder->first).FindAttribute(TNaming_NamedShape::GetID(), aNS)) {
- aNS->Clear();
- }
+ if (!aNS.IsNull() && !aNS->Label().IsNull())
+ aNS->Label().ForgetAttribute(TNaming_NamedShape::GetID());
}
myBuilders.clear();
+ myPrimitivesNamesIndexMap.clear();
// remove the old reference (if any)
aLab.ForgetAttribute(TDF_Reference::GetID());
- myPrimitiveTag = PRIMITIVES_START_TAG;
- myDividedIndex = 1;
- myVIndex = 1;
- myEIndex = 1;
- myFIndex = 1;
+ myFreePrimitiveTag = PRIMITIVES_START_TAG;
+ TDF_ChildIDIterator anEntriesIter(aLab, kEXTERNAL_SHAPE_REF, true);
+ for(; anEntriesIter.More(); anEntriesIter.Next()) {
+ anEntriesIter.Value()->Label().ForgetAttribute(kEXTERNAL_SHAPE_REF);
+ }
}
Model_BodyBuilder::~Model_BodyBuilder()
void Model_BodyBuilder::buildName(const int theTag, const std::string& theName)
{
- std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(document());
std::string aName = theName;
+ std::string aPrefix = "";
switch (theTag) {
- case GENERATED_VERTICES_TAG: aName += aName.empty() ? "Generated_Vertex" : "_GV"; break;
- case GENERATED_EDGES_TAG: aName += aName.empty() ? "Generated_Edge" : "_GE"; break;
- case GENERATED_FACES_TAG: aName += aName.empty() ? "Generated_Face" : "_GF"; break;
- case MODIFIED_VERTICES_TAG: aName += aName.empty() ? "Modified_Vertex" : "_MV"; break;
- case MODIFIED_EDGES_TAG: aName += aName.empty() ? "Modified_Edge" : "_ME"; break;
- case MODIFIED_FACES_TAG: aName += aName.empty() ? "Modified_Face" : "_MF"; break;
+ 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;
}
+ aName.insert(0, aPrefix);
TDataStd_Name::Set(builder(theTag)->NamedShape()->Label(), aName.c_str());
}
-void Model_BodyBuilder::generated(const GeomShapePtr& theNewShape,
- const std::string& theName)
+bool Model_BodyBuilder::generated(const GeomShapePtr& theNewShape,
+ const std::string& theName,
+ const bool theCheckIsInResult)
{
+ GeomShapePtr aResultShape = shape();
+ if (theCheckIsInResult) {
+ bool aNewShapeIsNotInResultShape = !aResultShape->isSubShape(theNewShape, false);
+ if (aNewShapeIsNotInResultShape) {
+ return false;
+ }
+ }
+
TopoDS_Shape aShape = theNewShape->impl<TopoDS_Shape>();
- builder(myPrimitiveTag)->Generated(aShape);
+ builder(myFreePrimitiveTag)->Generated(aShape);
if (!theName.empty()) {
- buildName(myPrimitiveTag, theName);
- }
+ std::string aName = theName;
+ if (myPrimitivesNamesIndexMap.find(theName) != myPrimitivesNamesIndexMap.end()) {
+ IndexTags& anIndexTags = myPrimitivesNamesIndexMap.find(theName)->second;
+ aName += "_" + std::to_string(++(anIndexTags.index));
+ anIndexTags.tags.push_back(myFreePrimitiveTag);
+ if (anIndexTags.index == 2) {
+ buildName(anIndexTags.tags.front(), theName + "_1");
+ }
+ }
+ else {
+ IndexTags anIndexTags;
+ anIndexTags.index = 1;
+ anIndexTags.tags.push_back(myFreePrimitiveTag);
+ myPrimitivesNamesIndexMap[theName] = anIndexTags;
+ }
- ++myPrimitiveTag;
+ buildName(myFreePrimitiveTag, aName);
+ }
+ ++myFreePrimitiveTag;
+ return true;
}
void Model_BodyBuilder::generated(const GeomShapePtr& theOldShape,
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 anExplodeShapeType = aNewShapeType == TopAbs_WIRE ? TopAbs_EDGE : TopAbs_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, anExplodeShapeType); anExp.More(); anExp.Next()) {
+ for (TopExp_Explorer anExp(aNewShape, aShapeTypeToExplore); anExp.More(); anExp.Next()) {
builder(aTag)->Generated(anOldShape, anExp.Current());
- buildName(aTag, theName);
}
+ buildName(aTag, theName);
} else {
aTag = getGenerationTag(aNewShape);
if (aTag == INVALID_TAG) return;
}
// 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();
}
}
-// returns an ancestor shape-type thaty used for naming-definition of the sub-type
+// returns an ancestor shape-type that used for naming-definition of the sub-type
TopAbs_ShapeEnum typeOfAncestor(const TopAbs_ShapeEnum theSubType) {
if (theSubType == TopAbs_VERTEX)
return TopAbs_EDGE;
return TopAbs_VERTEX; // bad case
}
+/// Checks that shape is presented in the tree with not-selection evolution
+/// In theOriginalLabel it returns label where NS of old sub-shape is stored
+static bool isShapeInTree(const TDF_Label& theAccess1, const TDF_Label& theAccess2,
+ TopoDS_Shape theShape, TDF_Label& theOriginalLabel)
+{
+ bool aResult = TNaming_Tool::HasLabel(theAccess1, theShape);
+ if (aResult) { //check evolution and a label of this shape
+ for(TNaming_SameShapeIterator aShapes(theShape, theAccess1); aShapes.More(); aShapes.Next())
+ {
+ static Handle(TNaming_NamedShape) aNS;
+ if (aShapes.Label().FindAttribute(TNaming_NamedShape::GetID(), aNS)) {
+ if (aNS->Evolution() != TNaming_SELECTED) {
+ theOriginalLabel = aNS->Label();
+ return true;
+ }
+ }
+ }
+ }
+ if (!theAccess2.IsNull()) {
+ static const TDF_Label anEmpty;
+ return isShapeInTree(theAccess2, anEmpty, theShape, theOriginalLabel);
+ }
+ return false;
+}
+
+/// Stores entry to the external label in the entries list at this label
+static void storeExternalReference(const TDF_Label& theExternal, const TDF_Label theThis)
+{
+ // store information about the external document reference to restore old shape on open
+ if (!theExternal.IsNull() && !theExternal.Root().IsEqual(theThis.Root())) {
+ Handle(TDataStd_ExtStringList) anEntries;
+ if (!theThis.FindAttribute(kEXTERNAL_SHAPE_REF, anEntries)) {
+ anEntries = TDataStd_ExtStringList::Set(theThis, kEXTERNAL_SHAPE_REF);
+ }
+ TCollection_AsciiString anEntry;
+ TDF_Tool::Entry(theExternal, anEntry);
+ // check it already contains this entry
+ TDataStd_ListOfExtendedString::Iterator anIter(anEntries->List());
+ for(; anIter.More(); anIter.Next())
+ if (anIter.Value() == anEntry)
+ break;
+ if (!anIter.More()) {
+ anEntries->Append(anEntry);
+ }
+ }
+}
+
void Model_BodyBuilder::loadModifiedShapes(const GeomMakeShapePtr& theAlgo,
const GeomShapePtr& theOldShape,
const GeomAPI_Shape::ShapeType theShapeTypeToExplore,
// 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)
- {
+ TDF_Label anAccess2 = std::dynamic_pointer_cast<Model_Document>(
+ ModelAPI_Session::get()->moduleDocument())->generalLabel();
+ TDF_Label anOriginalLabel;
+ bool anOldSubShapeNotInTree =
+ !isShapeInTree(aData->shapeLab(), anAccess2, anOldSubShape_, anOriginalLabel);
+ if (anOldSubShapeAlreadyProcessed || anOldSubShapeNotInTree) {
continue;
}
isGenerated ? aBuilder->Generated(anOldSubShape_, aNewShape_)
: aBuilder->Modify(anOldSubShape_, aNewShape_);
+ // store information about the external document reference to restore old shape on open
+ storeExternalReference(anOriginalLabel, aBuilder->NamedShape()->Label());
}
}
}
-void Model_BodyBuilder::loadAndOrientGeneratedShapes (
- GeomAlgoAPI_MakeShape* theMS,
- GeomShapePtr 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;
- GeomShapePtr aRShape(new GeomAPI_Shape());
- aRShape->setImpl((new TopoDS_Shape(aRoot)));
- theMS->generated(aRShape, aList);
- keepTopLevelShapes(aList, aRoot);
- std::list<GeomShapePtr >::const_iterator
- anIt = aList.begin(), aLast = aList.end();
- for (; anIt != aLast; anIt++) {
- TopoDS_Shape aNewShape = (*anIt)->impl<TopoDS_Shape>();
- if (theSubShapes.isBound(*anIt)) {
- GeomShapePtr 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);
+ GeomShapePtr aResultShape = shape();
+ TopTools_MapOfShape anAlreadyProcessedShapes;
+ std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
+ 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
+ // or old shape does not exist in the document.
+ bool anOldSubShapeAlreadyProcessed = !anAlreadyProcessedShapes.Add(anOldSubShape_);
+ TDF_Label anAccess2 = std::dynamic_pointer_cast<Model_Document>(
+ ModelAPI_Session::get()->moduleDocument())->generalLabel();
+ TDF_Label anOriginalLabel;
+ bool anOldSubShapeNotInTree =
+ !isShapeInTree(aData->shapeLab(), anAccess2, anOldSubShape_, anOriginalLabel);
+ if (anOldSubShapeAlreadyProcessed || anOldSubShapeNotInTree) {
+ 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>();
+
+ bool aNewShapeIsSameAsOldShape = anOldSubShape->isSame(aNewShape);
+ bool aNewShapeIsNotInResultShape = !aResultShape->isSubShape(aNewShape, false);
+ if (aNewShapeIsSameAsOldShape
+ || aNewShapeIsNotInResultShape)
+ {
+ continue;
}
- 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++;
+
+ 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());
+ // store information about the external document reference to restore old shape on open
+ storeExternalReference(anOriginalLabel, builder(aTag)->NamedShape()->Label());
}
+ buildName(aTag, theName);
+ }
+ else {
+ int aTag = getGenerationTag(aNewShape_);
+ if (aTag == INVALID_TAG) return;
+ builder(aTag)->Generated(anOldSubShape_, aNewShape_);
+ buildName(aTag, theName);
+ // store information about the external document reference to restore old shape on open
+ storeExternalReference(anOriginalLabel, builder(aTag)->NamedShape()->Label());
}
}
}
//=======================================================================
void Model_BodyBuilder::loadNextLevels(GeomShapePtr theShape,
- const std::string& theName, int& theTag)
+ 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(
- GeomShapePtr 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)
{
GeomShapePtr itrShape(new GeomAPI_Shape());
itrShape->setImpl(new TopoDS_Shape(itr.Value()));
- loadFirstLevel(itrShape, theName, theTag);
+ loadFirstLevel(itrShape, theName);
} else {
GeomShapePtr itrShape(new GeomAPI_Shape());
itrShape->setImpl(new TopoDS_Shape(itr.Value()));
- loadNextLevels(itrShape, theName, theTag);
+ loadNextLevels(itrShape, theName);
}
}
} else {
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(
- GeomShapePtr 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(anEdgesToDelete.Contains(anEdge2)) continue;
if (anEdge1.IsSame(anEdge2)) continue;
const TopTools_ListOfShape& aList2 = itr.Value();
- // compare lists of the neighbour faces of edge1 and edge2
+ // compare lists of the neighbor faces of edge1 and edge2
if (aList1.Extent() == aList2.Extent()) {
Standard_Integer aMatches = 0;
for(TopTools_ListIteratorOfListOfShape aLIter1(aList1);aLIter1.More();aLIter1.Next())
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(GeomShapePtr theShape,
- const std::string& theName, int& theTag)
+ 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;
}
}
}
TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData) {
- TDF_Label& aShapeLab = aData->shapeLab();
+ TDF_Label aShapeLab = aData->shapeLab();
Handle(TNaming_NamedShape) aName;
if (aShapeLab.FindAttribute(TNaming_NamedShape::GetID(), aName)) {
TopoDS_Shape aLatest = TNaming_Tool::CurrentShape(aName);