-// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2023 CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
//
// 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
+// 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>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include <Model_ResultConstruction.h>
#include <Model_Data.h>
#include <ModelAPI_CompositeFeature.h>
#include <GeomAlgoAPI_SketchBuilder.h>
+#include <GeomAPI_Tools.h>
#include <ModelAPI_Events.h>
#include <Model_Document.h>
#include <GeomAPI_PlanarEdges.h>
#include <GeomAPI_Shape.h>
#include <Events_Loop.h>
+#include <GeomDataAPI_Point.h>
+#include <GeomDataAPI_Dir.h>
#include <TDF_ChildIDIterator.hxx>
#include <TNaming_NamedShape.hxx>
#include <TopoDS_ListOfShape.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_MapOfShape.hxx>
+#include <NCollection_IndexedDataMap.hxx>
#include <algorithm>
+typedef NCollection_IndexedDataMap<TopoDS_Face, TColStd_ListOfInteger> MapFaceToEdgeIndices;
+
+/// Convert each edge of sketch to corresponding integer value
+/// \param[in] theComposite sketch feature
+/// \param[out] theCurvesIndices map curve to its index
+/// \param[out] theEdgesIndices indexed edge
+/// \param[out] theEdgesNames indexed name for edge
+static void indexingSketchEdges(
+ const CompositeFeaturePtr& theComposite,
+ NCollection_DataMap<Handle(Geom_Curve), int>& theCurvesIndices,
+ NCollection_DataMap<int, TopoDS_Edge>& theEdgesIndices,
+ std::map<int, std::wstring>& theEdgesNames);
+
+/// Convert each face to the list of indices of its edges
+/// \param[in] theFaces list of faces to proceed
+/// \param[in] theCurvesIndices index of each curve
+/// \param[out] theFaceEdges map face to indices of its edges
+static void faceToEdgeIndices(
+ const ListOfShape& theFaces,
+ const NCollection_DataMap<Handle(Geom_Curve), int>& theCurvesIndices,
+ MapFaceToEdgeIndices& theFaceEdges);
+
+/// Assign faces to tags for the specified label
+/// \param theDocument current document
+/// \param theShapeLabel label to store shapes
+/// \param theName name of the object
+/// \param theShape shape to be stored to the label
+/// \param theFacesOrder faces to be assigned to specified tag
+/// \param theUnorderedFaces faces which may be stored to any tag
+/// \param theFaceEdges indices of edges for each face
+/// \param theEdgesIndices indices of edges
+/// \param theEdgesNames named of edges
+static void storeFacesOnLabel(std::shared_ptr<Model_Document>& theDocument,
+ TDF_Label& theShapeLabel,
+ const std::wstring& theName,
+ const TopoDS_Shape& theShape,
+ NCollection_DataMap<int, TopoDS_Face>& theFacesOrder,
+ NCollection_List<TopoDS_Face>& theUnorderedFaces,
+ const MapFaceToEdgeIndices& theFaceEdges,
+ const NCollection_DataMap<int, TopoDS_Edge>& theEdgesIndices,
+ const std::map<int, std::wstring>& theEdgesNames);
+
// identifier of the infinite result
Standard_GUID kIS_INFINITE("dea8cc5a-53f2-49c1-94e8-a947bed20a9f");
// identifier of the result not in history
Standard_GUID kIS_IN_HISTORY("a9aec01c-805e-44d1-b5d2-a63f06522f8a");
-
void Model_ResultConstruction::colorConfigInfo(std::string& theSection, std::string& theName,
std::string& theDefault)
{
theSection = "Visualization";
- theName = "result_construction_color";
+ theName = RESULT_COLOR_NAME();
theDefault = DEFAULT_COLOR();
}
void Model_ResultConstruction::setShape(std::shared_ptr<GeomAPI_Shape> theShape)
{
if (myShape != theShape) {
- if (!isInfinite())
- storeShape(theShape);
- static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
- ModelAPI_EventCreator::get()->sendUpdated(data()->owner(), anEvent);
+ storeShape(theShape);
+ if (!theShape.get() || !theShape->isEqual(myShape)) {
+ static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
+ ModelAPI_EventCreator::get()->sendUpdated(data()->owner(), anEvent);
+ }
myShape = theShape;
}
}
return myShape;
}
-static std::string shortName(
+static std::wstring shortName(
std::shared_ptr<ModelAPI_ResultConstruction>& theConstr)
{
- std::string aName = theConstr->data()->name();
+ std::wstring aName = theConstr->data()->name();
// remove "-", "/" and "&" command-symbols
aName.erase(std::remove(aName.begin(), aName.end(), '-'), aName.end());
aName.erase(std::remove(aName.begin(), aName.end(), '/'), aName.end());
aName.erase(std::remove(aName.begin(), aName.end(), '&'), aName.end());
// remove the last 's', 'e', 'f' and 'r' symbols:
- // they are used as markers of start/end/forward/rewersed indicators
- static const std::string aSyms("sefr");
- std::string::iterator aSuffix = aName.end() - 1;
- while(aSyms.find(*aSuffix) != std::string::npos) {
+ // they are used as markers of start/end/forward/reversed indicators
+ static const std::wstring aSyms(L"sefr");
+ std::wstring::iterator aSuffix = aName.end() - 1;
+ while(aSyms.find(*aSuffix) != std::wstring::npos) {
--aSuffix;
}
aName.erase(aSuffix + 1, aName.end());
return aName;
}
-
bool Model_ResultConstruction::updateShape()
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData && aData->isValid()) {
- TDF_Label& aShapeLab = aData->shapeLab();
+ TDF_Label aShapeLab = aData->shapeLab();
Handle(TNaming_NamedShape) aNS;
if (aShapeLab.FindAttribute(TNaming_NamedShape::GetID(), aNS)) {
TopoDS_Shape aShape = aNS->Get();
if (!aShape.IsNull()) {
+ if (aShape.ShapeType() == TopAbs_COMPOUND) {
+ // restore the sketch planar edges object
+ std::shared_ptr<GeomAPI_PlanarEdges> aBigWire(new GeomAPI_PlanarEdges);
+ aBigWire->setImpl<TopoDS_Shape>(new TopoDS_Shape(aShape));
+ FeaturePtr aSketch =
+ document()->feature(std::dynamic_pointer_cast<ModelAPI_Result>(data()->owner()));
+ std::shared_ptr<GeomDataAPI_Point> anOrigin =
+ std::dynamic_pointer_cast<GeomDataAPI_Point>(aSketch->data()->attribute("Origin"));
+ std::shared_ptr<GeomDataAPI_Dir> aDirX =
+ std::dynamic_pointer_cast<GeomDataAPI_Dir>(aSketch->data()->attribute("DirX"));
+ std::shared_ptr<GeomDataAPI_Dir> aNorm =
+ std::dynamic_pointer_cast<GeomDataAPI_Dir>(aSketch->data()->attribute("Norm"));
+ if (anOrigin.get() && aDirX.get() && aNorm.get()) {
+ aBigWire->setPlane(anOrigin->pnt(), aDirX->dir(), aNorm->dir());
+ myShape = aBigWire;
+ return true;
+ }
+ }
+ // just restore shape
GeomShapePtr aGShape(new GeomAPI_Shape);
aGShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aShape));
- myShape = aGShape; // restore the sketch sub-components
+ myShape = GeomAPI_Tools::getTypedShape(aGShape); // restore the sketch sub-components
return true;
}
}
}
}
-int Model_ResultConstruction::facesNum(const bool theUpdateNaming)
+int Model_ResultConstruction::facesNum(const bool /*theUpdateNaming*/)
{
int aResult = 0;
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData.get() && aData->isValid()) {
- TDF_Label& aShapeLab = aData->shapeLab();
+ TDF_Label aShapeLab = aData->shapeLab();
TDF_ChildIDIterator anOldIter(aShapeLab, TDataStd_IntPackedMap::GetID());
for (; anOldIter.More(); anOldIter.Next()) {
aResult++;
int anIndex = 0;
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData.get() && aData->isValid()) {
- TDF_Label& aShapeLab = aData->shapeLab();
+ TDF_Label aShapeLab = aData->shapeLab();
TDF_ChildIDIterator anOldIter(aShapeLab, TDataStd_IntPackedMap::GetID());
for (; anOldIter.More(); anOldIter.Next()) {
if (anIndex == theIndex) {
return aResult;
}
-void Model_ResultConstruction::setIsConcealed(const bool theValue)
+void Model_ResultConstruction::setIsConcealed(const bool theValue, const bool theForced)
{
- // do nothing: the construction element is never concealed
+ // the construction element may be concealed only by "delete" feature
+ if (!theValue || theForced) {
+ ModelAPI_ResultConstruction::setIsConcealed(theValue, theForced);
+ }
}
void Model_ResultConstruction::storeShape(std::shared_ptr<GeomAPI_Shape> theShape)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
if (aData && aData->isValid()) {
- std::string aMyName = data()->name();
- TDF_Label& aShapeLab = aData->shapeLab();
+ std::wstring aMyName = data()->name();
+ TDF_Label aShapeLab = aData->shapeLab();
if (!theShape.get() || theShape->isNull()) {
aShapeLab.ForgetAllAttributes();
TDataStd_Name::Set(aShapeLab, aMyName.c_str()); // restore name forgotten
std::shared_ptr<Model_Document> aMyDoc =
std::dynamic_pointer_cast<Model_Document>(document());
const TopoDS_Shape& aShape = theShape->impl<TopoDS_Shape>();
- if (aShape.ShapeType() == TopAbs_VERTEX) {
+ if (isInfinite() || aShape.ShapeType() == TopAbs_VERTEX) {
aShapeLab.ForgetAllAttributes(); // clear all previously stored
TNaming_Builder aBuilder(aShapeLab);
aBuilder.Generated(aShape);
TopExp_Explorer anExp(aShape, TopAbs_VERTEX);
for(int anIndex = 1; anExp.More(); anExp.Next(), anIndex++) {
- TDF_Label aSubLab = aShapeLab.FindChild(anIndex);;
- TNaming_Builder aBuilder(aSubLab);
- aBuilder.Generated(anExp.Current());
- std::string aVertexName = anIndex == 1 ? "StartVertex" : "EndVertex";
+ TDF_Label aSubLab = aShapeLab.FindChild(anIndex);
+ TNaming_Builder aSubBuilder(aSubLab);
+ aSubBuilder.Generated(anExp.Current());
+ std::wstring aVertexName = aMyName + L"_" +
+ (anIndex == 1 ? L"StartVertex" : L"EndVertex");
TDataStd_Name::Set(aSubLab, aVertexName.c_str());
aMyDoc->addNamingName(aSubLab, aVertexName);
}
// collect indices of curves of current composite
NCollection_DataMap<Handle(Geom_Curve), int> aCurvesIndices;
NCollection_DataMap<int, TopoDS_Edge> anEdgeIndices;
- std::map<int, std::string> aComponentsNames; // names of components that lay on index
- const int aSubNum = aComposite->numberOfSubs();
- for (int a = 0; a < aSubNum; a++) {
- FeaturePtr aSub = aComposite->subFeature(a);
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aSub->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResults.cbegin();
- for (; aRes != aResults.cend(); aRes++) {
- ResultConstructionPtr aConstr =
- std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aRes);
- if (aConstr->shape() && aConstr->shape()->isEdge()) {
- TopoDS_Edge anEdge = TopoDS::Edge(aConstr->shape()->impl<TopoDS_Shape>());
- Standard_Real aFirst, aLast;
- Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
- aCurvesIndices.Bind(aCurve, a);
- anEdgeIndices.Bind(a, anEdge);
- aComponentsNames[a] = shortName(aConstr);
- }
- }
- }
+ std::map<int, std::wstring> aComponentsNames; // names of components that lay on index
+ indexingSketchEdges(aComposite, aCurvesIndices, anEdgeIndices, aComponentsNames);
+
+ GeomAlgoAPI_SketchBuilder aSketchBuilder(aWirePtr->origin(), aWirePtr->dirX(),
+ aWirePtr->norm(), aWirePtr);
+ const ListOfShape& aFaces = aSketchBuilder.faces();
+ // order is important to store faces in the same order if sketch is created from scratch
+ MapFaceToEdgeIndices aNewIndices; // edges indices
+ faceToEdgeIndices(aFaces, aCurvesIndices, aNewIndices);
- std::list<std::shared_ptr<GeomAPI_Shape> > aFaces;
- GeomAlgoAPI_SketchBuilder::createFaces(aWirePtr->origin(), aWirePtr->dirX(),
- aWirePtr->norm(), aWirePtr, aFaces);
- NCollection_DataMap<TopoDS_Face, TColStd_ListOfInteger> aNewIndices; // edges indices
- std::list<std::shared_ptr<GeomAPI_Shape> >::iterator aFIter = aFaces.begin();
- for (; aFIter != aFaces.end(); aFIter++) {
- std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(*aFIter));
- // put them to a label, trying to keep the same faces on the same labels
- if (aFace.get() && !aFace->isNull()) {
- TopoDS_Face aTopoFace = TopoDS::Face(aFace->impl<TopoDS_Shape>());
- aNewIndices.Bind(aTopoFace, TColStd_ListOfInteger());
- // keep new indices of sub-elements used in this face
- for (TopExp_Explorer anEdges(aTopoFace, TopAbs_EDGE); anEdges.More(); anEdges.Next()) {
- TopoDS_Edge anEdge = TopoDS::Edge(anEdges.Current());
- Standard_Real aFirst, aLast;
- Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
- if (aCurvesIndices.IsBound(aCurve)) {
- int anIndex = aCurvesIndices.Find(aCurve);
- if ((aFirst > aLast) != (anEdge.Orientation() == TopAbs_REVERSED))
- anIndex = -anIndex;
- aNewIndices.ChangeFind(aTopoFace).Append(anIndex);
- }
- }
- }
- }
NCollection_DataMap<int, TopoDS_Face> aFacesOrder; // faces -> tag where they must be set
NCollection_List<TopoDS_Face> anUnorderedFaces; // faces that may be located at any index
// searching for the best new candidate to old location
- NCollection_DataMap<TopoDS_Face, TColStd_ListOfInteger>::Iterator aNewIter(aNewIndices);
+ MapFaceToEdgeIndices::Iterator aNewIter(aNewIndices);
for (; aNewIter.More(); aNewIter.Next()) {
double aBestFound = 0, aBestNotFound = 1.e+100;
int aBestTag = 0;
aNotFound += 1.;
}
}
- if (aNotFound < aBestNotFound) {
+ if (aNotFound <= aBestNotFound) { // less and equal to find better "found": #2859
if (aFound > aBestFound) {
aBestNotFound = aNotFound;
aBestFound = aFound;
anUnorderedFaces.Append(aNewIter.Key());
}
}
- aShapeLab.ForgetAllAttributes(); // clear all previously stored
- TDataStd_Name::Set(aShapeLab, aMyName.c_str()); // restore name forgotten
- TNaming_Builder aBuilder(aShapeLab); // store the compound to get it ready on open of document
- aBuilder.Generated(aShape);
- aMyDoc->addNamingName(aShapeLab, aMyName);
- // set new faces to the labels
- int aCurrentTag = 1;
- NCollection_List<TopoDS_Face>::Iterator anUnordered(anUnorderedFaces);
- for(int aCurrentTag = 1; !aFacesOrder.IsEmpty() || anUnordered.More(); aCurrentTag++) {
- TopoDS_Face aFaceToPut;
- if (aFacesOrder.IsBound(aCurrentTag)) {
- aFaceToPut = aFacesOrder.Find(aCurrentTag);
- aFacesOrder.UnBind(aCurrentTag);
- } else if (anUnordered.More()){
- aFaceToPut = anUnordered.Value();
- anUnordered.Next();
- }
+ storeFacesOnLabel(aMyDoc, aShapeLab, aMyName, aShape, aFacesOrder, anUnorderedFaces,
+ aNewIndices, anEdgeIndices, aComponentsNames);
+ }
+ }
+}
- if (!aFaceToPut.IsNull()) {
- TopTools_MapOfShape aFaceEdges;
- for(TopExp_Explorer anEdges(aFaceToPut, TopAbs_EDGE); anEdges.More(); anEdges.Next()) {
- aFaceEdges.Add(anEdges.Current());
- }
+void Model_ResultConstruction::setFacesOrder(const std::list<GeomFacePtr>& theFaces)
+{
+ std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
+ if (aData && aData->isValid()) {
+ std::wstring aMyName = data()->name();
+ TDF_Label aShapeLab = aData->shapeLab();
+ GeomShapePtr aResShape = shape();
+ if (!aResShape.get() || aResShape->isNull()) {
+ // do nothing
+ return;
+ }
+ std::shared_ptr<Model_Document> aMyDoc =
+ std::dynamic_pointer_cast<Model_Document>(document());
+ const TopoDS_Shape& aShape = aResShape->impl<TopoDS_Shape>();
+ if (aShape.ShapeType() != TopAbs_VERTEX &&
+ aShape.ShapeType() != TopAbs_EDGE) {
+ ResultPtr aThisPtr = std::dynamic_pointer_cast<ModelAPI_Result>(data()->owner());
+ FeaturePtr aThisFeature = aMyDoc->feature(aThisPtr);
+ CompositeFeaturePtr aComposite =
+ std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aThisFeature);
+ if (!aComposite || aComposite->numberOfSubs() == 0)
+ return; // unknown case
+ // collect indices of curves of current composite
+ NCollection_DataMap<Handle(Geom_Curve), int> aCurvesIndices;
+ NCollection_DataMap<int, TopoDS_Edge> anEdgeIndices;
+ std::map<int, std::wstring> aComponentsNames; // names of components that lay on index
+ indexingSketchEdges(aComposite, aCurvesIndices, anEdgeIndices, aComponentsNames);
+
+ ListOfShape aFaces;
+ NCollection_DataMap<int, TopoDS_Face> aFacesOrder; // faces -> tag where they must be set
+ NCollection_List<TopoDS_Face> anUnorderedFaces; // unordered faces are empty in this case
+ int aTagId = 0;
+ for (std::list<GeomFacePtr>::const_iterator aFIt = theFaces.begin();
+ aFIt != theFaces.end(); ++aFIt) {
+ aFaces.push_back(*aFIt);
+ aFacesOrder.Bind(++aTagId, (*aFIt)->impl<TopoDS_Face>());
+ }
+
+ MapFaceToEdgeIndices aNewIndices; // edges indices
+ faceToEdgeIndices(aFaces, aCurvesIndices, aNewIndices);
+
+ storeFacesOnLabel(aMyDoc, aShapeLab, aMyName, aShape, aFacesOrder, anUnorderedFaces,
+ aNewIndices, anEdgeIndices, aComponentsNames);
+ }
+ }
+}
+
+// ========================== Auxiliary functions =========================================
+
+void storeFacesOnLabel(std::shared_ptr<Model_Document>& theDocument,
+ TDF_Label& theShapeLabel,
+ const std::wstring& theName,
+ const TopoDS_Shape& theShape,
+ NCollection_DataMap<int, TopoDS_Face>& theFacesOrder,
+ NCollection_List<TopoDS_Face>& theUnorderedFaces,
+ const MapFaceToEdgeIndices& theFaceEdges,
+ const NCollection_DataMap<int, TopoDS_Edge>& theEdgesIndices,
+ const std::map<int, std::wstring>& theEdgesNames)
+{
+ theShapeLabel.ForgetAllAttributes(); // clear all previously stored
+ TDataStd_Name::Set(theShapeLabel, theName.c_str()); // restore name forgotten
+ TNaming_Builder aBuilder(theShapeLabel); // store the compound to get it ready on open of document
+ aBuilder.Generated(theShape);
+ theDocument->addNamingName(theShapeLabel, theName);
+ // set new faces to the labels
+ NCollection_List<TopoDS_Face>::Iterator anUnordered(theUnorderedFaces);
+ for (int aCurrentTag = 1; !theFacesOrder.IsEmpty() || anUnordered.More(); aCurrentTag++) {
+ TopoDS_Face aFaceToPut;
+ if (theFacesOrder.IsBound(aCurrentTag)) {
+ aFaceToPut = theFacesOrder.Find(aCurrentTag);
+ theFacesOrder.UnBind(aCurrentTag);
+ }
+ else if (anUnordered.More()) {
+ aFaceToPut = anUnordered.Value();
+ anUnordered.Next();
+ }
+
+ if (aFaceToPut.IsNull())
+ continue;
- TDF_Label aLab = aShapeLab.FindChild(aCurrentTag);
- TNaming_Builder aFaceBuilder(aLab);
- aFaceBuilder.Generated(aFaceToPut);
- // store also indices of the new face edges
- Handle(TDataStd_IntPackedMap) aNewMap = TDataStd_IntPackedMap::Set(aLab);
- const TColStd_ListOfInteger& aNewInd = aNewIndices.Find(aFaceToPut);
- std::stringstream aName;
- aName<<"Face";
- TopExp_Explorer aPutEdges(aFaceToPut, TopAbs_EDGE);
- TNaming_Builder* anEdgesBuilder = 0;
- for(TColStd_ListOfInteger::Iterator anIter(aNewInd); anIter.More(); anIter.Next()) {
- int anIndex = anIter.Value();
- aNewMap->Add(anIndex);
- aName<<"-"<<aComponentsNames[anIndex > 0 ? anIndex : -anIndex];
- if (anIter.Value() > 0)
- aName<<"f";
- else
- aName<<"r";
- // collect all edges of the face which are modified in sub-label of the face
- if (anEdgeIndices.IsBound(anIndex) &&
- !aFaceEdges.Contains(anEdgeIndices.Find(anIndex))) {
- if (!anEdgesBuilder) {
- TDF_Label anEdgesLabel = aLab.FindChild(1);
- anEdgesBuilder = new TNaming_Builder(anEdgesLabel);
- TDataStd_Name::Set(anEdgesLabel, "SubEdge");
- }
- anEdgesBuilder->Modify(anEdgeIndices.Find(anIndex), aPutEdges.Current());
+ TopTools_MapOfShape aFaceEdges;
+ for (TopExp_Explorer anEdges(aFaceToPut, TopAbs_EDGE); anEdges.More(); anEdges.Next())
+ aFaceEdges.Add(anEdges.Current());
+
+ TDF_Label aLab = theShapeLabel.FindChild(aCurrentTag);
+ TNaming_Builder aFaceBuilder(aLab);
+ aFaceBuilder.Generated(aFaceToPut);
+ // store also indices of the new face edges
+ Handle(TDataStd_IntPackedMap) aNewMap = TDataStd_IntPackedMap::Set(aLab);
+ const TColStd_ListOfInteger& aNewInd = theFaceEdges.FindFromKey(aFaceToPut);
+ std::wstringstream aName;
+ aName<<"Face";
+ TopExp_Explorer aPutEdges(aFaceToPut, TopAbs_EDGE);
+ TNaming_Builder *anEdgesBuilder = 0, *aVerticesBuilder = 0;
+ for(TColStd_ListOfInteger::Iterator anIter(aNewInd); anIter.More(); anIter.Next()) {
+ int anIndex = anIter.Value();
+ int aModIndex = anIndex > 0 ? anIndex : -anIndex;
+ aNewMap->Add(anIndex);
+ aName<<"-"<<theEdgesNames.find(aModIndex)->second;
+ if (anIter.Value() > 0)
+ aName<<"f";
+ else
+ aName<<"r";
+ // collect all edges of the face which are modified in sub-label of the face
+ if (theEdgesIndices.IsBound(aModIndex) &&
+ !aFaceEdges.Contains(theEdgesIndices.Find(aModIndex))) {
+ if (!anEdgesBuilder) {
+ TDF_Label anEdgesLabel = aLab.FindChild(1);
+ anEdgesBuilder = new TNaming_Builder(anEdgesLabel);
+ std::ostringstream aSubName;
+ // tag is needed for Test1922 to distinguish sub-edges of different faces
+ aSubName<<"SubEdge_"<<aCurrentTag;
+ TDataStd_Name::Set(anEdgesLabel, aSubName.str().c_str());
+ }
+ anEdgesBuilder->Modify(theEdgesIndices.Find(aModIndex), aPutEdges.Current());
+ }
+ // put also modified vertices, otherwise vertex of original edge has no history
+ if (theEdgesIndices.IsBound(aModIndex)) {
+ TopExp_Explorer aVExpOld(theEdgesIndices.Find(aModIndex), TopAbs_VERTEX);
+ TopExp_Explorer aVExpNew(aPutEdges.Current(), TopAbs_VERTEX);
+ for(; aVExpNew.More() && aVExpOld.More(); aVExpNew.Next(), aVExpOld.Next()) {
+ if (!aVExpOld.Current().IsSame(aVExpNew.Current())) {
+ if (!aVerticesBuilder) {
+ TDF_Label aVertLabel = aLab.FindChild(2);
+ aVerticesBuilder = new TNaming_Builder(aVertLabel);
+ std::ostringstream aSubName;
+ // tag is needed for Test1922 to distinguish sub-edges of different faces
+ aSubName<<"SubVertex_"<<aCurrentTag;
+ TDataStd_Name::Set(aVertLabel, aSubName.str().c_str());
}
- aPutEdges.Next();
+ aVerticesBuilder->Modify(aVExpOld.Current(), aVExpNew.Current());
+
}
- TDataStd_Name::Set(aLab, TCollection_ExtendedString(aName.str().c_str()));
- aMyDoc->addNamingName(aLab, aName.str());
+ }
+ }
+ aPutEdges.Next();
+ }
+ if (anEdgesBuilder)
+ delete anEdgesBuilder;
+ if (aVerticesBuilder)
+ delete aVerticesBuilder;
+ TDataStd_Name::Set(aLab, TCollection_ExtendedString(aName.str().c_str()));
+ theDocument->addNamingName(aLab, aName.str());
+ // put also wires to sub-labels to correctly select them instead of collection by edges
+ int aWireTag = 3; // first tag is for SubEdge-s, second - for vertices
+ for(TopExp_Explorer aWires(aFaceToPut, TopAbs_WIRE); aWires.More(); aWires.Next()) {
+ TDF_Label aWireLab = aLab.FindChild(aWireTag);
+ TNaming_Builder aWireBuilder(aWireLab);
+ aWireBuilder.Generated(aWires.Current());
+ std::wostringstream aWireName;
+ aWireName<<aName.str()<<L"_wire";
+ if (aWireTag > 3)
+ aWireName<<"_"<<aWireTag - 2;
+ TDataStd_Name::Set(aWireLab, aWireName.str().c_str());
+ theDocument->addNamingName(aWireLab, aWireName.str());
+ aWireTag++;
+ }
+ }
+}
+
+void indexingSketchEdges(const CompositeFeaturePtr& theComposite,
+ NCollection_DataMap<Handle(Geom_Curve), int>& theCurvesIndices,
+ NCollection_DataMap<int, TopoDS_Edge>& theEdgesIndices,
+ std::map<int, std::wstring>& theEdgesNames)
+{
+ const int aSubNum = theComposite->numberOfSubs();
+ for (int a = 0; a < aSubNum; a++) {
+ FeaturePtr aSub = theComposite->subFeature(a);
+ const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aSub->results();
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResults.cbegin();
+ for (; aRes != aResults.cend(); aRes++) {
+ ResultConstructionPtr aConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aRes);
+ if (aConstr->shape() && aConstr->shape()->isEdge()) {
+ TopoDS_Edge anEdge = TopoDS::Edge(aConstr->shape()->impl<TopoDS_Shape>());
+ Standard_Real aFirst, aLast;
+ Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
+ theCurvesIndices.Bind(aCurve, a);
+ theEdgesIndices.Bind(a, anEdge);
+ theEdgesNames[a] = shortName(aConstr);
+ }
+ }
+ }
+}
+
+void faceToEdgeIndices(const ListOfShape& theFaces,
+ const NCollection_DataMap<Handle(Geom_Curve), int>& theCurvesIndices,
+ MapFaceToEdgeIndices& theFaceEdges)
+{
+ std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator aFIter = theFaces.begin();
+ for (; aFIter != theFaces.end(); aFIter++) {
+ std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(*aFIter));
+ // put them to a label, trying to keep the same faces on the same labels
+ if (aFace.get() && !aFace->isNull()) {
+ TopoDS_Face aTopoFace = TopoDS::Face(aFace->impl<TopoDS_Shape>());
+ theFaceEdges.Add(aTopoFace, TColStd_ListOfInteger());
+ // keep new indices of sub-elements used in this face
+ for (TopExp_Explorer anEdges(aTopoFace, TopAbs_EDGE); anEdges.More(); anEdges.Next()) {
+ TopoDS_Edge anEdge = TopoDS::Edge(anEdges.Current());
+ Standard_Real aFirst, aLast;
+ Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
+ if (theCurvesIndices.IsBound(aCurve)) {
+ int anIndex = theCurvesIndices.Find(aCurve);
+ if ((aFirst > aLast) != (anEdge.Orientation() == TopAbs_REVERSED))
+ anIndex = -anIndex;
+ theFaceEdges.ChangeFromKey(aTopoFace).Append(anIndex);
}
}
}
