kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Merge pull request #12201 from bgbsww/bgbsww-toponamingGetElementName

Browse Source 
Toponaming: transfer in getElementName and dependencies
This commit is contained in:
Chris Hennes
2024-02-28 21:05:54 -06:00
committed by GitHub
parent 2630e259a0 a4efcf0533
commit a03ad7f49b
9 changed files with 457 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/App/GeoFeature.cpp
View File

@@ -25,6 +25,7 @@
#include <App/GeoFeaturePy.h>
#include "ComplexGeoData.h"
#include "GeoFeature.h"
#include "GeoFeatureGroupExtension.h"
#include "ElementNamingUtils.h"
@@ -78,17 +79,52 @@ PyObject* GeoFeature::getPyObject()
return Py::new_reference_to(PythonObject);
}
std::pair<std::string,std::string> GeoFeature::getElementName(
const char *name, ElementNameType type) const
std::pair<std::string,std::string>
GeoFeature::getElementName(const char *name, ElementNameType type) const
{
(void)type;
std::pair<std::string,std::string> ret;
if(!name)
return ret;
auto prop = getPropertyOfGeometry();
if (!prop) {
return std::make_pair("", name);
}
auto geo = prop->getComplexData();
if (!geo) {
return std::make_pair("", name);
}
return _getElementName(name, geo->getElementName(name));
}
std::pair<std::string, std::string>
GeoFeature::_getElementName(const char* name, const Data::MappedElement& mapped) const
{
std::pair<std::string, std::string> ret;
if (mapped.index && mapped.name) {
std::ostringstream ss;
ss << Data::ComplexGeoData::elementMapPrefix() << mapped.name << '.' << mapped.index;
ret.first = ss.str();
mapped.index.appendToStringBuffer(ret.second);
}
else if (mapped.name) {
// FC_TRACE("element mapped name " << name << " not found in " << getFullName());
ret.first = name;
const char* dot = strrchr(name, '.');
if (dot) {
// deliberately mangle the old style element name to signal a
// missing reference
ret.second = Data::MISSING_PREFIX;
ret.second += dot + 1;
}
}
else {
mapped.index.appendToStringBuffer(ret.second);
}
ret.second = name;
return ret;
}

6
src/App/GeoFeature.h
View File

@@ -26,7 +26,7 @@
#include "DocumentObject.h"
#include "PropertyGeo.h"
#include "MappedElement.h"
namespace App
{
@@ -120,6 +120,10 @@ public:
* @return Base::Placement The transformation from the global reference coordinate system
*/
Base::Placement globalPlacement() const;
protected:
std::pair<std::string, std::string> _getElementName(const char* name,
const Data::MappedElement& mapped) const;
};
} //namespace App

232
src/Mod/Part/App/PartFeature.cpp
View File

