1290 lines
44 KiB
C++
1290 lines
44 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2015 Stefan Tröger <stefantroeger@gmx.net> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
|
|
#include <gp_Lin.hxx>
|
|
#include <gp_Pln.hxx>
|
|
#include <BRep_Builder.hxx>
|
|
#include <BRepBuilderAPI_MakeEdge.hxx>
|
|
#include <BRepBuilderAPI_MakeFace.hxx>
|
|
#include <BRepBuilderAPI_MakeVertex.hxx>
|
|
|
|
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
|
|
#include <App/Application.h>
|
|
#include <App/Document.h>
|
|
#include <App/GroupExtension.h>
|
|
#include <App/Link.h>
|
|
#include <App/Datums.h>
|
|
#include <App/ElementNamingUtils.h>
|
|
#include <Mod/Part/App/TopoShape.h>
|
|
|
|
#include "ShapeBinder.h"
|
|
#include "Mod/Part/App/TopoShapeOpCode.h"
|
|
#include "Base/Tools.h"
|
|
|
|
FC_LOG_LEVEL_INIT("PartDesign", true, true)
|
|
|
|
using namespace PartDesign;
|
|
namespace sp = std::placeholders;
|
|
|
|
namespace PartDesign
|
|
{
|
|
extern bool getPDRefineModelParameter();
|
|
}
|
|
|
|
// ============================================================================
|
|
|
|
PROPERTY_SOURCE(PartDesign::ShapeBinder, Part::Feature)
|
|
|
|
ShapeBinder::ShapeBinder()
|
|
{
|
|
ADD_PROPERTY_TYPE(
|
|
Support,
|
|
(nullptr, nullptr),
|
|
"",
|
|
(App::PropertyType)(App::Prop_None),
|
|
"Support of the geometry"
|
|
);
|
|
Placement.setStatus(App::Property::Hidden, true);
|
|
ADD_PROPERTY_TYPE(TraceSupport, (false), "", App::Prop_None, "Trace support shape");
|
|
}
|
|
|
|
ShapeBinder::~ShapeBinder()
|
|
{
|
|
this->connectDocumentChangedObject.disconnect();
|
|
}
|
|
|
|
void ShapeBinder::onChanged(const App::Property* prop)
|
|
{
|
|
Feature::onChanged(prop);
|
|
}
|
|
|
|
short int ShapeBinder::mustExecute() const
|
|
{
|
|
|
|
if (Support.isTouched()) {
|
|
return 1;
|
|
}
|
|
if (TraceSupport.isTouched()) {
|
|
return 1;
|
|
}
|
|
|
|
return Part::Feature::mustExecute();
|
|
}
|
|
|
|
Part::TopoShape ShapeBinder::updatedShape() const
|
|
{
|
|
Part::TopoShape shape;
|
|
App::GeoFeature* obj = nullptr;
|
|
std::vector<std::string> subs;
|
|
|
|
ShapeBinder::getFilteredReferences(&Support, obj, subs);
|
|
|
|
// if we have a link we rebuild the shape, but we change nothing if we are a simple copy
|
|
if (obj) {
|
|
shape = ShapeBinder::buildShapeFromReferences(obj, subs);
|
|
// now, shape is in object's CS, and includes local Placement of obj but nothing else.
|
|
|
|
if (TraceSupport.getValue()) {
|
|
// compute the transform, and apply it to the shape.
|
|
Base::Placement sourceCS = // full placement of container of obj
|
|
obj->globalPlacement() * obj->Placement.getValue().inverse();
|
|
Base::Placement targetCS = // full placement of container of this shapebinder
|
|
this->globalPlacement() * this->Placement.getValue().inverse();
|
|
Base::Placement transform = targetCS.inverse() * sourceCS;
|
|
shape.setPlacement(transform * shape.getPlacement());
|
|
}
|
|
}
|
|
|
|
return shape;
|
|
}
|
|
|
|
bool ShapeBinder::hasPlacementChanged() const
|
|
{
|
|
Part::TopoShape shape(updatedShape());
|
|
Base::Placement placement(shape.getTransform());
|
|
return this->Placement.getValue() != placement;
|
|
}
|
|
|
|
App::DocumentObjectExecReturn* ShapeBinder::execute()
|
|
{
|
|
if (!this->isRestoring()) {
|
|
Part::TopoShape shape(updatedShape());
|
|
if (!shape.isNull()) {
|
|
this->Placement.setValue(shape.getTransform());
|
|
this->Shape.setValue(shape);
|
|
}
|
|
}
|
|
|
|
return Part::Feature::execute();
|
|
}
|
|
|
|
void ShapeBinder::getFilteredReferences(
|
|
const App::PropertyLinkSubList* prop,
|
|
App::GeoFeature*& obj,
|
|
std::vector<std::string>& subobjects
|
|
)
|
|
{
|
|
obj = nullptr;
|
|
subobjects.clear();
|
|
|
|
auto objs = prop->getValues();
|
|
auto subs = prop->getSubValues();
|
|
|
|
if (objs.empty()) {
|
|
return;
|
|
}
|
|
|
|
// we only allow one part feature, so get the first one we find
|
|
size_t index = 0;
|
|
for (auto* it : objs) {
|
|
if (auto part = dynamic_cast<Part::Feature*>(it)) {
|
|
obj = part;
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
// do we have any part feature?
|
|
if (obj) {
|
|
// if we have no subshpape we use the whole shape
|
|
if (subs[index].empty()) {
|
|
return;
|
|
}
|
|
|
|
// collect all subshapes for the object
|
|
for (index = 0; index < objs.size(); index++) {
|
|
// we only allow subshapes from a single Part::Feature
|
|
if (objs[index] != obj) {
|
|
continue;
|
|
}
|
|
|
|
// in this mode the full shape is not allowed, as we already started the subshape
|
|
// processing
|
|
if (subs[index].empty()) {
|
|
continue;
|
|
}
|
|
|
|
subobjects.push_back(subs[index]);
|
|
}
|
|
}
|
|
else {
|
|
// search for Origin features
|
|
for (auto* it : objs) {
|
|
if (auto line = dynamic_cast<App::Line*>(it)) {
|
|
obj = line;
|
|
break;
|
|
}
|
|
if (auto plane = dynamic_cast<App::Plane*>(it)) {
|
|
obj = plane;
|
|
break;
|
|
}
|
|
if (auto point = dynamic_cast<App::Point*>(it)) {
|
|
obj = point;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Part::TopoShape ShapeBinder::buildShapeFromReferences(App::GeoFeature* obj, std::vector<std::string> subs)
|
|
{
|
|
|
|
if (!obj) {
|
|
return TopoDS_Shape();
|
|
}
|
|
|
|
if (obj->isDerivedFrom<Part::Feature>()) {
|
|
auto part = static_cast<Part::Feature*>(obj);
|
|
if (subs.empty()) {
|
|
return part->Shape.getValue();
|
|
}
|
|
|
|
std::vector<TopoDS_Shape> shapes;
|
|
shapes.reserve(subs.size());
|
|
for (const std::string& sub : subs) {
|
|
shapes.push_back(part->Shape.getShape().getSubShape(sub.c_str()));
|
|
}
|
|
|
|
if (shapes.size() == 1) {
|
|
// single subshape. Return directly.
|
|
return shapes[0];
|
|
}
|
|
|
|
// multiple subshapes. Make a compound.
|
|
BRep_Builder builder;
|
|
TopoDS_Compound cmp;
|
|
builder.MakeCompound(cmp);
|
|
for (const TopoDS_Shape& sh : shapes) {
|
|
builder.Add(cmp, sh);
|
|
}
|
|
return cmp;
|
|
}
|
|
else if (obj->isDerivedFrom<App::Line>()) {
|
|
gp_Lin line;
|
|
BRepBuilderAPI_MakeEdge mkEdge(line);
|
|
Part::TopoShape shape(mkEdge.Shape());
|
|
shape.setPlacement(obj->Placement.getValue());
|
|
return shape;
|
|
}
|
|
else if (obj->isDerivedFrom<App::Plane>()) {
|
|
gp_Pln plane;
|
|
BRepBuilderAPI_MakeFace mkFace(plane);
|
|
Part::TopoShape shape(mkFace.Shape());
|
|
shape.setPlacement(obj->Placement.getValue());
|
|
return shape;
|
|
}
|
|
else if (obj->isDerivedFrom<App::Point>()) {
|
|
gp_Pnt point;
|
|
BRepBuilderAPI_MakeVertex mkPoint(point);
|
|
Part::TopoShape shape(mkPoint.Shape());
|
|
shape.setPlacement(obj->Placement.getValue());
|
|
return shape;
|
|
}
|
|
|
|
return TopoDS_Shape();
|
|
}
|
|
|
|
void ShapeBinder::handleChangedPropertyType(
|
|
Base::XMLReader& reader,
|
|
const char* TypeName,
|
|
App::Property* prop
|
|
)
|
|
{
|
|
// The type of Support was App::PropertyLinkSubList in the past
|
|
if (prop == &Support && strcmp(TypeName, "App::PropertyLinkSubList") == 0) {
|
|
Support.Restore(reader);
|
|
}
|
|
else {
|
|
Part::Feature::handleChangedPropertyType(reader, TypeName, prop);
|
|
}
|
|
}
|
|
|
|
void ShapeBinder::onSettingDocument()
|
|
{
|
|
App::Document* document = getDocument();
|
|
if (document) {
|
|
// NOLINTBEGIN
|
|
this->connectDocumentChangedObject = document->signalChangedObject.connect(
|
|
std::bind(&ShapeBinder::slotChangedObject, this, sp::_1, sp::_2)
|
|
);
|
|
// NOLINTEND
|
|
}
|
|
}
|
|
|
|
void ShapeBinder::slotChangedObject(const App::DocumentObject& Obj, const App::Property& Prop)
|
|
{
|
|
App::Document* doc = getDocument();
|
|
if (!doc || doc->testStatus(App::Document::Restoring)) {
|
|
return;
|
|
}
|
|
if (this == &Obj) {
|
|
return;
|
|
}
|
|
if (!TraceSupport.getValue()) {
|
|
return;
|
|
}
|
|
if (!Prop.isDerivedFrom<App::PropertyPlacement>()) {
|
|
return;
|
|
}
|
|
|
|
App::GeoFeature* obj = nullptr;
|
|
std::vector<std::string> subs;
|
|
ShapeBinder::getFilteredReferences(&Support, obj, subs);
|
|
if (obj) {
|
|
if (obj == &Obj) {
|
|
// the directly referenced object has changed
|
|
if (hasPlacementChanged()) {
|
|
enforceRecompute();
|
|
}
|
|
}
|
|
else if (Obj.hasExtension(App::GroupExtension::getExtensionClassTypeId())) {
|
|
// check if the changed property belongs to a group-like object
|
|
// like Body or Part
|
|
std::vector<App::DocumentObject*> chain;
|
|
std::vector<App::DocumentObject*> list = getInListRecursive();
|
|
chain.insert(chain.end(), list.begin(), list.end());
|
|
list = obj->getInListRecursive();
|
|
chain.insert(chain.end(), list.begin(), list.end());
|
|
|
|
if (const auto it = std::ranges::find(chain, &Obj); it != chain.end()) {
|
|
if (hasPlacementChanged()) {
|
|
enforceRecompute();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
|
|
PROPERTY_SOURCE(PartDesign::SubShapeBinder, Part::Feature)
|
|
|
|
SubShapeBinder::SubShapeBinder()
|
|
{
|
|
ADD_PROPERTY_TYPE(Support, (nullptr), "", (App::PropertyType)(App::Prop_None), "Support of the geometry");
|
|
Support.setStatus(App::Property::ReadOnly, true);
|
|
ADD_PROPERTY_TYPE(Fuse, (false), "Base", App::Prop_None, "Fuse solids from bound shapes");
|
|
ADD_PROPERTY_TYPE(MakeFace, (true), "Base", App::Prop_None, "Create face using wires from bound shapes");
|
|
ADD_PROPERTY_TYPE(
|
|
Offset,
|
|
(0.0),
|
|
"Offsetting",
|
|
App::Prop_None,
|
|
"2D offset face or wires, 0.0 = no offset"
|
|
);
|
|
ADD_PROPERTY_TYPE(OffsetJoinType, ((long)0), "Offsetting", App::Prop_None, "Arcs, Tangent, Intersection");
|
|
static const char* JoinTypeEnum[] = {"Arcs", "Tangent", "Intersection", nullptr};
|
|
OffsetJoinType.setEnums(JoinTypeEnum);
|
|
ADD_PROPERTY_TYPE(
|
|
OffsetFill,
|
|
(false),
|
|
"Offsetting",
|
|
App::Prop_None,
|
|
"True = make face between original wire and offset."
|
|
);
|
|
ADD_PROPERTY_TYPE(
|
|
OffsetOpenResult,
|
|
(false),
|
|
"Offsetting",
|
|
App::Prop_None,
|
|
"False = make closed offset from open wire."
|
|
);
|
|
ADD_PROPERTY_TYPE(
|
|
OffsetIntersection,
|
|
(false),
|
|
"Offsetting",
|
|
App::Prop_None,
|
|
"False = offset child wires independently."
|
|
);
|
|
ADD_PROPERTY_TYPE(ClaimChildren, (false), "Base", App::Prop_Output, "Claim linked object as children");
|
|
ADD_PROPERTY_TYPE(Relative, (true), "Base", App::Prop_None, "Enable relative sub-object binding");
|
|
ADD_PROPERTY_TYPE(
|
|
BindMode,
|
|
((long)0),
|
|
"Base",
|
|
App::Prop_None,
|
|
"Synchronized: auto update binder shape on changed of bound object.\n"
|
|
"Frozen: disable auto update, but can be updated manually using context menu.\n"
|
|
"Detached: copy the shape of bound object and then remove the binding immediately."
|
|
);
|
|
ADD_PROPERTY_TYPE(
|
|
PartialLoad,
|
|
(false),
|
|
"Base",
|
|
App::Prop_None,
|
|
"Enable partial loading, which disables auto loading of external document for"
|
|
"external bound object."
|
|
);
|
|
PartialLoad.setStatus(App::Property::PartialTrigger, true);
|
|
static const char* BindModeEnum[] = {"Synchronized", "Frozen", "Detached", nullptr};
|
|
BindMode.setEnums(BindModeEnum);
|
|
|
|
ADD_PROPERTY_TYPE(
|
|
Context,
|
|
(nullptr),
|
|
"Base",
|
|
App::Prop_Hidden,
|
|
"Stores the context of this binder. It is used for monitoring and auto updating\n"
|
|
"the relative placement of the bound shape"
|
|
);
|
|
|
|
static const char* BindCopyOnChangeEnum[] = {"Disabled", "Enabled", "Mutated", nullptr};
|
|
BindCopyOnChange.setEnums(BindCopyOnChangeEnum);
|
|
ADD_PROPERTY_TYPE(
|
|
BindCopyOnChange,
|
|
((long)0),
|
|
"Base",
|
|
App::Prop_None,
|
|
"Disabled: disable copy on change.\n"
|
|
"Enabled: duplicate properties from binding object that are marked with 'CopyOnChange'.\n"
|
|
" Make internal copy of the object with any changed properties to obtain the\n"
|
|
" shape of an alternative configuration\n"
|
|
"Mutated: indicate the binder has already mutated by changing any properties marked with\n"
|
|
" 'CopyOnChange'. Those properties will not longer be kept in sync between the\n"
|
|
" binder and the binding object"
|
|
);
|
|
|
|
ADD_PROPERTY_TYPE(
|
|
Refine,
|
|
(true),
|
|
"Base",
|
|
(App::PropertyType)(App::Prop_None),
|
|
"Refine shape (clean up redundant edges) after adding/subtracting"
|
|
);
|
|
|
|
Context.setScope(App::LinkScope::Hidden);
|
|
|
|
ADD_PROPERTY_TYPE(
|
|
_Version,
|
|
(0),
|
|
"Base",
|
|
(App::PropertyType)(App::Prop_Hidden | App::Prop_ReadOnly),
|
|
""
|
|
);
|
|
|
|
_CopiedLink.setScope(App::LinkScope::Hidden);
|
|
ADD_PROPERTY_TYPE(
|
|
_CopiedLink,
|
|
(nullptr),
|
|
"Base",
|
|
(App::PropertyType)(App::Prop_Hidden | App::Prop_ReadOnly | App::Prop_NoPersist),
|
|
""
|
|
);
|
|
}
|
|
|
|
SubShapeBinder::~SubShapeBinder()
|
|
{
|
|
try {
|
|
clearCopiedObjects();
|
|
}
|
|
catch (const Base::ValueError& e) {
|
|
e.reportException();
|
|
}
|
|
}
|
|
|
|
void SubShapeBinder::setupObject()
|
|
{
|
|
_Version.setValue(2);
|
|
checkPropertyStatus();
|
|
}
|
|
|
|
App::DocumentObject* SubShapeBinder::getSubObject(
|
|
const char* subname,
|
|
PyObject** pyObj,
|
|
Base::Matrix4D* mat,
|
|
bool transform,
|
|
int depth
|
|
) const
|
|
{
|
|
auto sobj = Part::Feature::getSubObject(subname, pyObj, mat, transform, depth);
|
|
if (sobj) {
|
|
return sobj;
|
|
}
|
|
if (Data::findElementName(subname) == subname) {
|
|
return nullptr;
|
|
}
|
|
|
|
const char* dot = strchr(subname, '.');
|
|
if (!dot) {
|
|
return nullptr;
|
|
}
|
|
|
|
App::GetApplication().checkLinkDepth(depth);
|
|
std::string name(subname, dot - subname);
|
|
for (auto& l : Support.getSubListValues()) {
|
|
auto obj = l.getValue();
|
|
if (!obj || !obj->isAttachedToDocument()) {
|
|
continue;
|
|
}
|
|
for (auto& sub : l.getSubValues()) {
|
|
auto sobj = obj->getSubObject(sub.c_str());
|
|
if (!sobj || !sobj->isAttachedToDocument()) {
|
|
continue;
|
|
}
|
|
if (subname[0] == '$') {
|
|
if (sobj->Label.getStrValue() != name.c_str() + 1) {
|
|
continue;
|
|
}
|
|
}
|
|
else if (!boost::equals(sobj->getNameInDocument(), name)) {
|
|
continue;
|
|
}
|
|
name = Data::noElementName(sub.c_str());
|
|
name += dot + 1;
|
|
if (mat && transform) {
|
|
*mat *= Placement.getValue().toMatrix();
|
|
}
|
|
return obj->getSubObject(name.c_str(), pyObj, mat, true, depth + 1);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void SubShapeBinder::setupCopyOnChange()
|
|
{
|
|
copyOnChangeConns.clear();
|
|
|
|
const auto& support = Support.getSubListValues();
|
|
if (BindCopyOnChange.getValue() == 0 || support.size() != 1) {
|
|
if (hasCopyOnChange) {
|
|
hasCopyOnChange = false;
|
|
std::vector<App::Property*> props;
|
|
getPropertyList(props);
|
|
for (auto prop : props) {
|
|
if (App::LinkBaseExtension::isCopyOnChangeProperty(this, *prop)) {
|
|
try {
|
|
removeDynamicProperty(prop->getName());
|
|
}
|
|
catch (Base::Exception& e) {
|
|
e.reportException();
|
|
}
|
|
catch (...) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
auto linked = support.front().getValue();
|
|
hasCopyOnChange = App::LinkBaseExtension::setupCopyOnChange(
|
|
this,
|
|
linked,
|
|
BindCopyOnChange.getValue() == 1 ? ©OnChangeConns : nullptr,
|
|
hasCopyOnChange
|
|
);
|
|
if (hasCopyOnChange) {
|
|
copyOnChangeConns.emplace_back(linked->signalChanged.connect(
|
|
[this](const App::DocumentObject&, const App::Property& prop) {
|
|
if (!prop.testStatus(App::Property::Output)
|
|
&& !prop.testStatus(App::Property::PropOutput)) {
|
|
if (!this->_CopiedObjs.empty()) {
|
|
FC_LOG(
|
|
"Clear binder " << getFullName() << " cache on change of "
|
|
<< prop.getFullName()
|
|
);
|
|
this->clearCopiedObjects();
|
|
}
|
|
}
|
|
}
|
|
));
|
|
}
|
|
}
|
|
|
|
void SubShapeBinder::clearCopiedObjects()
|
|
{
|
|
std::vector<App::DocumentObjectT> objs;
|
|
objs.swap(_CopiedObjs);
|
|
for (auto& o : objs) {
|
|
auto obj = o.getObject();
|
|
if (obj) {
|
|
obj->getDocument()->removeObject(obj->getNameInDocument());
|
|
}
|
|
}
|
|
_CopiedLink.setValue(nullptr);
|
|
}
|
|
|
|
void SubShapeBinder::update(SubShapeBinder::UpdateOption options)
|
|
{
|
|
Part::TopoShape result;
|
|
std::vector<Part::TopoShape> shapes;
|
|
std::vector<std::pair<int, int>> shapeOwners;
|
|
std::vector<const Base::Matrix4D*> shapeMats;
|
|
|
|
bool forced = (Shape.getValue().IsNull() || (options & UpdateForced)) ? true : false;
|
|
bool init = (!forced && (options & UpdateForced)) ? true : false;
|
|
|
|
std::string errMsg;
|
|
auto parent = Context.getValue();
|
|
std::string parentSub = Context.getSubName(false);
|
|
if (!Relative.getValue()) {
|
|
parent = nullptr;
|
|
}
|
|
else {
|
|
if (parent && parent->getSubObject(parentSub.c_str()) == this) {
|
|
auto parents = parent->getParents();
|
|
if (!parents.empty()) {
|
|
parent = parents.begin()->first;
|
|
parentSub = parents.begin()->second + parentSub;
|
|
}
|
|
}
|
|
else {
|
|
parent = nullptr;
|
|
}
|
|
if (!parent && parentSub.empty()) {
|
|
auto parents = getParents();
|
|
if (!parents.empty()) {
|
|
parent = parents.begin()->first;
|
|
parentSub = parents.begin()->second;
|
|
}
|
|
}
|
|
if (parent && (parent != Context.getValue() || parentSub != Context.getSubName(false))) {
|
|
Context.setValue(parent, parentSub.c_str());
|
|
}
|
|
}
|
|
|
|
bool first = false;
|
|
std::unordered_map<const App::DocumentObject*, Base::Matrix4D> mats;
|
|
int idx = -1;
|
|
for (auto& l : Support.getSubListValues()) {
|
|
++idx;
|
|
auto obj = l.getValue();
|
|
if (!obj || !obj->isAttachedToDocument()) {
|
|
continue;
|
|
}
|
|
auto res = mats.emplace(obj, Base::Matrix4D());
|
|
if (parent && res.second) {
|
|
std::string resolvedSub = parentSub;
|
|
std::string linkSub;
|
|
auto link = obj;
|
|
auto resolved = parent->resolveRelativeLink(resolvedSub, link, linkSub);
|
|
if (!resolved) {
|
|
if (!link) {
|
|
FC_WARN(
|
|
getFullName() << " cannot resolve relative link of " << parent->getFullName()
|
|
<< '.' << parentSub << " -> " << obj->getFullName()
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
Base::Matrix4D mat;
|
|
auto sobj = resolved->getSubObject(resolvedSub.c_str(), nullptr, &mat);
|
|
if (sobj != this) {
|
|
FC_LOG(
|
|
getFullName()
|
|
<< " skip invalid parent " << resolved->getFullName() << '.' << resolvedSub
|
|
);
|
|
}
|
|
else if (_Version.getValue() == 0) {
|
|
// For existing legacy SubShapeBinder, we use its Placement
|
|
// to store the position adjustment of the first Support
|
|
if (first) {
|
|
auto pla = Placement.getValue() * Base::Placement(mat).inverse();
|
|
Placement.setValue(pla);
|
|
first = false;
|
|
}
|
|
else {
|
|
// The remaining support will cancel the Placement
|
|
mat.inverseGauss();
|
|
res.first->second = mat;
|
|
}
|
|
}
|
|
else {
|
|
// For newer SubShapeBinder, the Placement property is free
|
|
// to use by the user to add additional offset to the
|
|
// binding object
|
|
mat.inverseGauss();
|
|
res.first->second = Placement.getValue().toMatrix() * mat;
|
|
}
|
|
}
|
|
}
|
|
if (init) {
|
|
continue;
|
|
}
|
|
|
|
App::DocumentObject* copied = nullptr;
|
|
|
|
if (BindCopyOnChange.getValue() == 2 && Support.getSubListValues().size() == 1) {
|
|
if (!_CopiedObjs.empty()) {
|
|
copied = _CopiedObjs.front().getObject();
|
|
}
|
|
|
|
bool recomputeCopy = false;
|
|
int copyerror = 0;
|
|
if (!copied || !copied->isValid()) {
|
|
recomputeCopy = true;
|
|
clearCopiedObjects();
|
|
|
|
App::DocumentInitFlags initFlags {.createView = false, .temporary = true};
|
|
auto tmpDoc = App::GetApplication().newDocument("_tmp_binder", nullptr, initFlags);
|
|
tmpDoc->setUndoMode(0);
|
|
auto objs = tmpDoc->copyObject({obj}, true, true);
|
|
if (!objs.empty()) {
|
|
for (auto it = objs.rbegin(); it != objs.rend(); ++it) {
|
|
_CopiedObjs.emplace_back(*it);
|
|
}
|
|
copied = objs.back();
|
|
// IMPORTANT! must make a recomputation first before any
|
|
// further change so that we can generate the correct
|
|
// geometry element map.
|
|
if (!copied->recomputeFeature(true)) {
|
|
copyerror = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (copied) {
|
|
if (!copyerror) {
|
|
std::vector<App::Property*> props;
|
|
getPropertyList(props);
|
|
// lambda for copying values of copy-on-change properties
|
|
const auto copyPropertyValues =
|
|
[this, &recomputeCopy, &props, copied](const bool to_support) {
|
|
for (auto prop : props) {
|
|
if (!App::LinkBaseExtension::isCopyOnChangeProperty(this, *prop)) {
|
|
continue;
|
|
}
|
|
// we only copy read-only and output properties from support to binder
|
|
if (!to_support
|
|
&& !(
|
|
prop->testStatus(App::Property::Output)
|
|
&& prop->testStatus(App::Property::ReadOnly)
|
|
)) {
|
|
continue;
|
|
}
|
|
auto p = copied->getPropertyByName(prop->getName());
|
|
if (p && p->getContainer() == copied
|
|
&& p->getTypeId() == prop->getTypeId() && !p->isSame(*prop)) {
|
|
recomputeCopy = true;
|
|
auto* const from = to_support ? prop : p;
|
|
auto* const to = to_support ? p : prop;
|
|
|
|
std::unique_ptr<App::Property> pcopy(from->Copy());
|
|
to->Paste(*pcopy);
|
|
}
|
|
}
|
|
};
|
|
|
|
copyPropertyValues(true);
|
|
if (recomputeCopy && !copied->recomputeFeature(true)) {
|
|
copyerror = 2;
|
|
}
|
|
if (!copyerror) {
|
|
copyPropertyValues(false);
|
|
}
|
|
}
|
|
obj = copied;
|
|
_CopiedLink.setValue(copied, l.getSubValues(false));
|
|
if (copyerror) {
|
|
FC_THROWM(
|
|
Base::RuntimeError,
|
|
(
|
|
copyerror == 1 ? "Initial copy failed." : "Copy on change failed."
|
|
) << " Please check report view for more details.\n"
|
|
"You can show temporary document to reveal the failed objects using\n"
|
|
"tree view context menu."
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
const auto& subvals = copied ? _CopiedLink.getSubValues() : l.getSubValues();
|
|
std::set<std::string> subs(subvals.begin(), subvals.end());
|
|
int sidx = copied ? -1 : idx;
|
|
int subidx = -1;
|
|
static std::string none;
|
|
if (subs.empty()) {
|
|
subs.insert(none);
|
|
}
|
|
else if (subs.size() > 1) {
|
|
subs.erase(none);
|
|
}
|
|
for (const auto& sub : subs) {
|
|
++subidx;
|
|
try {
|
|
auto shape = Part::Feature::getTopoShape(
|
|
obj,
|
|
Part::ShapeOption::NeedSubElement | Part::ShapeOption::ResolveLink
|
|
| Part::ShapeOption::Transform,
|
|
sub.c_str()
|
|
);
|
|
if (!shape.isNull()) {
|
|
shapes.push_back(shape);
|
|
shapeOwners.emplace_back(sidx, subidx);
|
|
shapeMats.push_back(&res.first->second);
|
|
}
|
|
}
|
|
catch (Base::Exception& e) {
|
|
e.reportException();
|
|
FC_ERR(
|
|
getFullName() << " failed to obtain shape from " << obj->getFullName() << '.' << sub
|
|
);
|
|
if (errMsg.empty()) {
|
|
std::ostringstream ss;
|
|
ss << "Failed to obtain shape " << obj->getFullName() << '.'
|
|
<< Data::oldElementName(sub.c_str());
|
|
errMsg = ss.str();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string objName;
|
|
// lambda function for generating matrix cache property
|
|
auto cacheName = [this, &objName](const App::DocumentObject* obj) {
|
|
objName = "Cache_";
|
|
objName += obj->getNameInDocument();
|
|
if (obj->getDocument() != getDocument()) {
|
|
objName += "_";
|
|
objName += obj->getDocument()->getName();
|
|
}
|
|
return objName.c_str();
|
|
};
|
|
|
|
if (!init) {
|
|
|
|
if (!errMsg.empty()) {
|
|
if (!(options & UpdateInit)) {
|
|
FC_THROWM(Base::RuntimeError, errMsg);
|
|
}
|
|
if (!Shape.getValue().IsNull()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If not forced, only rebuild when there is any change in
|
|
// transformation matrix
|
|
if (!forced) {
|
|
bool hit = true;
|
|
for (auto& v : mats) {
|
|
auto prop = freecad_cast<App::PropertyMatrix*>(
|
|
getDynamicPropertyByName(cacheName(v.first))
|
|
);
|
|
if (!prop || prop->getValue() != v.second) {
|
|
hit = false;
|
|
break;
|
|
}
|
|
}
|
|
if (hit) {
|
|
return;
|
|
}
|
|
}
|
|
std::ostringstream ss;
|
|
int idx = -1;
|
|
for (auto& shape : shapes) {
|
|
++idx;
|
|
if (shape.Hasher && shape.getElementMapSize()
|
|
&& shape.Hasher != getDocument()->getStringHasher()) {
|
|
ss.str("");
|
|
ss << Data::POSTFIX_EXTERNAL_TAG << Data::ComplexGeoData::elementMapPrefix()
|
|
<< Part::OpCodes::Shapebinder << ':' << shapeOwners[idx].first << ':'
|
|
<< shapeOwners[idx].second;
|
|
shape.reTagElementMap(-getID(), getDocument()->getStringHasher(), ss.str().c_str());
|
|
}
|
|
if (!shape.hasSubShape(TopAbs_FACE) && shape.hasSubShape(TopAbs_EDGE)) {
|
|
shape = shape.makeElementCopy();
|
|
}
|
|
}
|
|
|
|
if (shapes.size() == 1 && !Relative.getValue()) {
|
|
shapes.back().setPlacement(Base::Placement());
|
|
}
|
|
else {
|
|
for (size_t i = 0; i < shapes.size(); ++i) {
|
|
auto& shape = shapes[i];
|
|
shape = shape.makeElementTransform(*shapeMats[i]);
|
|
// if(shape.Hasher
|
|
// && shape.getElementMapSize()
|
|
// && shape.Hasher != getDocument()->getStringHasher())
|
|
// {
|
|
// shape.reTagElementMap(getID(),
|
|
// getDocument()->getStringHasher(),TOPOP_SHAPEBINDER);
|
|
// }
|
|
}
|
|
}
|
|
|
|
if (shapes.empty()) {
|
|
// Shape.resetElementMapVersion();
|
|
return;
|
|
}
|
|
result.makeElementCompound(shapes);
|
|
bool fused = false;
|
|
if (Fuse.getValue()) {
|
|
// If the compound has solid, fuse them together, and ignore other type of
|
|
// shapes
|
|
std::vector<TopoDS_Shape> solids;
|
|
Part::TopoShape solid;
|
|
for (auto& s : result.getSubTopoShapes(TopAbs_SOLID)) {
|
|
if (solid.isNull()) {
|
|
solid = s;
|
|
}
|
|
else {
|
|
solids.push_back(s.getShape());
|
|
}
|
|
}
|
|
if (!solids.empty()) {
|
|
result = solid.fuse(solids);
|
|
fused = true;
|
|
}
|
|
else if (!solid.isNull()) {
|
|
// wrap the single solid in compound to keep its placement
|
|
result.makeElementCompound({solid});
|
|
fused = true;
|
|
}
|
|
}
|
|
|
|
if (!fused && (MakeFace.getValue() || Offset.getValue() != 0.0)
|
|
&& !result.hasSubShape(TopAbs_FACE) && result.hasSubShape(TopAbs_EDGE)) {
|
|
result = result.makeElementWires();
|
|
if (MakeFace.getValue()) {
|
|
try {
|
|
result = result.makeElementFace(nullptr);
|
|
}
|
|
catch (...) {
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!fused && result.hasSubShape(TopAbs_WIRE) && Offset.getValue() != 0.0) {
|
|
try {
|
|
result = result.makeElementOffset2D(
|
|
Offset.getValue(),
|
|
(Part::JoinType)OffsetJoinType.getValue(),
|
|
OffsetFill.getValue() ? Part::FillType::fill : Part::FillType::noFill,
|
|
OffsetOpenResult.getValue() ? Part::OpenResult::allowOpenResult
|
|
: Part::OpenResult::noOpenResult,
|
|
OffsetIntersection.getValue()
|
|
);
|
|
}
|
|
catch (...) {
|
|
std::ostringstream msg;
|
|
msg << Label.getValue() << ": failed to make 2D offset" << std::endl;
|
|
Base::Console().error(msg.str().c_str());
|
|
}
|
|
}
|
|
|
|
if (Refine.getValue()) {
|
|
result = result.makeElementRefine();
|
|
}
|
|
result.setPlacement(Placement.getValue());
|
|
Shape.setValue(result);
|
|
}
|
|
|
|
// collect transformation matrix cache entries
|
|
std::unordered_set<std::string> caches;
|
|
for (const auto& name : getDynamicPropertyNames()) {
|
|
if (boost::starts_with(name, "Cache_")) {
|
|
caches.emplace(name);
|
|
}
|
|
}
|
|
|
|
// update transformation matrix cache
|
|
for (auto& v : mats) {
|
|
const char* name = cacheName(v.first);
|
|
auto prop = getDynamicPropertyByName(name);
|
|
if (!prop || !prop->isDerivedFrom<App::PropertyMatrix>()) {
|
|
if (prop) {
|
|
removeDynamicProperty(name);
|
|
}
|
|
prop = addDynamicProperty("App::PropertyMatrix", name, "Cache", nullptr, 0, false, true);
|
|
}
|
|
caches.erase(name);
|
|
static_cast<App::PropertyMatrix*>(prop)->setValue(v.second);
|
|
}
|
|
|
|
// remove any non-used cache entries.
|
|
for (const auto& name : caches) {
|
|
try {
|
|
removeDynamicProperty(name.c_str());
|
|
}
|
|
catch (...) {
|
|
}
|
|
}
|
|
}
|
|
|
|
void SubShapeBinder::slotRecomputedObject(const App::DocumentObject& Obj)
|
|
{
|
|
if (Context.getValue() == &Obj && !this->testStatus(App::ObjectStatus::Recompute2)) {
|
|
try {
|
|
update();
|
|
}
|
|
catch (Base::Exception& e) {
|
|
e.reportException();
|
|
}
|
|
}
|
|
}
|
|
|
|
App::DocumentObjectExecReturn* SubShapeBinder::execute()
|
|
{
|
|
|
|
setupCopyOnChange();
|
|
|
|
if (BindMode.getValue() == 0) {
|
|
update(UpdateForced);
|
|
}
|
|
|
|
return inherited::execute();
|
|
}
|
|
|
|
void SubShapeBinder::onDocumentRestored()
|
|
{
|
|
if (_Version.getValue() < 2) {
|
|
update(UpdateInit);
|
|
}
|
|
inherited::onDocumentRestored();
|
|
}
|
|
|
|
void SubShapeBinder::collapseGeoChildren()
|
|
{
|
|
// Geo children, i.e. children of GeoFeatureGroup may group some tool
|
|
// features under itself but does not function as a container. In addition,
|
|
// its parent group can directly reference the tool feature grouped without
|
|
// referencing the child. The purpose of this function is to remove any
|
|
// intermediate Non group features in the object path to avoid unnecessary
|
|
// dependencies.
|
|
if (Support.testStatus(App::Property::User3)) {
|
|
return;
|
|
}
|
|
|
|
Base::ObjectStatusLocker<App::Property::Status, App::Property> guard(App::Property::User3, &Support);
|
|
App::PropertyXLinkSubList::atomic_change guard2(Support, false);
|
|
|
|
std::vector<App::DocumentObject*> removes;
|
|
std::map<App::DocumentObject*, std::vector<std::string>> newVals;
|
|
std::ostringstream ss;
|
|
for (auto& l : Support.getSubListValues()) {
|
|
auto obj = l.getValue();
|
|
if (!obj || !obj->getNameInDocument()) {
|
|
continue;
|
|
}
|
|
auto subvals = l.getSubValues();
|
|
if (subvals.empty()) {
|
|
continue;
|
|
}
|
|
bool touched = false;
|
|
for (auto itSub = subvals.begin(); itSub != subvals.end();) {
|
|
auto& sub = *itSub;
|
|
App::SubObjectT sobjT(obj, sub.c_str());
|
|
if (sobjT.normalize(App::SubObjectT::NormalizeOption::KeepSubName)) {
|
|
touched = true;
|
|
auto newobj = sobjT.getObject();
|
|
sub = sobjT.getSubName();
|
|
if (newobj != obj) {
|
|
newVals[newobj].push_back(std::move(sub));
|
|
itSub = subvals.erase(itSub);
|
|
continue;
|
|
}
|
|
}
|
|
++itSub;
|
|
}
|
|
if (touched) {
|
|
removes.push_back(obj);
|
|
}
|
|
if (!subvals.empty() && touched) {
|
|
auto& newSubs = newVals[obj];
|
|
if (newSubs.empty()) {
|
|
newSubs = std::move(subvals);
|
|
}
|
|
else {
|
|
newSubs.insert(
|
|
newSubs.end(),
|
|
std::make_move_iterator(subvals.begin()),
|
|
std::make_move_iterator(subvals.end())
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (removes.size() || newVals.size()) {
|
|
guard2.aboutToChange();
|
|
}
|
|
for (auto obj : removes) {
|
|
Support.removeValue(obj);
|
|
}
|
|
if (newVals.size()) {
|
|
setLinks(std::move(newVals));
|
|
}
|
|
}
|
|
|
|
void SubShapeBinder::onChanged(const App::Property* prop)
|
|
{
|
|
if (prop == &Context || prop == &Relative) {
|
|
if (!Context.getValue() || !Relative.getValue()) {
|
|
connRecomputedObj.disconnect();
|
|
}
|
|
else if (contextDoc != Context.getValue()->getDocument() || !connRecomputedObj.connected()) {
|
|
// NOLINTBEGIN
|
|
contextDoc = Context.getValue()->getDocument();
|
|
connRecomputedObj = contextDoc->signalRecomputedObject.connect(
|
|
std::bind(&SubShapeBinder::slotRecomputedObject, this, sp::_1)
|
|
);
|
|
// NOLINTEND
|
|
}
|
|
}
|
|
else if (!isRestoring()) {
|
|
if (prop == &Support) {
|
|
collapseGeoChildren();
|
|
clearCopiedObjects();
|
|
setupCopyOnChange();
|
|
if (!Support.getSubListValues().empty()) {
|
|
update();
|
|
if (BindMode.getValue() == 2) {
|
|
Support.setValue(nullptr);
|
|
}
|
|
}
|
|
}
|
|
else if (prop == &BindCopyOnChange) {
|
|
setupCopyOnChange();
|
|
}
|
|
else if (prop == &BindMode) {
|
|
if (BindMode.getValue() == 2) {
|
|
Support.setValue(nullptr);
|
|
}
|
|
else if (BindMode.getValue() == 0) {
|
|
update();
|
|
}
|
|
checkPropertyStatus();
|
|
}
|
|
else if (prop == &PartialLoad) {
|
|
checkPropertyStatus();
|
|
}
|
|
else if (prop && !prop->testStatus(App::Property::User3)) {
|
|
checkCopyOnChange(*prop);
|
|
}
|
|
}
|
|
inherited::onChanged(prop);
|
|
}
|
|
|
|
void SubShapeBinder::checkCopyOnChange(const App::Property& prop)
|
|
{
|
|
if (BindCopyOnChange.getValue() != 1 || getDocument()->isPerformingTransaction()
|
|
|| !App::LinkBaseExtension::isCopyOnChangeProperty(this, prop)
|
|
|| Support.getSubListValues().size() != 1) {
|
|
return;
|
|
}
|
|
|
|
auto linked = Support.getSubListValues().front().getValue();
|
|
if (!linked) {
|
|
return;
|
|
}
|
|
auto linkedProp = linked->getPropertyByName(prop.getName());
|
|
if (linkedProp && linkedProp->getTypeId() == prop.getTypeId() && !linkedProp->isSame(prop)) {
|
|
BindCopyOnChange.setValue(2);
|
|
}
|
|
}
|
|
|
|
void SubShapeBinder::checkPropertyStatus()
|
|
{
|
|
Support.setAllowPartial(PartialLoad.getValue());
|
|
|
|
// Make Shape transient can reduce some file size, and maybe reduce file
|
|
// loading time as well. But there maybe complication arise when doing
|
|
// TopoShape version upgrade. So we DO NOT set transient at the moment.
|
|
//
|
|
// Shape.setStatus(App::Property::Transient, !PartialLoad.getValue() && BindMode.getValue()==0);
|
|
}
|
|
|
|
void SubShapeBinder::setLinks(
|
|
std::map<App::DocumentObject*, std::vector<std::string>>&& values,
|
|
bool reset
|
|
)
|
|
{
|
|
if (values.empty()) {
|
|
if (reset) {
|
|
Support.setValue(nullptr);
|
|
Shape.setValue(Part::TopoShape());
|
|
}
|
|
return;
|
|
}
|
|
auto inSet = getInListEx(true);
|
|
inSet.insert(this);
|
|
|
|
for (auto& v : values) {
|
|
if (!v.first || !v.first->isAttachedToDocument()) {
|
|
FC_THROWM(Base::ValueError, "Invalid document object");
|
|
}
|
|
if (inSet.find(v.first) != inSet.end()) {
|
|
FC_THROWM(Base::ValueError, "Cyclic reference to " << v.first->getFullName());
|
|
}
|
|
|
|
if (v.second.empty()) {
|
|
v.second.emplace_back("");
|
|
continue;
|
|
}
|
|
|
|
std::vector<std::string> wholeSubs;
|
|
for (auto& sub : v.second) {
|
|
if (sub.empty()) {
|
|
wholeSubs.clear();
|
|
v.second.resize(1);
|
|
v.second[0].clear();
|
|
break;
|
|
}
|
|
else if (sub[sub.size() - 1] == '.') {
|
|
wholeSubs.push_back(sub);
|
|
}
|
|
}
|
|
for (auto& whole : wholeSubs) {
|
|
for (auto it = v.second.begin(); it != v.second.end();) {
|
|
auto& sub = *it;
|
|
if (!boost::starts_with(sub, whole) || sub.size() == whole.size()) {
|
|
++it;
|
|
}
|
|
else {
|
|
FC_LOG("Remove subname " << sub << " because of whole selection " << whole);
|
|
it = v.second.erase(it);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!reset) {
|
|
for (auto& link : Support.getSubListValues()) {
|
|
auto subs = link.getSubValues();
|
|
auto& s = values[link.getValue()];
|
|
if (s.empty()) {
|
|
s = std::move(subs);
|
|
continue;
|
|
}
|
|
else if (subs.empty() || s[0].empty()) {
|
|
continue;
|
|
}
|
|
|
|
for (auto& sub : s) {
|
|
for (auto it = subs.begin(); it != subs.end();) {
|
|
if (sub[sub.size() - 1] == '.') {
|
|
if (boost::starts_with(*it, sub)) {
|
|
FC_LOG("Remove subname " << *it << " because of whole selection " << sub);
|
|
it = subs.erase(it);
|
|
}
|
|
else {
|
|
++it;
|
|
}
|
|
}
|
|
else if (it->empty() || (it->back() == '.' && boost::starts_with(sub, *it))) {
|
|
FC_LOG("Remove whole subname " << *it << " because of " << sub);
|
|
it = subs.erase(it);
|
|
}
|
|
else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
subs.insert(subs.end(), s.begin(), s.end());
|
|
s = std::move(subs);
|
|
}
|
|
}
|
|
Support.setValues(std::move(values));
|
|
}
|
|
|
|
void SubShapeBinder::handleChangedPropertyType(
|
|
Base::XMLReader& reader,
|
|
const char* TypeName,
|
|
App::Property* prop
|
|
)
|
|
{
|
|
if (prop == &Support) {
|
|
Support.upgrade(reader, TypeName);
|
|
}
|
|
else {
|
|
inherited::handleChangedPropertyType(reader, TypeName, prop);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace App
|
|
{
|
|
PROPERTY_SOURCE_TEMPLATE(PartDesign::SubShapeBinderPython, PartDesign::SubShapeBinder)
|
|
template<>
|
|
const char* PartDesign::SubShapeBinderPython::getViewProviderName() const
|
|
{
|
|
return "PartDesignGui::ViewProviderSubShapeBinderPython";
|
|
}
|
|
template class PartDesignExport FeaturePythonT<PartDesign::SubShapeBinder>;
|
|
} // namespace App
|