@@ -757,3 +757,235 @@ bool Part::checkIntersection(const TopoDS_Shape& first, const TopoDS_Shape& seco
}
}
/**
* Override getElementName to support the Export type. Other calls are passed to the original
* method
* @param name The name to search for, or if non existent, name of current Feature is returned
* @param type An element type name.
* @return The element name located, of
*/
std::pair<std::string, std::string> Feature::getElementName(const char* name,
ElementNameType type) const
{
if (type != ElementNameType::Export) {
return App::GeoFeature::getElementName(name, type);
}
// This function is overridden to provide higher level shape topo names that
// are generated on demand, e.g. Wire, Shell, Solid, etc.
auto prop = Base::freecad_dynamic_cast<PropertyPartShape>(getPropertyOfGeometry());
if (!prop) {
return App::GeoFeature::getElementName(name, type);
}
TopoShape shape = prop->getShape();
Data::MappedElement mapped = shape.getElementName(name);
auto res = shape.shapeTypeAndIndex(mapped.index);
static const int MinLowerTopoNames = 3;
static const int MaxLowerTopoNames = 10;
if (res.second && !mapped.name) {
// Here means valid index name, but no mapped name, check to see if
// we shall generate the high level topo name.
//
// The general idea of the algorithm is to find the minimum number of
// lower elements that can identify the given higher element, and
// combine their names to generate the name for the higher element.
//
// In theory, all it takes to find one lower element that only appear
// in the given higher element. To make the algorithm more robust
// against model changes, we shall take minimum MinLowerTopoNames lower
// elements.
//
// On the other hand, it may be possible to take too many elements for
// disambiguation. We shall limit to maximum MaxLowerTopoNames. If the
// chosen elements are not enough to disambiguate the higher element,
// we'll include an index for disambiguation.
auto subshape = shape.getSubTopoShape(res.first, res.second, true);
TopAbs_ShapeEnum lower;
Data::IndexedName idxName;
if (!subshape.isNull()) {
switch (res.first) {
case TopAbs_WIRE:
lower = TopAbs_EDGE;
idxName = Data::IndexedName::fromConst("Edge", 1);
break;
case TopAbs_SHELL:
case TopAbs_SOLID:
case TopAbs_COMPOUND:
case TopAbs_COMPSOLID:
lower = TopAbs_FACE;
idxName = Data::IndexedName::fromConst("Face", 1);
break;
default:
lower = TopAbs_SHAPE;
}
if (lower != TopAbs_SHAPE) {
typedef std::pair<size_t, std::vector<int>> NameEntry;
std::vector<NameEntry> indices;
std::vector<Data::MappedName> names;
std::vector<int> ancestors;
int count = 0;
for (auto& ss : subshape.getSubTopoShapes(lower)) {
auto name = ss.getMappedName(idxName);
if (!name) {
continue;
}
indices.emplace_back(name.size(),
shape.findAncestors(ss.getShape(), res.first));
names.push_back(name);
if (indices.back().second.size() == 1 && ++count >= MinLowerTopoNames) {
break;
}
}
if (names.size() >= MaxLowerTopoNames) {
std::stable_sort(indices.begin(),
indices.end(),
[](const NameEntry& a, const NameEntry& b) {
return a.second.size() < b.second.size();
});
std::vector<Data::MappedName> sorted;
auto pos = 0;
sorted.reserve(names.size());
for (auto& v : indices) {
size_t size = ancestors.size();
if (size == 0) {
ancestors = v.second;
}
else if (size > 1) {
for (auto it = ancestors.begin(); it != ancestors.end();) {
if (std::find(v.second.begin(), v.second.end(), *it)
== v.second.end()) {
it = ancestors.erase(it);
if (ancestors.size() == 1) {
break;
}
}
else {
++it;
}
}
}
auto itPos = sorted.end();
if (size == 1 || size != ancestors.size()) {
itPos = sorted.begin() + pos;
++pos;
}
sorted.insert(itPos, names[v.first]);
if (size == 1 && sorted.size() >= MinLowerTopoNames) {
break;
}
}
}
names.resize(std::min((int)names.size(), MaxLowerTopoNames));
if (names.size()) {
std::string op;
if (ancestors.size() > 1) {
// The current chosen elements are not enough to
// identify the higher element, generate an index for
// disambiguation.
auto it = std::find(ancestors.begin(), ancestors.end(), res.second);
if (it == ancestors.end()) {
assert(0 && "ancestor not found"); // this shouldn't happened
}
else {
op = Data::POSTFIX_TAG + std::to_string(it - ancestors.begin());
}
}
// Note: setting names to shape will change its underlying
// shared element name table. This actually violates the
// const'ness of this function.
//
// To be const correct, we should have made the element
// name table to be implicit sharing (i.e. copy on change).
//
// Not sure if there is any side effect of indirectly
// change the element map inside the Shape property without
// recording the change in undo stack.
//
mapped.name = shape.setElementComboName(mapped.index,
names,
mapped.index.getType(),
op.c_str());
}
}
}
return App::GeoFeature::_getElementName(name, mapped);
}
if (!res.second && mapped.name) {
const char* dot = strchr(name, '.');
if (dot) {
++dot;
// Here means valid mapped name, but cannot find the corresponding
// indexed name. This usually means the model has been changed. The
// original indexed name is usually appended to the mapped name
// separated by a dot. We use it as a clue to decode the combo name
// set above, and try to single out one sub shape that has all the
// lower elements encoded in the combo name. But since we don't
// always use all the lower elements for encoding, this can only be
// consider a heuristics.
if (Data::hasMissingElement(dot)) {
dot += strlen(Data::MISSING_PREFIX);
}
std::pair<TopAbs_ShapeEnum, int> occindex = shape.shapeTypeAndIndex(dot);
if (occindex.second > 0) {
auto idxName = Data::IndexedName::fromConst(shape.shapeName(occindex.first).c_str(),
occindex.second);
std::string postfix;
auto names =
shape.decodeElementComboName(idxName, mapped.name, idxName.getType(), &postfix);
std::vector<int> ancestors;
for (auto& name : names) {
auto index = shape.getIndexedName(name);
if (!index) {
ancestors.clear();
break;
}
auto oidx = shape.shapeTypeAndIndex(index);
auto subshape = shape.getSubShape(oidx.first, oidx.second);
if (subshape.IsNull()) {
ancestors.clear();
break;
}
auto current = shape.findAncestors(subshape, occindex.first);
if (ancestors.empty()) {
ancestors = std::move(current);
}
else {
for (auto it = ancestors.begin(); it != ancestors.end();) {
if (std::find(current.begin(), current.end(), *it) == current.end()) {
it = ancestors.erase(it);
}
else {
++it;
}
}
if (ancestors.empty()) { // model changed beyond recognition, bail!
break;
}
}
}
if (ancestors.size() > 1 && boost::starts_with(postfix, Data::POSTFIX_INDEX)) {
std::istringstream iss(postfix.c_str() + strlen(Data::POSTFIX_INDEX));
int idx;
if (iss >> idx && idx >= 0 && idx < (int)ancestors.size()) {
ancestors.resize(1, ancestors[idx]);
}
}
if (ancestors.size() == 1) {
idxName.setIndex(ancestors.front());
mapped.index = idxName;
return App::GeoFeature::_getElementName(name, mapped);
}
}
}
}
return App::GeoFeature::getElementName(name, type);
}

3
src/Mod/Part/App/PartFeature.h
View File

@@ -64,6 +64,9 @@ public:
PyObject* getPyObject() override;
std::pair<std::string,std::string> getElementName(
const char *name, ElementNameType type=Normal) const override;
TopLoc_Location getLocation() const;
DocumentObject *getSubObject(const char *subname, PyObject **pyObj,

16
src/Mod/Part/App/TopoShape.cpp
View File

@@ -477,6 +477,22 @@ std::pair<TopAbs_ShapeEnum,int> TopoShape::shapeTypeAndIndex(const char *name) {
return std::make_pair(type,idx);
}
std::pair<TopAbs_ShapeEnum, int> TopoShape::shapeTypeAndIndex(const Data::IndexedName& element)
{
if (!element) {
return std::make_pair(TopAbs_SHAPE, 0);
}
static const std::string _subshape("SubShape");
if (boost::equals(element.getType(), _subshape)) {
return std::make_pair(TopAbs_SHAPE, element.getIndex());
}
TopAbs_ShapeEnum shapetype = shapeType(element.getType(), true);
if (shapetype == TopAbs_SHAPE) {
return std::make_pair(TopAbs_SHAPE, 0);
}
return std::make_pair(shapetype, element.getIndex());
}
TopAbs_ShapeEnum TopoShape::shapeType(const char *type, bool silent) {
if(type) {
initShapeNameMap();

8
src/Mod/Part/App/TopoShape.h
View File

@@ -1176,13 +1176,19 @@ public:
static const std::string& shapeName(TopAbs_ShapeEnum type, bool silent = false);
const std::string& shapeName(bool silent = false) const;
static std::pair<TopAbs_ShapeEnum, int> shapeTypeAndIndex(const char* name);
static std::pair<TopAbs_ShapeEnum, int> shapeTypeAndIndex(const Data::IndexedName &name);
Data::MappedName setElementComboName(const Data::IndexedName & element,
Data::MappedName setElementComboName(const Data::IndexedName & element,
const std::vector<Data::MappedName> &names,
const char *marker=nullptr,
const char *op=nullptr,
const Data::ElementIDRefs *sids=nullptr);
std::vector<Data::MappedName> decodeElementComboName(const Data::IndexedName& element,
const Data::MappedName& name,
const char* marker = nullptr,
std::string* postfix = nullptr) const;
/** @name sub shape cached functions
*
* Mapped element names introduces some overhead when getting sub shapes

91
src/Mod/Part/App/TopoShapeExpansion.cpp
View File

@@ -4096,6 +4096,97 @@ Data::MappedName TopoShape::setElementComboName(const Data::IndexedName& element
return elementMap()->setElementName(element, newName, Tag, &sids);
}
std::vector<Data::MappedName> TopoShape::decodeElementComboName(const Data::IndexedName& element,
const Data::MappedName& name,
const char* marker,
std::string* postfix) const
{
std::vector<Data::MappedName> names;
if (!element) {
return names;
}
if (!marker) {
marker = "";
}
int plen = (int)elementMapPrefix().size();
int markerLen = strlen(marker);
int len;
int pos = name.findTagInElementName(nullptr, &len);
if (pos < 0) {
// It is possible to encode combo name without using a tag, e.g.
// Sketcher object creates wire using edges that are created by itself,
// so there will be no tag to encode.
//
// In this case, just search for the brackets
len = name.find("(");
if (len < 0) {
// No bracket is also possible, if there is only one name in the combo
pos = len = name.size();
}
else {
pos = name.find(")");
if (pos < 0) {
// non closing bracket?
return {};
}
++pos;
}
if (len <= (int)markerLen) {
return {};
}
len -= markerLen + plen;
}
if (name.find(elementMapPrefix(), len) != len || name.find(marker, len + plen) != len + plen) {
return {};
}
names.emplace_back(name, 0, len);
std::string text;
len += plen + markerLen;
name.appendToBuffer(text, len, pos - len);
if (this->Hasher) {
if (auto id = App::StringID::fromString(names.back().toRawBytes())) {
if (App::StringIDRef sid = this->Hasher->getID(id)) {
names.pop_back();
names.emplace_back(sid);
}
else {
return names;
}
}
if (auto id = App::StringID::fromString(text.c_str())) {
if (App::StringIDRef sid = this->Hasher->getID(id)) {
text = sid.dataToText();
}
else {
return names;
}
}
}
if (text.empty() || text[0] != '(') {
return names;
}
auto endPos = text.rfind(')');
if (endPos == std::string::npos) {
return names;
}
if (postfix) {
*postfix = text.substr(endPos + 1);
}
text.resize(endPos);
std::istringstream iss(text.c_str() + 1);
std::string token;
while (std::getline(iss, token, '|')) {
names.emplace_back(token);
}
return names;
}
/**
* Reorient the outer and inner wires of the TopoShape
*

1
tests/src/Mod/Part/App/CMakeLists.txt
View File

@@ -11,6 +11,7 @@ target_sources(
${CMAKE_CURRENT_SOURCE_DIR}/FeaturePartCut.cpp
${CMAKE_CURRENT_SOURCE_DIR}/FeaturePartFuse.cpp
${CMAKE_CURRENT_SOURCE_DIR}/FeatureRevolution.cpp
${CMAKE_CURRENT_SOURCE_DIR}/PartFeature.cpp
${CMAKE_CURRENT_SOURCE_DIR}/PartFeatures.cpp
${CMAKE_CURRENT_SOURCE_DIR}/PartTestHelpers.cpp
${CMAKE_CURRENT_SOURCE_DIR}/TopoShape.cpp

62
tests/src/Mod/Part/App/PartFeature.cpp Normal file
View File

@@ -0,0 +1,62 @@
// SPDX-License-Identifier: LGPL-2.1-or-later
#include "gtest/gtest.h"
#include "Mod/Part/App/FeaturePartCommon.h"
#include <src/App/InitApplication.h>
#include <BRepBuilderAPI_MakeVertex.hxx>
#include "PartTestHelpers.h"
using namespace Part;
using namespace PartTestHelpers;
class FeaturePartTest: public ::testing::Test, public PartTestHelperClass
{
protected:
static void SetUpTestSuite()
{
tests::initApplication();
}
void SetUp() override
{
createTestDoc();
_common = dynamic_cast<Common*>(_doc->addObject("Part::Common"));
}
void TearDown() override
{}
Common* _common = nullptr; // NOLINT Can't be private in a test framework
};
TEST_F(FeaturePartTest, testGetElementName)
{
// Arrange
_boxes[0]->Shape.getShape().Tag = 1L;
_boxes[1]->Shape.getShape().Tag = 2L;
_common->Base.setValue(_boxes[0]);
_common->Tool.setValue(_boxes[1]);
// Act
_common->execute();
const TopoShape& ts = _common->Shape.getShape();
auto namePair = _common->getElementName("test");
auto namePairExport = _common->getElementName("test", App::GeoFeature::Export);
auto namePairSelf = _common->getElementName(nullptr);
// Assert
EXPECT_STREQ(namePair.first.c_str(), "");
EXPECT_STREQ(namePair.second.c_str(), "test");
EXPECT_STREQ(namePairExport.first.c_str(), "");
EXPECT_STREQ(namePairExport.second.c_str(), "test");
EXPECT_STREQ(namePairSelf.first.c_str(), "");
EXPECT_STREQ(namePairSelf.second.c_str(), "");
#ifndef FC_USE_TNP_FIX
EXPECT_EQ(ts.getElementMap().size(), 0);
#else
EXPECT_EQ(ts.getElementMap().size(), 26); // Value and code TBD
#endif
// TBD
}