|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| #include <algorithm>
|
| #include <cmath>
|
| #include <limits>
|
| #include <vector>
|
|
|
| #include <BRepAdaptor_Curve.hxx>
|
| #include <BRepAdaptor_Surface.hxx>
|
| #include <Mod/Part/App/FCBRepAlgoAPI_Section.h>
|
| #include <BRepBuilderAPI_MakeEdge.hxx>
|
| #include <BRepBuilderAPI_MakeFace.hxx>
|
| #include <BRepBuilderAPI_MakeVertex.hxx>
|
| #include <BRepMesh_IncrementalMesh.hxx>
|
| #include <BRepOffsetAPI_NormalProjection.hxx>
|
| #include <BRepTools_WireExplorer.hxx>
|
| #include <BRep_Tool.hxx>
|
| #include <ElCLib.hxx>
|
| #include <GCPnts_AbscissaPoint.hxx>
|
| #include <GC_MakeArcOfCircle.hxx>
|
| #include <GC_MakeCircle.hxx>
|
| #include <GeomAPI_ProjectPointOnCurve.hxx>
|
| #include <GeomAPI_ProjectPointOnSurf.hxx>
|
| #include <GeomConvert.hxx>
|
| #include <GeomConvert_BSplineCurveKnotSplitting.hxx>
|
| #include <GeomLProp_CLProps.hxx>
|
| #include <Geom_BSplineCurve.hxx>
|
| #include <Geom_Circle.hxx>
|
| #include <Geom_Ellipse.hxx>
|
| #include <Geom_Hyperbola.hxx>
|
| #include <Geom_Line.hxx>
|
| #include <Geom_Parabola.hxx>
|
| #include <Geom_Plane.hxx>
|
| #include <Geom_TrimmedCurve.hxx>
|
| #include <Standard_Version.hxx>
|
| #include <TColStd_Array1OfInteger.hxx>
|
| #include <TopExp.hxx>
|
| #include <TopExp_Explorer.hxx>
|
| #include <TopTools_IndexedMapOfShape.hxx>
|
| #include <TopoDS.hxx>
|
| #include <TopoDS_Edge.hxx>
|
| #include <TopoDS_Face.hxx>
|
| #include <TopoDS_Shape.hxx>
|
| #include <gp_Ax3.hxx>
|
| #include <gp_Circ.hxx>
|
| #include <gp_Elips.hxx>
|
| #include <gp_Hypr.hxx>
|
| #include <gp_Parab.hxx>
|
| #include <gp_Pln.hxx>
|
|
|
| #include <boost/algorithm/string.hpp>
|
| #include <boost/algorithm/string/predicate.hpp>
|
| #include <boost/geometry/geometries/register/point.hpp>
|
| #include <boost/iostreams/device/array.hpp>
|
| #include <boost/iostreams/stream.hpp>
|
| #include <boost/range/adaptor/map.hpp>
|
| #include <boost/geometry.hpp>
|
|
|
| #include <HLRAlgo_Projector.hxx>
|
| #include <HLRBRep_Algo.hxx>
|
| #include <HLRBRep_HLRToShape.hxx>
|
|
|
| #include <App/Application.h>
|
| #include <App/Document.h>
|
| #include <App/ElementNamingUtils.h>
|
| #include <App/Expression.h>
|
| #include <App/ExpressionParser.h>
|
| #include <App/FeaturePythonPyImp.h>
|
| #include <App/IndexedName.h>
|
| #include <App/MappedName.h>
|
| #include <App/ObjectIdentifier.h>
|
| #include <App/Datums.h>
|
| #include <App/Part.h>
|
| #include <Base/Console.h>
|
| #include <Base/Reader.h>
|
| #include <Base/Tools.h>
|
| #include <Base/Vector3D.h>
|
| #include <Base/Writer.h>
|
| #include <Mod/Part/App/BodyBase.h>
|
| #include <Mod/Part/App/PartPyCXX.h>
|
| #include <Mod/Part/App/DatumFeature.h>
|
| #include <Mod/Part/App/GeometryMigrationExtension.h>
|
| #include <Mod/Part/App/TopoShapeOpCode.h>
|
| #include <Mod/Part/App/WireJoiner.h>
|
|
|
| #include <memory>
|
|
|
| #include "GeoEnum.h"
|
| #include "SketchObject.h"
|
| #include "SketchObjectPy.h"
|
| #include "SolverGeometryExtension.h"
|
| #include "ExternalGeometryFacade.h"
|
| #include <Mod/Part/App/Datums.h>
|
|
|
|
|
| #undef DEBUG
|
|
|
|
|
|
|
| using namespace Sketcher;
|
| using namespace Base;
|
| namespace sp = std::placeholders;
|
| namespace bio = boost::iostreams;
|
|
|
| FC_LOG_LEVEL_INIT("Sketch", true, true)
|
|
|
| PROPERTY_SOURCE(Sketcher::SketchObject, Part::Part2DObject)
|
|
|
| SketchObject::SketchObject() : geoLastId(0)
|
| {
|
| ADD_PROPERTY_TYPE(
|
| Geometry, (nullptr), "Sketch", (App::PropertyType)(App::Prop_None), "Sketch geometry");
|
| ADD_PROPERTY_TYPE(Constraints,
|
| (nullptr),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_None),
|
| "Sketch constraints");
|
| ADD_PROPERTY_TYPE(ExternalGeometry,
|
| (nullptr, nullptr),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_None | App::Prop_ReadOnly),
|
| "Sketch external geometry");
|
| ADD_PROPERTY_TYPE(ExternalTypes,
|
| ({}),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_None | App::Prop_Hidden),
|
| "Sketch external geometry type: 0 = projection, 1 = intersection, 2 = both.");
|
| ADD_PROPERTY_TYPE(FullyConstrained,
|
| (false),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_Output | App::Prop_ReadOnly | App::Prop_Hidden),
|
| "Sketch is fully constrained");
|
| ADD_PROPERTY_TYPE(Exports,
|
| (nullptr),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_Hidden),"Sketch export geometry");
|
| ADD_PROPERTY_TYPE(ExternalGeo,
|
| (nullptr),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_Hidden),"Sketch external geometry");
|
| ADD_PROPERTY_TYPE(ArcFitTolerance,
|
| (0.0),
|
| "Sketch",
|
| (App::PropertyType)(App::Prop_None),
|
| "Tolerance for fitting arcs of projected external geometry");
|
| ADD_PROPERTY(InternalShape,
|
| (Part::TopoShape()));
|
| ADD_PROPERTY_TYPE(MakeInternals,
|
| (false),
|
| "Internal Geometry",
|
| App::Prop_None,
|
| "Enables selection of closed profiles within a sketch as input for operations");
|
|
|
| Geometry.setOrderRelevant(true);
|
|
|
| allowOtherBody = true;
|
| allowUnaligned = true;
|
|
|
| initExternalGeo();
|
|
|
| rebuildVertexIndex();
|
|
|
| lastDoF = 0;
|
| lastHasConflict = false;
|
| lastHasRedundancies = false;
|
| lastHasPartialRedundancies = false;
|
| lastHasMalformedConstraints = false;
|
| lastSolverStatus = 0;
|
| lastSolveTime = 0;
|
|
|
| solverNeedsUpdate = false;
|
|
|
| noRecomputes = false;
|
|
|
|
|
| ExpressionEngine.setValidator(
|
| std::bind(&Sketcher::SketchObject::validateExpression, this, sp::_1, sp::_2));
|
|
|
| constraintsRemovedConn = Constraints.signalConstraintsRemoved.connect(
|
| std::bind(&Sketcher::SketchObject::constraintsRemoved, this, sp::_1));
|
| constraintsRenamedConn = Constraints.signalConstraintsRenamed.connect(
|
| std::bind(&Sketcher::SketchObject::constraintsRenamed, this, sp::_1));
|
|
|
|
|
| analyser = new SketchAnalysis(this);
|
|
|
| internaltransaction = false;
|
| managedoperation = false;
|
|
|
| registerElementCache(internalPrefix(), &InternalShape);
|
| }
|
|
|
| SketchObject::~SketchObject() {
|
| delete analyser;
|
| }
|
|
|
| void SketchObject::setupObject()
|
| {
|
| ParameterGrp::handle hGrpp = App::GetApplication().GetParameterGroupByPath(
|
| "User parameter:BaseApp/Preferences/Mod/Sketcher");
|
| ArcFitTolerance.setValue(hGrpp->GetFloat("ArcFitTolerance", Precision::Confusion()*10.0));
|
| MakeInternals.setValue(hGrpp->GetBool("MakeInternals", false));
|
| inherited::setupObject();
|
| }
|
|
|
| void SketchObject::initExternalGeo() {
|
| std::vector<Part::Geometry *> geos;
|
| auto HLine = GeometryTypedFacade<Part::GeomLineSegment>::getTypedFacade();
|
| auto VLine = GeometryTypedFacade<Part::GeomLineSegment>::getTypedFacade();
|
| HLine->getTypedGeometry()->setPoints(Base::Vector3d(0,0,0),Base::Vector3d(1,0,0));
|
| VLine->getTypedGeometry()->setPoints(Base::Vector3d(0,0,0),Base::Vector3d(0,1,0));
|
| HLine->setConstruction(true);
|
| HLine->setId(-1);
|
| VLine->setConstruction(true);
|
| VLine->setId(-2);
|
| geos.push_back(HLine->getGeometry());
|
| geos.push_back(VLine->getGeometry());
|
| HLine->setOwner(false);
|
| VLine->setOwner(false);
|
| ExternalGeo.setValues(std::move(geos));
|
| }
|
|
|
| short SketchObject::mustExecute() const
|
| {
|
| if (Geometry.isTouched())
|
| return 1;
|
| if (Constraints.isTouched())
|
| return 1;
|
| if (ExternalGeometry.isTouched())
|
| return 1;
|
| if (ExternalGeo.isTouched())
|
| return 1;
|
| return Part2DObject::mustExecute();
|
| }
|
|
|
| App::DocumentObjectExecReturn* SketchObject::execute()
|
| {
|
| try {
|
| App::DocumentObjectExecReturn* rtn = Part2DObject::execute();
|
| if (rtn != App::DocumentObject::StdReturn)
|
|
|
| return rtn;
|
| }
|
| catch (const Base::Exception& e) {
|
| return new App::DocumentObjectExecReturn(e.what());
|
| }
|
|
|
|
|
| try {
|
| rebuildExternalGeometry();
|
| Constraints.acceptGeometry(getCompleteGeometry());
|
| }
|
| catch (const Base::Exception&) {
|
|
|
|
|
|
|
|
|
|
|
| }
|
|
|
|
|
|
|
| int err = this->solve(true);
|
|
|
| if (err == -4) {
|
| std::string msg = "Over-constrained sketch\n";
|
| appendConflictMsg(lastConflicting, msg);
|
| return new App::DocumentObjectExecReturn(msg.c_str(), this);
|
| }
|
| else if (err == -3) {
|
| std::string msg = "Sketch with conflicting constraints\n";
|
| appendConflictMsg(lastConflicting, msg);
|
| return new App::DocumentObjectExecReturn(msg.c_str(), this);
|
| }
|
| else if (err == -2) {
|
| std::string msg = "Sketch with redundant constraints\n";
|
| appendRedundantMsg(lastRedundant, msg);
|
| return new App::DocumentObjectExecReturn(msg.c_str(), this);
|
| }
|
| else if (err == -5) {
|
| std::string msg = "Sketch with malformed constraints\n";
|
| appendMalformedConstraintsMsg(lastMalformedConstraints, msg);
|
| return new App::DocumentObjectExecReturn(msg.c_str(), this);
|
| }
|
| else if (err == -1) {
|
| return new App::DocumentObjectExecReturn("Solving the sketch failed", this);
|
| }
|
|
|
|
|
|
|
| buildShape();
|
|
|
| return App::DocumentObject::StdReturn;
|
| }
|
|
|
| static bool inline checkSmallEdge(const Part::TopoShape &s) {
|
| if (s.shapeType() != TopAbs_EDGE)
|
| return false;
|
| BRepAdaptor_Curve adapt(TopoDS::Edge(s.getShape()));
|
| return GCPnts_AbscissaPoint::Length(adapt, Precision::Confusion()) <= Precision::Confusion();
|
| }
|
|
|
|
|
| void SketchObject::buildShape()
|
| {
|
|
|
|
|
| std::vector<Part::TopoShape> shapes;
|
| std::vector<Part::TopoShape> vertices;
|
| int geoId = 0;
|
|
|
| auto addVertex = [&vertices](auto vertex, auto name) {
|
| if (!vertex.hasElementMap()) {
|
| vertex.resetElementMap(std::make_shared<Data::ElementMap>());
|
| }
|
| vertex.setElementName(
|
| Data::IndexedName::fromConst("Vertex", 1),
|
| Data::MappedName::fromRawData(name.c_str()),
|
| 0L
|
| );
|
| vertices.push_back(vertex);
|
| vertices.back().copyElementMap(vertex, Part::OpCodes::Sketch);
|
| };
|
|
|
| auto addEdge = [this, &shapes](auto geo, auto indexedName) {
|
| shapes.push_back(getEdge(geo, convertSubName(indexedName, false).c_str()));
|
| if (checkSmallEdge(shapes.back())) {
|
| FC_WARN("Edge too small: " << indexedName);
|
| }
|
| };
|
|
|
|
|
| auto geometries = solvedSketch.extractGeometry();
|
| for (auto geo : geometries) {
|
| ++geoId;
|
| if (GeometryFacade::getConstruction(geo)) {
|
| continue;
|
| }
|
| if (geo->isDerivedFrom<Part::GeomPoint>()) {
|
| int idx = getVertexIndexGeoPos(geoId - 1, Sketcher::PointPos::start);
|
| addVertex(
|
| Part::TopoShape {TopoDS::Vertex(geo->toShape())},
|
| convertSubName(Data::IndexedName::fromConst("Vertex", idx + 1), false)
|
| );
|
| }
|
| else {
|
| auto indexedName = Data::IndexedName::fromConst("Edge", geoId);
|
| addEdge(geo, indexedName);
|
| }
|
| }
|
|
|
| for (auto geo : geometries) {
|
| delete geo;
|
| }
|
|
|
| for (int i = 2; i < ExternalGeo.getSize(); ++i) {
|
| auto geo = ExternalGeo[i];
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if (!egf->testFlag(ExternalGeometryExtension::Defining)) {
|
| continue;
|
| }
|
|
|
| auto indexedName = Data::IndexedName::fromConst("ExternalEdge", i - 1);
|
|
|
| if (geo->isDerivedFrom<Part::GeomPoint>()) {
|
| addVertex(
|
| Part::TopoShape {TopoDS::Vertex(geo->toShape())},
|
| convertSubName(indexedName, false)
|
| );
|
| }
|
| else {
|
| addEdge(geo, indexedName);
|
| }
|
| }
|
|
|
| internalElementMap.clear();
|
|
|
| if (shapes.empty() && vertices.empty()) {
|
| InternalShape.setValue(Part::TopoShape());
|
| Shape.setValue(Part::TopoShape());
|
| return;
|
| }
|
| Part::TopoShape result(0, getDocument()->getStringHasher());
|
| if (vertices.empty()) {
|
|
|
| result.makeElementWires(shapes, Part::OpCodes::Sketch);
|
| }
|
| else {
|
| std::vector<Part::TopoShape> results;
|
| if (!shapes.empty()) {
|
|
|
|
|
|
|
|
|
|
|
| auto wires = Part::TopoShape().makeElementWires(shapes, Part::OpCodes::Sketch);
|
| for (const auto& wire : wires.getSubTopoShapes(TopAbs_WIRE)) {
|
| results.push_back(wire);
|
| }
|
| }
|
| results.insert(results.end(), vertices.begin(), vertices.end());
|
| result.makeElementCompound(results);
|
| }
|
| result.Tag = getID();
|
| InternalShape.setValue(buildInternals(result.located(TopLoc_Location())));
|
|
|
|
|
|
|
| Shape.setValue(result);
|
| }
|
|
|
|
|
| const std::map<std::string,std::string> SketchObject::getInternalElementMap() const
|
| {
|
| if (!internalElementMap.empty() || !MakeInternals.getValue())
|
| return internalElementMap;
|
|
|
| const auto& internalShape = InternalShape.getShape();
|
| auto shape = Shape.getShape().located(TopLoc_Location());
|
| if (!internalShape.isNull() && !shape.isNull()) {
|
| std::vector<std::string> names;
|
| std::string prefix;
|
| const std::array<TopAbs_ShapeEnum, 2> types = {TopAbs_VERTEX, TopAbs_EDGE};
|
| for (const auto &type : types) {
|
| prefix = internalPrefix() + Part::TopoShape::shapeName(type);
|
| std::size_t len = prefix.size();
|
| int i=0;
|
| for (const auto &v : internalShape.getSubTopoShapes(type)) {
|
| ++i;
|
| shape.findSubShapesWithSharedVertex(v, &names, Data::SearchOption::CheckGeometry
|
| |Data::SearchOption::SingleResult);
|
| if (names.empty())
|
| continue;
|
| prefix += std::to_string(i);
|
| internalElementMap[prefix] = names.front();
|
| internalElementMap[names.front()] = prefix;
|
| prefix.resize(len);
|
| names.clear();
|
| }
|
| }
|
| }
|
| return internalElementMap;
|
| }
|
|
|
| Part::TopoShape SketchObject::buildInternals(const Part::TopoShape &edges) const {
|
| if (!MakeInternals.getValue())
|
| return Part::TopoShape();
|
|
|
| try {
|
| Part::WireJoiner joiner;
|
| joiner.setTightBound(true);
|
| joiner.setMergeEdges(true);
|
| joiner.addShape(edges);
|
| Part::TopoShape result(getID(), getDocument()->getStringHasher());
|
| if (!joiner.Shape().IsNull()) {
|
| joiner.getResultWires(result, "SKF");
|
| result = result.makeElementFace(result.getSubTopoShapes(TopAbs_WIRE),
|
| "",
|
| "Part::FaceMakerRing",
|
| nullptr
|
| );
|
| }
|
| Part::TopoShape openWires(getID(), getDocument()->getStringHasher());
|
| joiner.getOpenWires(openWires, "SKF");
|
| if (openWires.isNull()) {
|
| return result;
|
| }
|
| if (result.isNull()) {
|
| return openWires;
|
| }
|
| return result.makeElementCompound({result, openWires});
|
| } catch (Base::Exception &e) {
|
| FC_WARN("Failed to make face for sketch: " << e.what());
|
| } catch (Standard_Failure &e) {
|
| FC_WARN("Failed to make face for sketch: " << e.GetMessageString());
|
| }
|
| return Part::TopoShape();
|
| }
|
|
|
| static const char *hasSketchMarker(const char *name) {
|
| static std::string marker(Part::TopoShape::elementMapPrefix()+Part::OpCodes::Sketch);
|
| if (!name)
|
| return nullptr;
|
| return strstr(name,marker.c_str());
|
| }
|
|
|
| int SketchObject::hasConflicts() const
|
| {
|
| if (lastDoF < 0)
|
| return -2;
|
| if (solvedSketch.hasConflicts())
|
| return -1;
|
|
|
| return 0;
|
| }
|
|
|
| void SketchObject::retrieveSolverDiagnostics()
|
| {
|
| lastHasConflict = solvedSketch.hasConflicts();
|
| lastHasRedundancies = solvedSketch.hasRedundancies();
|
| lastHasPartialRedundancies = solvedSketch.hasPartialRedundancies();
|
| lastHasMalformedConstraints = solvedSketch.hasMalformedConstraints();
|
| lastConflicting = solvedSketch.getConflicting();
|
| lastRedundant = solvedSketch.getRedundant();
|
| lastPartiallyRedundant = solvedSketch.getPartiallyRedundant();
|
| lastMalformedConstraints = solvedSketch.getMalformedConstraints();
|
| }
|
|
|
| int SketchObject::solve(bool updateGeoAfterSolving )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| solvedSketch.resetInitMove();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| lastDoF = solvedSketch.setUpSketch(
|
| getCompleteGeometry(), Constraints.getValues(), getExternalGeometryCount());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| solverNeedsUpdate = false;
|
|
|
| retrieveSolverDiagnostics();
|
|
|
| lastSolveTime = 0.0;
|
|
|
|
|
| lastSolverStatus = GCS::Failed;
|
|
|
| int err = 0;
|
|
|
|
|
|
|
|
|
| if (lastHasRedundancies) {
|
| err = -2;
|
| }
|
|
|
| if (lastDoF < 0) {
|
| err = -4;
|
| }
|
| else if (lastHasConflict) {
|
|
|
| err = -3;
|
| }
|
| else if (lastHasMalformedConstraints) {
|
| err = -5;
|
| }
|
| else {
|
| lastSolverStatus = solvedSketch.solve();
|
| if (lastSolverStatus != 0) {
|
| err = -1;
|
| }
|
| }
|
|
|
| if (lastHasMalformedConstraints) {
|
| Base::Console().error(
|
| this->getFullLabel(),
|
| QT_TRANSLATE_NOOP("Notifications", "The Sketch has malformed constraints!") "\n");
|
| }
|
|
|
| if (lastHasPartialRedundancies) {
|
| QString uniqueName = QString::fromLatin1(this->getNameInDocument());
|
| QString userLabel = QString::fromUtf8(Label.getValue());
|
|
|
| QString ref;
|
| if (uniqueName == userLabel) {
|
| ref = uniqueName;
|
| } else {
|
| ref = QStringLiteral("%1 (%2)").arg(uniqueName).arg(userLabel);
|
| }
|
|
|
| QString msg = QCoreApplication::translate(
|
| "Notifications",
|
| "\"%1\" has partially redundant constraint(s)."
|
| ).arg(ref);
|
|
|
| Base::Console().warning(this->getFullLabel(), "%s\n", msg.toUtf8().constData());
|
| }
|
|
|
| lastSolveTime = solvedSketch.getSolveTime();
|
|
|
|
|
|
|
|
|
| if (err == 0) {
|
| FullyConstrained.setValue(lastDoF == 0);
|
| if (updateGeoAfterSolving) {
|
|
|
| std::vector<Part::Geometry*> geomlist = solvedSketch.extractGeometry();
|
| Part::PropertyGeometryList tmp;
|
| tmp.setValues(std::move(geomlist));
|
|
|
| if (Constraints.isTouched() || !Geometry.isSame(tmp)) {
|
| Geometry.moveValues(std::move(tmp));
|
| }
|
| }
|
| }
|
|
|
| signalSolverUpdate();
|
|
|
| return err;
|
| }
|
|
|
| namespace bg = boost::geometry;
|
| namespace bgi = boost::geometry::index;
|
|
|
|
|
| BOOST_GEOMETRY_REGISTER_POINT_3D(Base::Vector3d, double, bg::cs::cartesian, x, y, z)
|
|
|
| class SketchObject::GeoHistory
|
| {
|
| private:
|
| static constexpr int bgiMaxElements = 16;
|
|
|
| using Parameters = bgi::linear<bgiMaxElements>;
|
| using IdSet = std::set<long>;
|
| using IdSets = std::pair<IdSet, IdSet>;
|
| using AdjList = std::list<IdSet>;
|
|
|
|
|
| using AdjMap = std::map<long, IdSets>;
|
|
|
|
|
| using Value = std::pair<Base::Vector3d, AdjList::iterator>;
|
|
|
| AdjList adjlist;
|
| AdjMap adjmap;
|
| bgi::rtree<Value,Parameters> rtree;
|
|
|
| public:
|
| AdjList::iterator find(const Base::Vector3d &pt,bool strict=true){
|
| std::vector<Value> ret;
|
| rtree.query(bgi::nearest(pt, 1), std::back_inserter(ret));
|
| if (!ret.empty()) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| double tol = strict?Precision::SquareConfusion()*10:1e-6;
|
| double d = Base::DistanceP2(ret[0].first,pt);
|
| if(d<tol) {
|
| return ret[0].second;
|
| }
|
| }
|
| return adjlist.end();
|
| }
|
|
|
| void clear() {
|
| rtree.clear();
|
| adjlist.clear();
|
| }
|
|
|
| void update(const Base::Vector3d &pt, long id) {
|
| FC_TRACE("update " << id << ", " << FC_xyz(pt));
|
| auto it = find(pt);
|
| if(it==adjlist.end()) {
|
| adjlist.emplace_back();
|
| it = adjlist.end();
|
| --it;
|
| rtree.insert(std::make_pair(pt,it));
|
| }
|
| it->insert(id);
|
| }
|
|
|
| void finishUpdate(const std::map<long,int> &geomap) {
|
| IdSet oldset;
|
| for(auto &idset : adjlist) {
|
| oldset.clear();
|
| for(long _id : idset) {
|
| long id = abs(_id);
|
| auto& v = adjmap[id];
|
| auto& adj = _id > 0 ? v.first : v.second;
|
| for (auto it = adj.begin(); it != adj.end(); ) {
|
| long other = *it;
|
| auto removeId = it++;
|
| if (geomap.find(other) == geomap.end()) {
|
|
|
| oldset.insert(other);
|
| }
|
| else if (idset.find(other) == idset.end()) {
|
|
|
| adj.erase(removeId);
|
| }
|
| }
|
|
|
| for(long _id2 : idset) {
|
| long id2 = abs(_id2);
|
| if(id!=id2) {
|
| adj.insert(id2);
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
| idset.swap(oldset);
|
| }
|
| }
|
|
|
| AdjList::iterator end() {
|
| return adjlist.end();
|
| }
|
|
|
| size_t size() {
|
| return rtree.size();
|
| }
|
| };
|
|
|
| void SketchObject::updateGeoHistory() {
|
| if(!geoHistoryLevel) return;
|
|
|
| if (!geoHistory) {
|
| geoHistory = std::make_unique<GeoHistory>();
|
| }
|
|
|
| FC_TIME_INIT(t);
|
| const auto &geos = getInternalGeometry();
|
| geoHistory->clear();
|
| for (auto geo : geos) {
|
| auto pstart = getPoint(geo, PointPos::start);
|
| auto pend = getPoint(geo, PointPos::end);
|
| int id = GeometryFacade::getId(geo);
|
| geoHistory->update(pstart,id);
|
| if(pstart!=pend)
|
| geoHistory->update(pend,-id);
|
| }
|
| geoHistory->finishUpdate(geoMap);
|
| FC_TIME_LOG(t,"update geometry history (" << geoHistory->size() << ", " << geoMap.size()<<')');
|
| }
|
|
|
|
|
| void SketchObject::generateId(const Part::Geometry* geo)
|
| {
|
| auto preReturn = [this, &geo](auto& newId) {
|
| GeometryFacade::setId(geo, newId);
|
| geoMap[Sketcher::GeometryFacade::getId(geo)] = (long)Geometry.getSize();
|
| };
|
|
|
| auto isNotInGeoMap = [this](auto& id) {
|
| if (geoMap.find(id) == geoMap.end()) {
|
| return true;
|
| }
|
| FC_TRACE("ignore " << id);
|
| return false;
|
| };
|
|
|
| if (geoHistoryLevel == 0) {
|
| preReturn(++geoLastId);
|
| return;
|
| }
|
|
|
| if (!geoHistory) {
|
| updateGeoHistory();
|
| }
|
|
|
|
|
|
|
|
|
| auto pstart = getPoint(geo, PointPos::start);
|
| auto it = geoHistory->find(pstart, false);
|
| auto pend = getPoint(geo, PointPos::end);
|
| auto it2 = it;
|
| if (pstart != pend) {
|
| it2 = geoHistory->find(pend, false);
|
| if (it2 == geoHistory->end()) {
|
| it2 = it;
|
| }
|
| }
|
| std::vector<long> found;
|
|
|
| if (geoHistoryLevel <= 1 && (it == geoHistory->end() || it2 == it)) {
|
|
|
| preReturn(++geoLastId);
|
| return;
|
| }
|
|
|
| if (it != geoHistory->end()) {
|
|
|
| auto iterOfId = std::ranges::find_if(*it, isNotInGeoMap);
|
| if (iterOfId != it->end() && it2 == it) {
|
| preReturn(*iterOfId);
|
| return;
|
| }
|
| std::copy_if(iterOfId, it->end(), std::back_inserter(found), isNotInGeoMap);
|
| }
|
| if (found.empty()) {
|
|
|
| if (it2 == it) {
|
| preReturn(++geoLastId);
|
| return;
|
| }
|
| auto iterOfId = std::ranges::find_if(*it, isNotInGeoMap);
|
| if (iterOfId != it->end()) {
|
| preReturn(*iterOfId);
|
| return;
|
| }
|
| preReturn(++geoLastId);
|
| return;
|
| }
|
|
|
| auto isInIt2 = [&it2](auto& id) {
|
| if (it2->find(id) != it2->end()) {
|
| return true;
|
| }
|
| FC_TRACE("ignore " << id);
|
| return false;
|
| };
|
|
|
|
|
|
|
| if (it2 != it) {
|
| auto iterOfId = std::ranges::find_if(found, isInIt2);
|
| if (iterOfId != found.end()) {
|
| preReturn(*iterOfId);
|
| return;
|
| }
|
| }
|
| FC_TRACE("found " << found.front());
|
| preReturn(found.front());
|
| }
|
|
|
|
|
| int SketchObject::setDatum(int ConstrId, double Datum)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| if (this->Constraints.hasInvalidGeometry())
|
| return -6;
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
| ConstraintType type = vals[ConstrId]->Type;
|
|
|
| if (!vals[ConstrId]->isDimensional() && type != Tangent && type != Perpendicular)
|
| return -1;
|
|
|
| if ((type == Radius || type == Diameter || type == Weight) && Datum <= 0)
|
| return (Datum == 0) ? -5 : -4;
|
|
|
| if (type == Distance && Datum == 0)
|
| return -5;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
| double oldDatum = newVals[ConstrId]->getValue();
|
| newVals[ConstrId] = newVals[ConstrId]->clone();
|
| newVals[ConstrId]->setValue(Datum);
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| int err = solve();
|
|
|
| if (err)
|
| this->Constraints.getValues()[ConstrId]->setValue(oldDatum);
|
|
|
| return err;
|
| }
|
| double SketchObject::getDatum(int ConstrId) const
|
| {
|
| if (!this->Constraints[ConstrId]->isDimensional()) {
|
| return 0.0;
|
| }
|
| return this->Constraints[ConstrId]->getValue();
|
| }
|
|
|
| int SketchObject::setDriving(int ConstrId, bool isdriving)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| int ret = testDrivingChange(ConstrId, isdriving);
|
|
|
| if (ret < 0)
|
| return ret;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
| newVals[ConstrId] = newVals[ConstrId]->clone();
|
| newVals[ConstrId]->isDriving = isdriving;
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| if (!isdriving)
|
| setExpression(Constraints.createPath(ConstrId), std::shared_ptr<App::Expression>());
|
|
|
|
|
| if (noRecomputes)
|
| solve();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::getDriving(int ConstrId, bool& isdriving)
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
| if (!vals[ConstrId]->isDimensional())
|
| return -1;
|
|
|
| isdriving = vals[ConstrId]->isDriving;
|
| return 0;
|
| }
|
|
|
| int SketchObject::testDrivingChange(int ConstrId, bool isdriving)
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
| if (!vals[ConstrId]->isDimensional())
|
| return -2;
|
|
|
| if (!(vals[ConstrId]->First >= 0 || vals[ConstrId]->Second >= 0 || vals[ConstrId]->Third >= 0)
|
| && isdriving) {
|
|
|
|
|
| return -3;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::setActive(int ConstrId, bool isactive)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->isActive = isactive;
|
| newVals[ConstrId] = constNew;
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
| if (noRecomputes)
|
| solve();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::getActive(int ConstrId, bool& isactive)
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
| isactive = vals[ConstrId]->isActive;
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::toggleActive(int ConstrId)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->isActive = !constNew->isActive;
|
| newVals[ConstrId] = constNew;
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
| if (noRecomputes)
|
| solve();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::setLabelPosition(int ConstrId, float value)
|
| {
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->LabelPosition = value;
|
| newVals[ConstrId] = constNew;
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::getLabelPosition(int ConstrId, float& value)
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
| value = vals[ConstrId]->LabelPosition;
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::setLabelDistance(int ConstrId, float value)
|
| {
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->LabelDistance = value;
|
| newVals[ConstrId] = constNew;
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::getLabelDistance(int ConstrId, float& value)
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
| value = vals[ConstrId]->LabelDistance;
|
|
|
| return 0;
|
| }
|
|
|
|
|
|
|
| int SketchObject::setDatumsDriving(bool isdriving)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| for (size_t i = 0; i < newVals.size(); i++) {
|
| if (!testDrivingChange(i, isdriving)) {
|
| newVals[i] = newVals[i]->clone();
|
| newVals[i]->isDriving = isdriving;
|
| }
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
| const std::vector<Constraint*>& uvals = this->Constraints.getValues();
|
|
|
| for (size_t i = 0; i < uvals.size(); i++) {
|
| if (!isdriving && uvals[i]->isDimensional())
|
| setExpression(Constraints.createPath(i), std::shared_ptr<App::Expression>());
|
| }
|
|
|
|
|
| if (noRecomputes)
|
| solve();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::moveDatumsToEnd()
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| std::vector<Constraint*> copy(vals);
|
| std::vector<Constraint*> newVals(vals.size());
|
|
|
| int addindex = copy.size() - 1;
|
|
|
|
|
| for (int i = copy.size() - 1; i >= 0; i--) {
|
| if (copy[i]->isDimensional()) {
|
| newVals[addindex] = copy[i];
|
| addindex--;
|
| }
|
| }
|
|
|
|
|
| for (int i = copy.size() - 1; i >= 0; i--) {
|
| if (!copy[i]->isDimensional()) {
|
| newVals[addindex] = copy[i];
|
| addindex--;
|
| }
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
| if (noRecomputes)
|
| solve();
|
|
|
| return 0;
|
| }
|
|
|
| void SketchObject::reverseAngleConstraintToSupplementary(Constraint* constr, int constNum)
|
| {
|
| std::swap(constr->First, constr->Second);
|
| std::swap(constr->FirstPos, constr->SecondPos);
|
| constr->FirstPos = (constr->FirstPos == Sketcher::PointPos::start) ? Sketcher::PointPos::end : Sketcher::PointPos::start;
|
|
|
|
|
| if (constraintHasExpression(constNum)) {
|
| std::string expression = getConstraintExpression(constNum);
|
| setConstraintExpression(constNum, std::move(reverseAngleConstraintExpression(expression)));
|
| }
|
| else {
|
| double actAngle = constr->getValue();
|
| constr->setValue(std::numbers::pi - actAngle);
|
| }
|
| }
|
|
|
| void SketchObject::inverseAngleConstraint(Constraint* constr)
|
| {
|
| constr->FirstPos = (constr->FirstPos == Sketcher::PointPos::start) ? Sketcher::PointPos::end : Sketcher::PointPos::start;
|
| constr->SecondPos = (constr->SecondPos == Sketcher::PointPos::start) ? Sketcher::PointPos::end : Sketcher::PointPos::start;
|
| }
|
|
|
| bool SketchObject::constraintHasExpression(int constNum) const
|
| {
|
| App::ObjectIdentifier path = Constraints.createPath(constNum);
|
| auto info = getExpression(path);
|
| if (info.expression) {
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| std::string SketchObject::getConstraintExpression(int constNum) const
|
| {
|
| App::ObjectIdentifier path = Constraints.createPath(constNum);
|
| auto info = getExpression(path);
|
| if (info.expression) {
|
| std::string expression = info.expression->toString();
|
| return expression;
|
| }
|
|
|
| return {};
|
| }
|
|
|
| void SketchObject::setConstraintExpression(int constNum, const std::string& newExpression)
|
| {
|
| App::ObjectIdentifier path = Constraints.createPath(constNum);
|
| auto info = getExpression(path);
|
| if (info.expression) {
|
| try {
|
| std::shared_ptr<App::Expression> expr(App::Expression::parse(this, newExpression));
|
| setExpression(path, std::move(expr));
|
| }
|
| catch (const Base::Exception&) {
|
| Base::Console().error("Failed to set constraint expression.");
|
| }
|
| }
|
| }
|
|
|
| std::string SketchObject::reverseAngleConstraintExpression(std::string expression)
|
| {
|
|
|
| if (expression.find("°") != std::string::npos
|
| || expression.find("deg") != std::string::npos
|
| || expression.find("rad") != std::string::npos) {
|
| if (expression.substr(0, 9) == "180 ° - ") {
|
| expression = expression.substr(9, expression.size() - 9);
|
| }
|
| else {
|
| expression = "180 ° - (" + expression + ")";
|
| }
|
| }
|
| else {
|
| if (expression.substr(0, 6) == "180 - ") {
|
| expression = expression.substr(6, expression.size() - 6);
|
| }
|
| else {
|
| expression = "180 - (" + expression + ")";
|
| }
|
| }
|
| return expression;
|
| }
|
|
|
| int SketchObject::setVirtualSpace(int ConstrId, bool isinvirtualspace)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->isInVirtualSpace = isinvirtualspace;
|
| newVals[ConstrId] = constNew;
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
|
|
| signalSolverUpdate();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::setVirtualSpace(std::vector<int> constrIds, bool isinvirtualspace)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (constrIds.empty())
|
| return 0;
|
|
|
| std::sort(constrIds.begin(), constrIds.end());
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (constrIds.front() < 0 || constrIds.back() >= int(vals.size()))
|
| return -1;
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| for (auto cid : constrIds) {
|
|
|
| if (vals[cid]->isInVirtualSpace != isinvirtualspace) {
|
| Constraint* constNew = vals[cid]->clone();
|
| constNew->isInVirtualSpace = isinvirtualspace;
|
| newVals[cid] = constNew;
|
| }
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
|
|
| signalSolverUpdate();
|
|
|
| return 0;
|
| }
|
|
|
|
|
| int SketchObject::getVirtualSpace(int ConstrId, bool& isinvirtualspace) const
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
| isinvirtualspace = vals[ConstrId]->isInVirtualSpace;
|
| return 0;
|
| }
|
|
|
| int SketchObject::toggleVirtualSpace(int ConstrId)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->isInVirtualSpace = !constNew->isInVirtualSpace;
|
| newVals[ConstrId] = constNew;
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
|
|
| signalSolverUpdate();
|
|
|
| return 0;
|
| }
|
|
|
|
|
| int SketchObject::setVisibility(std::vector<int> constrIds, bool isVisible)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (constrIds.empty())
|
| return 0;
|
|
|
| std::sort(constrIds.begin(), constrIds.end());
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (constrIds.front() < 0 || constrIds.back() >= int(vals.size()))
|
| return -1;
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| for (auto cid : constrIds) {
|
|
|
| if (vals[cid]->isVisible != isVisible) {
|
| Constraint* constNew = vals[cid]->clone();
|
| constNew->isVisible = isVisible;
|
| newVals[cid] = constNew;
|
| }
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
|
|
| signalSolverUpdate();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::setVisibility(int ConstrId, bool isVisible)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return -1;
|
|
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
|
|
| Constraint* constNew = vals[ConstrId]->clone();
|
| constNew->isVisible = isVisible;
|
| newVals[ConstrId] = constNew;
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
|
|
| signalSolverUpdate();
|
|
|
| return 0;
|
| }
|
|
|
|
|
| int SketchObject::setUpSketch()
|
| {
|
| lastDoF = solvedSketch.setUpSketch(
|
| getCompleteGeometry(), Constraints.getValues(), getExternalGeometryCount());
|
|
|
| retrieveSolverDiagnostics();
|
|
|
| if (lastHasRedundancies || lastDoF < 0 || lastHasConflict || lastHasMalformedConstraints
|
| || lastHasPartialRedundancies)
|
| Constraints.touch();
|
|
|
| return lastDoF;
|
| }
|
|
|
| int SketchObject::diagnoseAdditionalConstraints(
|
| std::vector<Sketcher::Constraint*> additionalconstraints)
|
| {
|
| auto objectconstraints = Constraints.getValues();
|
|
|
| std::vector<Sketcher::Constraint*> allconstraints;
|
| allconstraints.reserve(objectconstraints.size() + additionalconstraints.size());
|
|
|
| std::ranges::copy(objectconstraints, back_inserter(allconstraints));
|
| std::ranges::copy(additionalconstraints, back_inserter(allconstraints));
|
|
|
| lastDoF =
|
| solvedSketch.setUpSketch(getCompleteGeometry(), allconstraints, getExternalGeometryCount());
|
|
|
| retrieveSolverDiagnostics();
|
|
|
| return lastDoF;
|
| }
|
|
|
| int SketchObject::moveGeometries(const std::vector<GeoElementId>& geoEltIds, const Base::Vector3d& toPoint, bool relative,
|
| bool updateGeoBeforeMoving)
|
| {
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (updateGeoBeforeMoving || solverNeedsUpdate) {
|
| lastDoF = solvedSketch.setUpSketch(
|
| getCompleteGeometry(), Constraints.getValues(), getExternalGeometryCount());
|
|
|
| retrieveSolverDiagnostics();
|
|
|
| solverNeedsUpdate = false;
|
| }
|
|
|
| if (lastDoF < 0)
|
| return -1;
|
| if (lastHasConflict)
|
| return -1;
|
|
|
|
|
| lastSolverStatus = solvedSketch.moveGeometries(geoEltIds, toPoint, relative);
|
|
|
|
|
|
|
|
|
| if (lastSolverStatus == 0) {
|
| std::vector<Part::Geometry*> geomlist = solvedSketch.extractGeometry();
|
| Geometry.setValues(geomlist);
|
| for (auto* geo : geomlist) {
|
| delete geo;
|
| }
|
| }
|
|
|
| solvedSketch.resetInitMove();
|
|
|
| return lastSolverStatus;
|
| }
|
|
|
| int SketchObject::moveGeometry(int geoId, PointPos pos, const Base::Vector3d& toPoint, bool relative,
|
| bool updateGeoBeforeMoving)
|
| {
|
| std::vector<GeoElementId> geoEltIds = { GeoElementId(geoId, pos) };
|
| return moveGeometries(geoEltIds, toPoint, relative, updateGeoBeforeMoving);
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomPoint *geomPoint, PointPos PosId)
|
| {
|
| if (PosId == PointPos::start || PosId == PointPos::mid || PosId == PointPos::end)
|
| return geomPoint->getPoint();
|
| return Base::Vector3d();
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomLineSegment *lineSeg, PointPos PosId)
|
| {
|
| switch (PosId) {
|
| case PointPos::start: {
|
| return lineSeg->getStartPoint();
|
| }
|
| case PointPos::end: {
|
| return lineSeg->getEndPoint();
|
| }
|
| default:
|
| break;
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomCircle *circle, PointPos PosId)
|
| {
|
| auto pt = circle->getCenter();
|
| if(PosId != PointPos::mid)
|
| pt.x += circle->getRadius();
|
| return pt;
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomEllipse *ellipse, PointPos PosId)
|
| {
|
| auto pt = ellipse->getCenter();
|
| if(PosId != PointPos::mid)
|
| pt += ellipse->getMajorAxisDir()*ellipse->getMajorRadius();
|
| return pt;
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomArcOfCircle *aoc, PointPos PosId)
|
| {
|
| switch (PosId) {
|
| case PointPos::start: {
|
| return aoc->getStartPoint(true);
|
| }
|
| case PointPos::end: {
|
| return aoc->getEndPoint(true);
|
| }
|
| case PointPos::mid: {
|
| return aoc->getCenter();
|
| }
|
| default:
|
| break;
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomArcOfEllipse *aoe, PointPos PosId)
|
| {
|
| switch (PosId) {
|
| case PointPos::start: {
|
| return aoe->getStartPoint(true);
|
| }
|
| case PointPos::end: {
|
| return aoe->getEndPoint(true);
|
| }
|
| case PointPos::mid: {
|
| return aoe->getCenter();
|
| }
|
| default:
|
| break;
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomArcOfHyperbola *aoh, PointPos PosId)
|
| {
|
| switch (PosId) {
|
| case PointPos::start: {
|
| return aoh->getStartPoint();
|
| }
|
| case PointPos::end: {
|
| return aoh->getEndPoint();
|
| }
|
| case PointPos::mid: {
|
| return aoh->getCenter();
|
| }
|
| default:
|
| break;
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomArcOfParabola *aop, PointPos PosId)
|
| {
|
| switch (PosId) {
|
| case PointPos::start: {
|
| return aop->getStartPoint();
|
| }
|
| case PointPos::end: {
|
| return aop->getEndPoint();
|
| }
|
| case PointPos::mid: {
|
| return aop->getCenter();
|
| }
|
| default:
|
| break;
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| template <>
|
| Base::Vector3d SketchObject::getPointForGeometry<>(const Part::GeomBSplineCurve *bsp, PointPos PosId)
|
| {
|
| switch (PosId) {
|
| case PointPos::start: {
|
| return bsp->getStartPoint();
|
| }
|
| case PointPos::end: {
|
| return bsp->getEndPoint();
|
| }
|
| default:
|
| break;
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| Base::Vector3d SketchObject::getPoint(const Part::Geometry *geo, PointPos PosId)
|
| {
|
| if (auto point = freecad_cast<Part::GeomPoint*>(geo)) {
|
| return getPointForGeometry<Part::GeomPoint>(point, PosId);
|
| }
|
| else if (auto lineSegment = freecad_cast<Part::GeomLineSegment*>(geo)) {
|
| return getPointForGeometry<Part::GeomLineSegment>(lineSegment, PosId);
|
| }
|
| else if (auto circle = freecad_cast<Part::GeomCircle*>(geo)) {
|
| return getPointForGeometry<Part::GeomCircle>(circle, PosId);
|
| }
|
| else if (auto ellipse = freecad_cast<Part::GeomEllipse*>(geo)) {
|
| return getPointForGeometry<Part::GeomEllipse>(ellipse, PosId);
|
| }
|
| else if (auto arcOfCircle = freecad_cast<Part::GeomArcOfCircle*>(geo)) {
|
| return getPointForGeometry<Part::GeomArcOfCircle>(arcOfCircle, PosId);
|
| }
|
| else if (auto arcOfEllipse = freecad_cast<Part::GeomArcOfEllipse*>(geo)) {
|
| return getPointForGeometry<Part::GeomArcOfEllipse>(arcOfEllipse, PosId);
|
| }
|
| else if (auto arcOfHyperbola = freecad_cast<Part::GeomArcOfHyperbola*>(geo)) {
|
| return getPointForGeometry<Part::GeomArcOfHyperbola>(arcOfHyperbola, PosId);
|
| }
|
| else if (auto arcOfParabola = freecad_cast<Part::GeomArcOfParabola*>(geo)) {
|
| return getPointForGeometry<Part::GeomArcOfParabola>(arcOfParabola, PosId);
|
| }
|
| else if (auto bSplineCurve = freecad_cast<Part::GeomBSplineCurve*>(geo)) {
|
| return getPointForGeometry<Part::GeomBSplineCurve>(bSplineCurve, PosId);
|
| }
|
| return Base::Vector3d();
|
| }
|
|
|
| Base::Vector3d SketchObject::getPoint(int GeoId, PointPos PosId) const
|
| {
|
| if (!(GeoId == H_Axis || GeoId == V_Axis
|
| || (GeoId <= getHighestCurveIndex() && GeoId >= -getExternalGeometryCount())))
|
| throw Base::ValueError("SketchObject::getPoint. Invalid GeoId was supplied.");
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
| return getPoint(geo,PosId);
|
| }
|
|
|
| int SketchObject::getAxisCount() const
|
| {
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| int count = 0;
|
| for (const auto& geo : vals) {
|
| if (geo && GeometryFacade::getConstruction(geo)
|
| && geo->is<Part::GeomLineSegment>()) {
|
| count++;
|
| }
|
| }
|
|
|
| return count;
|
| }
|
|
|
| Base::Axis SketchObject::getAxis(int axId) const
|
| {
|
| if (axId == H_Axis || axId == V_Axis || axId == N_Axis)
|
| return Part::Part2DObject::getAxis(axId);
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
| int count = 0;
|
| for (const auto& geo : vals) {
|
| if (geo && GeometryFacade::getConstruction(geo)
|
| && geo->is<Part::GeomLineSegment>()) {
|
| if (count == axId) {
|
| auto* lineSeg = static_cast<Part::GeomLineSegment*>(geo);
|
| Base::Vector3d start = lineSeg->getStartPoint();
|
| Base::Vector3d end = lineSeg->getEndPoint();
|
| return Base::Axis(start, end - start);
|
| }
|
| count++;
|
| }
|
| }
|
|
|
| return Base::Axis();
|
| }
|
|
|
| void SketchObject::acceptGeometry()
|
| {
|
| Constraints.acceptGeometry(getCompleteGeometry());
|
| rebuildVertexIndex();
|
| signalElementsChanged();
|
| }
|
|
|
| bool SketchObject::isSupportedGeometry(const Part::Geometry* geo) const
|
| {
|
| if (geo->is<Part::GeomPoint>()
|
| || geo->is<Part::GeomCircle>()
|
| || geo->is<Part::GeomEllipse>()
|
| || geo->is<Part::GeomArcOfCircle>()
|
| || geo->is<Part::GeomArcOfEllipse>()
|
| || geo->is<Part::GeomArcOfHyperbola>()
|
| || geo->is<Part::GeomArcOfParabola>()
|
| || geo->is<Part::GeomBSplineCurve>()
|
| || geo->is<Part::GeomLineSegment>()) {
|
| return true;
|
| }
|
| if (geo->is<Part::GeomTrimmedCurve>()) {
|
| Handle(Geom_TrimmedCurve) trim = Handle(Geom_TrimmedCurve)::DownCast(geo->handle());
|
| Handle(Geom_Circle) circle = Handle(Geom_Circle)::DownCast(trim->BasisCurve());
|
| Handle(Geom_Ellipse) ellipse = Handle(Geom_Ellipse)::DownCast(trim->BasisCurve());
|
| if (!circle.IsNull() || !ellipse.IsNull()) {
|
| return true;
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| std::vector<Part::Geometry*>
|
| SketchObject::supportedGeometry(const std::vector<Part::Geometry*>& geoList) const
|
| {
|
| std::vector<Part::Geometry*> supportedGeoList;
|
| supportedGeoList.reserve(geoList.size());
|
|
|
| for (const auto& geo : geoList) {
|
| if (isSupportedGeometry(geo)) {
|
| supportedGeoList.push_back(geo);
|
| }
|
| }
|
|
|
| return supportedGeoList;
|
| }
|
|
|
| int SketchObject::addGeometry(const std::vector<Part::Geometry*>& geoList,
|
| bool construction )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
| newVals.reserve(newVals.size() + geoList.size());
|
| for (auto& v : geoList) {
|
| Part::Geometry* copy = v->copy();
|
| generateId(copy);
|
|
|
| if (construction) {
|
| GeometryFacade::setConstruction(copy, construction);
|
| }
|
|
|
| newVals.push_back(copy);
|
| }
|
|
|
|
|
|
|
| Geometry.setValues(std::move(newVals));
|
|
|
| return Geometry.getSize() - 1;
|
| }
|
|
|
| int SketchObject::addGeometry(const Part::Geometry* geo, bool construction )
|
| {
|
|
|
| auto geoNew = std::unique_ptr<Part::Geometry>(geo->copy());
|
|
|
| return addGeometry(std::move(geoNew), construction);
|
| }
|
|
|
| int SketchObject::addGeometry(std::unique_ptr<Part::Geometry> newgeo, bool construction )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
| auto* geoNew = newgeo.release();
|
| generateId(geoNew);
|
|
|
| if (construction) {
|
| GeometryFacade::setConstruction(geoNew, construction);
|
| }
|
|
|
| newVals.push_back(geoNew);
|
|
|
|
|
|
|
| Geometry.setValues(std::move(newVals));
|
|
|
| return Geometry.getSize() - 1;
|
| }
|
|
|
| bool SketchObject::isClosedCurve(const Part::Geometry* geo)
|
| {
|
| return (geo->is<Part::GeomCircle>()
|
| || geo->is<Part::GeomEllipse>()
|
| || (geo->is<Part::GeomBSplineCurve>()
|
| && static_cast<const Part::GeomBSplineCurve*>(geo)->isPeriodic()));
|
| }
|
|
|
| bool SketchObject::hasInternalGeometry(const Part::Geometry* geo)
|
| {
|
| return (geo->is<Part::GeomEllipse>()
|
| || geo->is<Part::GeomArcOfEllipse>()
|
| || geo->is<Part::GeomArcOfHyperbola>()
|
| || geo->is<Part::GeomArcOfParabola>()
|
| || geo->is<Part::GeomBSplineCurve>());
|
| }
|
|
|
| int SketchObject::delGeometry(int GeoId, DeleteOptions options)
|
| {
|
| if (GeoId < 0) {
|
| if(GeoId > GeoEnum::RefExt)
|
| return -1;
|
| return delExternal(-GeoId-1);
|
| }
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
| if (GeoId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
| if (options.testFlag(DeleteOption::IncludeInternalGeometry) && hasInternalGeometry(getGeometry(GeoId))) {
|
|
|
| this->deleteUnusedInternalGeometry(GeoId, true);
|
| return 0;
|
| }
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
| newVals.erase(newVals.begin() + GeoId);
|
|
|
|
|
| std::vector<int> GeoIdList;
|
| std::vector<PointPos> PosIdList;
|
| for (PointPos PosId : {PointPos::start, PointPos::end, PointPos::mid}) {
|
| getDirectlyCoincidentPoints(GeoId, PosId, GeoIdList, PosIdList);
|
| if (GeoIdList.size() > 1) {
|
| delConstraintOnPoint(GeoId, PosId, true );
|
| transferConstraints(GeoIdList[0], PosIdList[0], GeoIdList[1], PosIdList[1]);
|
| }
|
| }
|
|
|
| const std::vector<Constraint*>& constraints = this->Constraints.getValues();
|
| std::vector<Constraint*> newConstraints;
|
| newConstraints.reserve(constraints.size());
|
| for (const auto& constr : constraints) {
|
| if (auto newConstr = getConstraintAfterDeletingGeo(constr, GeoId)) {
|
| newConstraints.push_back(newConstr.release());
|
| }
|
| }
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| this->Geometry.setValues(std::move(newVals));
|
| this->Constraints.setValues(std::move(newConstraints));
|
| }
|
|
|
|
|
|
|
| Geometry.touch();
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoSolve)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::delGeometries(const std::vector<int>& GeoIds, DeleteOptions options)
|
| {
|
| return delGeometries(GeoIds.begin(), GeoIds.end(), options);
|
| }
|
|
|
| template <class InputIt>
|
| int SketchObject::delGeometries(InputIt first, InputIt last, DeleteOptions options)
|
| {
|
| std::vector<int> sGeoIds;
|
| std::vector<int> negativeGeoIds;
|
|
|
|
|
| for (auto it = first; it != last; ++it) {
|
| int geoId = *it;
|
| if (geoId < 0 && geoId <= GeoEnum::RefExt) {
|
| negativeGeoIds.push_back(geoId);
|
| }
|
| else if (geoId >= 0){
|
| sGeoIds.push_back(geoId);
|
| }
|
| }
|
|
|
|
|
| if (!negativeGeoIds.empty()) {
|
| int result = delExternal(negativeGeoIds);
|
| if (result != 0) {
|
| return result;
|
| }
|
| }
|
|
|
|
|
| if (sGeoIds.empty()) {
|
| return 0;
|
| }
|
|
|
|
|
| for (auto c : Constraints.getValues()) {
|
| if (c->Type == InternalAlignment) {
|
| auto pos = std::ranges::find(sGeoIds, c->Second);
|
|
|
| if (pos != sGeoIds.end()) {
|
| sGeoIds.push_back(c->First);
|
| }
|
| }
|
| }
|
|
|
| std::ranges::sort(sGeoIds);
|
|
|
| auto newend = std::unique(sGeoIds.begin(), sGeoIds.end());
|
| sGeoIds.resize(std::distance(sGeoIds.begin(), newend));
|
|
|
| return delGeometriesExclusiveList(sGeoIds, options);
|
| }
|
|
|
| int SketchObject::delGeometriesExclusiveList(const std::vector<int>& GeoIds, DeleteOptions options)
|
| {
|
| std::vector<int> sGeoIds(GeoIds);
|
|
|
| std::ranges::sort(sGeoIds);
|
| if (sGeoIds.empty()) {
|
| return 0;
|
| }
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
| if (sGeoIds.front() < 0 || sGeoIds.back() >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
| for (auto it = sGeoIds.rbegin(); it != sGeoIds.rend(); ++it) {
|
| int GeoId = *it;
|
| newVals.erase(newVals.begin() + GeoId);
|
|
|
|
|
| std::vector<int> GeoIdList;
|
| std::vector<PointPos> PosIdList;
|
| for (PointPos PosId : {PointPos::start, PointPos::end, PointPos::mid}) {
|
| getDirectlyCoincidentPoints(GeoId, PosId, GeoIdList, PosIdList);
|
| if (GeoIdList.size() > 1) {
|
| delConstraintOnPoint(GeoId, PosId, true );
|
| transferConstraints(GeoIdList[0], PosIdList[0], GeoIdList[1], PosIdList[1]);
|
| }
|
| }
|
| }
|
|
|
|
|
| std::vector<Constraint*> constraints;
|
| for (const auto& ptr : this->Constraints.getValues()) {
|
| constraints.push_back(ptr->clone());
|
| }
|
| for (auto itGeo = sGeoIds.rbegin(); itGeo != sGeoIds.rend(); ++itGeo) {
|
| const int GeoId = *itGeo;
|
| for (auto& constr : constraints) {
|
| changeConstraintAfterDeletingGeo(constr, GeoId);
|
| }
|
| }
|
|
|
| constraints.erase(std::remove_if(constraints.begin(),
|
| constraints.end(),
|
| [](const auto& constr) {
|
| return constr->Type == ConstraintType::None;
|
| }),
|
| constraints.end());
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| this->Geometry.setValues(newVals);
|
| this->Constraints.setValues(std::move(constraints));
|
| }
|
|
|
|
|
| Geometry.touch();
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoSolve)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
|
|
| void SketchObject::replaceGeometries(std::vector<int> oldGeoIds, std::vector<Part::Geometry*>& newGeos)
|
| {
|
| auto& vals = getInternalGeometry();
|
| auto newVals(vals);
|
|
|
| if (std::ranges::any_of(oldGeoIds, [](auto geoId) { return geoId < 0; })) {
|
| THROWM(ValueError, "Cannot replace external geometries and axes.");
|
| }
|
|
|
| auto oldGeoIdIter = oldGeoIds.begin();
|
| auto newGeoIter = newGeos.begin();
|
|
|
| for (; oldGeoIdIter != oldGeoIds.end() && newGeoIter != newGeos.end();
|
| ++oldGeoIdIter, ++newGeoIter) {
|
| GeometryFacade::copyId(getGeometry(*oldGeoIdIter), *newGeoIter);
|
| newVals[*oldGeoIdIter] = *newGeoIter;
|
| }
|
|
|
| for (; newGeoIter != newGeos.end(); ++newGeoIter) {
|
| generateId(*newGeoIter);
|
| newVals.push_back(*newGeoIter);
|
| }
|
|
|
|
|
| Geometry.setValues(std::move(newVals));
|
|
|
| delGeometries(oldGeoIdIter, oldGeoIds.end());
|
| }
|
|
|
|
|
| int SketchObject::deleteAllGeometry(DeleteOptions options)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| std::vector<Part::Geometry*> newVals(0);
|
| std::vector<Constraint*> newConstraints(0);
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| this->Geometry.setValues(newVals);
|
| this->Constraints.setValues(newConstraints);
|
| }
|
|
|
|
|
| Geometry.touch();
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoSolve)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::deleteAllConstraints(DeleteOptions options)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| std::vector<Constraint*> newConstraints(0);
|
|
|
| this->Constraints.setValues(newConstraints);
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoSolve)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::toggleConstruction(int GeoId)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId >= 0) {
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
| if (GeoId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
| if (getGeometryFacade(GeoId)->isInternalAligned()) {
|
| return -1;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| std::unique_ptr<Part::Geometry> geo(vals[GeoId]->clone());
|
| auto gft = GeometryFacade::getFacade(geo.get());
|
| gft->setConstruction(!gft->getConstruction());
|
| this->Geometry.set1Value(GeoId, std::move(geo));
|
| }
|
| else {
|
| if (GeoId > GeoEnum::RefExt) {
|
| return -1;
|
| }
|
|
|
| const std::vector<Part::Geometry*>& extGeos = getExternalGeometry();
|
| std::unique_ptr<Part::Geometry> geo(extGeos[-GeoId - 1]->clone());
|
| auto egf = ExternalGeometryFacade::getFacade(geo.get());
|
| egf->setFlag(ExternalGeometryExtension::Defining, !egf->testFlag(ExternalGeometryExtension::Defining));
|
| this->ExternalGeo.set1Value(-GeoId - 1, std::move(geo));
|
| }
|
|
|
| solverNeedsUpdate = true;
|
| signalSolverUpdate();
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::setConstruction(int GeoId, bool on)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| Part::PropertyGeometryList *prop;
|
| int idx;
|
| if (GeoId >= 0) {
|
| prop = &Geometry;
|
| if (GeoId < Geometry.getSize())
|
| idx = GeoId;
|
| else
|
| return -1;
|
| }else if (GeoId <= GeoEnum::RefExt && -GeoId-1 < ExternalGeo.getSize()) {
|
| prop = &ExternalGeo;
|
| idx = -GeoId-1;
|
| }else
|
| return -1;
|
|
|
|
|
|
|
|
|
|
|
|
|
| std::unique_ptr<Part::Geometry> geo(prop->getValues()[idx]->clone());
|
| if(prop == &Geometry)
|
| GeometryFacade::setConstruction(geo.get(), on);
|
| else {
|
| auto egf = ExternalGeometryFacade::getFacade(geo.get());
|
| egf->setFlag(ExternalGeometryExtension::Defining, on);
|
| }
|
|
|
| prop->set1Value(idx,std::move(geo));
|
| solverNeedsUpdate = true;
|
| return 0;
|
| }
|
|
|
|
|
| int SketchObject::toggleExternalGeometryFlag(
|
| const std::vector<int>& geoIds,
|
| const std::vector<ExternalGeometryExtension::Flag>& flags
|
| )
|
| {
|
| if (flags.empty()) {
|
| return 0;
|
| }
|
| auto flag = flags.front();
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| bool update = false;
|
| bool touched = false;
|
| auto geos = ExternalGeo.getValues();
|
| std::set<int> idSet(geoIds.begin(), geoIds.end());
|
| for (auto geoId : geoIds) {
|
| if (geoId > GeoEnum::RefExt || -geoId - 1 >= ExternalGeo.getSize()) {
|
| continue;
|
| }
|
| if (!idSet.contains(geoId)) {
|
| continue;
|
| }
|
| idSet.erase(geoId);
|
| const int idx = -geoId - 1;
|
| auto& geo = geos[idx];
|
| const auto egf = ExternalGeometryFacade::getFacade(geo);
|
| const bool value = !egf->testFlag(flag);
|
| if (!egf->getRef().empty()) {
|
| for (auto relatedGeoId : getRelatedGeometry(geoId)) {
|
| if (relatedGeoId == geoId) {
|
| continue;
|
| }
|
| int relatedIndex = -relatedGeoId - 1;
|
| auto& relatedGeometry = geos[relatedIndex];
|
| relatedGeometry = relatedGeometry->clone();
|
| auto relatedFacade = ExternalGeometryFacade::getFacade(relatedGeometry);
|
| for (auto& _flag : flags) {
|
| relatedFacade->setFlag(_flag, value);
|
| }
|
| idSet.erase(relatedGeoId);
|
| }
|
| }
|
| geo = geo->clone();
|
| egf->setGeometry(geo);
|
| for (auto& _flag : flags) {
|
| egf->setFlag(_flag, value);
|
| }
|
| update = update || (value || flag != ExternalGeometryExtension::Frozen);
|
| touched = true;
|
| }
|
|
|
| if (!touched) {
|
| return -1;
|
| }
|
| ExternalGeo.setValues(geos);
|
| if (update) {
|
| rebuildExternalGeometry();
|
| }
|
| return 0;
|
| }
|
|
|
|
|
| void SketchObject::addGeometryState(const Constraint* cstr) const
|
| {
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| Sketcher::InternalType::InternalType constraintInternalAlignment = InternalType::None;
|
| bool constraintBlockedState = false;
|
|
|
| if (getInternalTypeState(cstr, constraintInternalAlignment)) {
|
| auto gf = GeometryFacade::getFacade(vals[cstr->First]);
|
| gf->setInternalType(constraintInternalAlignment);
|
| }
|
| else if (getBlockedState(cstr, constraintBlockedState)) {
|
| auto gf = GeometryFacade::getFacade(vals[cstr->First]);
|
| gf->setBlocked(constraintBlockedState);
|
| }
|
| }
|
|
|
| void SketchObject::removeGeometryState(const Constraint* cstr) const
|
| {
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
|
|
| if (cstr->Type == InternalAlignment) {
|
| auto gf = GeometryFacade::getFacade(vals[cstr->First]);
|
| gf->setInternalType(InternalType::None);
|
| }
|
|
|
|
|
| if (cstr->Type == Block) {
|
| auto gf = GeometryFacade::getFacade(vals[cstr->First]);
|
| gf->setBlocked(false);
|
| }
|
| }
|
|
|
|
|
| int SketchObject::addConstraints(const std::vector<Constraint*>& ConstraintList)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| std::vector<Constraint*> newVals(vals);
|
| newVals.insert(newVals.end(), ConstraintList.begin(), ConstraintList.end());
|
| for (std::size_t i = newVals.size() - ConstraintList.size(); i < newVals.size(); i++) {
|
| Constraint* cnew = newVals[i]->clone();
|
| newVals[i] = cnew;
|
|
|
| if (cnew->Type == Tangent || cnew->Type == Perpendicular) {
|
| AutoLockTangencyAndPerpty(cnew);
|
| }
|
|
|
| addGeometryState(cnew);
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| return this->Constraints.getSize() - 1;
|
| }
|
|
|
| int SketchObject::addCopyOfConstraints(const SketchObject& orig)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| const std::vector<Constraint*>& origvals = orig.Constraints.getValues();
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| newVals.reserve(vals.size() + origvals.size());
|
|
|
| for (auto& v : origvals)
|
| newVals.push_back(v->copy());
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| auto& uvals = this->Constraints.getValues();
|
|
|
| std::size_t uvalssize = uvals.size();
|
|
|
| for (std::size_t i = uvalssize, j = 0; i < uvals.size(); i++, j++) {
|
| if (uvals[i]->isDriving && uvals[i]->isDimensional()) {
|
|
|
| App::ObjectIdentifier spath = orig.Constraints.createPath(j);
|
|
|
| App::PropertyExpressionEngine::ExpressionInfo expr_info = orig.getExpression(spath);
|
|
|
| if (expr_info.expression) {
|
| App::ObjectIdentifier dpath = this->Constraints.createPath(i);
|
| setExpression(dpath,
|
| std::shared_ptr<App::Expression>(expr_info.expression->copy()));
|
| }
|
| }
|
| }
|
|
|
| if (noRecomputes)
|
| solve();
|
|
|
| return this->Constraints.getSize() - 1;
|
| }
|
|
|
| int SketchObject::addConstraint(const Constraint* constraint)
|
| {
|
| auto constraint_ptr = std::unique_ptr<Constraint>(constraint->clone());
|
|
|
| return addConstraint(std::move(constraint_ptr));
|
| }
|
|
|
| int SketchObject::addConstraint(std::unique_ptr<Constraint> constraint)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| Constraint* constNew = constraint.release();
|
|
|
| if (constNew->Type == Tangent || constNew->Type == Perpendicular)
|
| AutoLockTangencyAndPerpty(constNew);
|
|
|
| addGeometryState(constNew);
|
|
|
| newVals.push_back(constNew);
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| return this->Constraints.getSize() - 1;
|
| }
|
|
|
| int SketchObject::delConstraint(int ConstrId, DeleteOptions options)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
| if (ConstrId < 0 || ConstrId >= int(vals.size())) {
|
| return -1;
|
| }
|
|
|
| std::vector<Constraint*> newVals(vals);
|
| auto ctriter = newVals.begin() + ConstrId;
|
| removeGeometryState(*ctriter);
|
| newVals.erase(ctriter);
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoSolve)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::delConstraints(std::vector<int> ConstrIds, DeleteOptions options)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
| if (ConstrIds.empty()) {
|
| return 0;
|
| }
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| std::sort(ConstrIds.begin(), ConstrIds.end());
|
|
|
| if (ConstrIds.front() < 0 || ConstrIds.back() >= int(vals.size()))
|
| return -1;
|
|
|
| for (auto rit = ConstrIds.rbegin(); rit != ConstrIds.rend(); rit++) {
|
| auto ctriter = newVals.begin() + *rit;
|
| removeGeometryState(*ctriter);
|
| newVals.erase(ctriter);
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoSolve)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::delConstraintOnPoint(int VertexId, bool onlyCoincident)
|
| {
|
| int GeoId;
|
| PointPos PosId;
|
| if (VertexId == GeoEnum::RtPnt) {
|
| GeoId = Sketcher::GeoEnum::RtPnt;
|
| PosId = PointPos::start;
|
| }
|
| else
|
| getGeoVertexIndex(VertexId, GeoId, PosId);
|
|
|
| return delConstraintOnPoint(GeoId, PosId, onlyCoincident);
|
| }
|
|
|
|
|
| int SketchObject::delConstraintOnPoint(int geoId, PointPos posId, bool onlyCoincident)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
| std::vector<Constraint*> newVals;
|
| newVals.reserve(vals.size());
|
|
|
|
|
| int replaceGeoId = GeoEnum::GeoUndef;
|
| PointPos replacePosId = Sketcher::PointPos::none;
|
| auto findReplacement = [geoId, posId, &replaceGeoId, &replacePosId, &vals]() {
|
| auto it = std::ranges::find_if(vals, [geoId, posId](auto& constr) {
|
| return constr->Type == Sketcher::Coincident
|
| && constr->involvesGeoIdAndPosId(geoId, posId);
|
| });
|
|
|
| if (it == vals.end()) {
|
| return;
|
| }
|
|
|
| if ((*it)->First == geoId && (*it)->FirstPos == posId) {
|
| replaceGeoId = (*it)->Second;
|
| replacePosId = (*it)->SecondPos;
|
| }
|
| else {
|
| replaceGeoId = (*it)->First;
|
| replacePosId = (*it)->FirstPos;
|
| }
|
| };
|
|
|
| auto transferToReplacement =
|
| [&geoId, &posId, &replaceGeoId, &replacePosId](int& constrGeoId, PointPos& constrPosId) {
|
| if (replaceGeoId == GeoEnum::GeoUndef) {
|
| return false;
|
| }
|
| if (geoId != constrGeoId || posId != constrPosId) {
|
| return false;
|
| }
|
| constrGeoId = replaceGeoId;
|
| constrPosId = replacePosId;
|
| return true;
|
| };
|
|
|
| findReplacement();
|
|
|
| auto performCoincidenceChecksOrChanges = [&](auto& constr) -> bool {
|
| if (replaceGeoId == GeoEnum::GeoUndef) {
|
| return false;
|
| }
|
| if (constr->involvesGeoIdAndPosId(replaceGeoId, replacePosId)) {
|
| return false;
|
| }
|
|
|
| constr->substituteIndexAndPos(geoId, posId, replaceGeoId, replacePosId);
|
| return true;
|
| };
|
|
|
| auto performAllConstraintChecksOrChanges = [&](auto& constr) -> std::optional<bool> {
|
| if (constr->Type != Sketcher::Coincident && onlyCoincident) {
|
| return true;
|
| }
|
| switch (constr->Type) {
|
| case Sketcher::Coincident:
|
| return performCoincidenceChecksOrChanges(constr);
|
| case Sketcher::Distance:
|
| case Sketcher::DistanceX:
|
| case Sketcher::DistanceY: {
|
| return (
|
| transferToReplacement(constr->First, constr->FirstPos)
|
| || transferToReplacement(constr->Second, constr->SecondPos)
|
| );
|
| }
|
| case Sketcher::PointOnObject: {
|
| return transferToReplacement(constr->First, constr->FirstPos);
|
| }
|
| case Sketcher::Tangent:
|
| case Sketcher::Perpendicular: {
|
|
|
|
|
|
|
| return false;
|
| }
|
| case Sketcher::Vertical:
|
| case Sketcher::Horizontal:
|
| case Sketcher::Symmetric: {
|
| return false;
|
| }
|
| default:
|
| return std::nullopt;
|
| }
|
| };
|
|
|
|
|
| for (auto& constr : vals) {
|
|
|
| if (!constr->involvesGeoIdAndPosId(geoId, posId)) {
|
|
|
|
|
| const bool isOneOfDistanceTypes = constr->Type == Sketcher::Distance
|
| || constr->Type == Sketcher::DistanceX || constr->Type == Sketcher::DistanceY;
|
| const bool involvesEntireCurve = constr->First == geoId
|
| && constr->FirstPos == PointPos::none;
|
| const bool isPosAnEndpoint = posId == PointPos::start || posId == PointPos::end;
|
| if (isOneOfDistanceTypes && involvesEntireCurve && isPosAnEndpoint) {
|
| continue;
|
| }
|
| newVals.push_back(constr);
|
| continue;
|
| }
|
| if (performAllConstraintChecksOrChanges(constr).value_or(true)) {
|
| newVals.push_back(constr);
|
| }
|
| }
|
|
|
| if (newVals.size() < vals.size()) {
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| return 0;
|
| }
|
|
|
| return -1;
|
| }
|
|
|
|
|
| void SketchObject::transferFilletConstraints(int geoId1, PointPos posId1, int geoId2,
|
| PointPos posId2)
|
| {
|
|
|
|
|
|
|
|
|
| if (!arePointsCoincident(geoId1, posId1, geoId2, posId2)) {
|
|
|
| delConstraintOnPoint(geoId1, posId1, false);
|
| delConstraintOnPoint(geoId2, posId2, false);
|
|
|
|
|
| const std::vector<Constraint*>& constraints = this->Constraints.getValues();
|
| std::vector<int> deleteme;
|
| for (int i = 0; i < int(constraints.size()); i++) {
|
| const Constraint* c = constraints[i];
|
| if (c->Type != Sketcher::Distance && c->Type != Sketcher::Equal) {
|
| continue;
|
| }
|
| bool line1 = c->First == geoId1 && c->FirstPos == PointPos::none;
|
| bool line2 = c->First == geoId2 && c->FirstPos == PointPos::none;
|
| if (line1 || line2) {
|
| deleteme.push_back(i);
|
| }
|
| }
|
| delConstraints(std::move(deleteme), DeleteOption::NoFlag);
|
| return;
|
| }
|
|
|
|
|
|
|
| const Part::Geometry* geo1 = getGeometry(geoId1);
|
| const Part::Geometry* geo2 = getGeometry(geoId2);
|
| if (!geo1->is<Part::GeomLineSegment>() || !geo2->is<Part::GeomLineSegment>()) {
|
| delConstraintOnPoint(geoId1, posId1, false);
|
| delConstraintOnPoint(geoId2, posId2, false);
|
| return;
|
| }
|
|
|
|
|
| auto* originalCorner = new Part::GeomPoint(getPoint(geoId1, posId1));
|
| int originalCornerId = addGeometry(originalCorner, true);
|
| delete originalCorner;
|
|
|
|
|
| auto* cornerToLine1 = new Sketcher::Constraint();
|
| cornerToLine1->Type = Sketcher::PointOnObject;
|
| cornerToLine1->First = originalCornerId;
|
| cornerToLine1->FirstPos = PointPos::start;
|
| cornerToLine1->Second = geoId1;
|
| cornerToLine1->SecondPos = PointPos::none;
|
| addConstraint(cornerToLine1);
|
| delete cornerToLine1;
|
| auto* cornerToLine2 = new Sketcher::Constraint();
|
| cornerToLine2->Type = Sketcher::PointOnObject;
|
| cornerToLine2->First = originalCornerId;
|
| cornerToLine2->FirstPos = PointPos::start;
|
| cornerToLine2->Second = geoId2;
|
| cornerToLine2->SecondPos = PointPos::none;
|
| addConstraint(cornerToLine2);
|
| delete cornerToLine2;
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| std::vector<Constraint*> newConstraints;
|
| for (auto c : this->Constraints.getValues()) {
|
|
|
| bool point1First = c->First == geoId1 && c->FirstPos == posId1;
|
| bool point2First = c->First == geoId2 && c->FirstPos == posId2;
|
| bool point1Second = c->Second == geoId1 && c->SecondPos == posId1;
|
| bool point2Second = c->Second == geoId2 && c->SecondPos == posId2;
|
| bool point1Third = c->Third == geoId1 && c->ThirdPos == posId1;
|
| bool point2Third = c->Third == geoId2 && c->ThirdPos == posId2;
|
| bool line1First = c->First == geoId1 && c->FirstPos == PointPos::none;
|
| bool line2First = c->First == geoId2 && c->FirstPos == PointPos::none;
|
| bool line1Second = c->Second == geoId1 && c->SecondPos == PointPos::none;
|
| bool line2Second = c->Second == geoId2 && c->SecondPos == PointPos::none;
|
|
|
| if (c->Type == Sketcher::Coincident) {
|
| if ((point1First && point2Second) || (point2First && point1Second)) {
|
|
|
|
|
|
|
| continue;
|
| }
|
| }
|
| else if (c->Type == Sketcher::Horizontal || c->Type == Sketcher::Vertical) {
|
|
|
| }
|
| else if (c->Type == Sketcher::Distance || c->Type == Sketcher::DistanceX
|
| || c->Type == Sketcher::DistanceY) {
|
|
|
|
|
|
|
|
|
| if (line1First) {
|
| c->FirstPos = (posId1 == PointPos::start) ? PointPos::end : PointPos::start;
|
| c->Second = originalCornerId;
|
| c->SecondPos = PointPos::start;
|
| }
|
| if (line2First) {
|
| c->FirstPos = (posId2 == PointPos::start) ? PointPos::end : PointPos::start;
|
| c->Second = originalCornerId;
|
| c->SecondPos = PointPos::start;
|
| }
|
| }
|
| else if (c->Type == Sketcher::PointOnObject) {
|
|
|
| }
|
| else if (c->Type == Sketcher::Equal) {
|
|
|
|
|
| if (line1First || line2First || line1Second || line2Second) {
|
| continue;
|
| }
|
| }
|
| else if (c->Type == Sketcher::Symmetric) {
|
|
|
| }
|
| else if (c->Type == Sketcher::SnellsLaw) {
|
|
|
|
|
| continue;
|
| }
|
| else if (point1First || point2First || point1Second || point2Second || point1Third
|
| || point2Third) {
|
|
|
| continue;
|
| }
|
|
|
|
|
| if (point1First || point2First) {
|
| c->First = originalCornerId;
|
| c->FirstPos = PointPos::start;
|
| }
|
| else if (point1Second || point2Second) {
|
| c->Second = originalCornerId;
|
| c->SecondPos = PointPos::start;
|
| }
|
| else if (point1Third || point2Third) {
|
| c->Third = originalCornerId;
|
| c->ThirdPos = PointPos::start;
|
| }
|
|
|
|
|
| newConstraints.push_back(c->clone());
|
| }
|
| this->Constraints.setValues(std::move(newConstraints));
|
| }
|
|
|
|
|
| int SketchObject::transferConstraints(
|
| int fromGeoId,
|
| PointPos fromPosId,
|
| int toGeoId,
|
| PointPos toPosId,
|
| bool doNotTransformTangencies
|
| )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
| std::vector<Constraint*> newVals(vals);
|
| bool changed = false;
|
| for (int i = 0; i < int(newVals.size()); i++) {
|
| if (vals[i]->Type == Sketcher::InternalAlignment) {
|
|
|
|
|
| continue;
|
| }
|
| else if (vals[i]->involvesGeoIdAndPosId(fromGeoId, fromPosId)
|
| && !vals[i]->involvesGeoIdAndPosId(toGeoId, toPosId)) {
|
| std::unique_ptr<Constraint> constNew(newVals[i]->clone());
|
| constNew->substituteIndexAndPos(fromGeoId, fromPosId, toGeoId, toPosId);
|
| if (vals[i]->First < 0 && vals[i]->Second < 0) {
|
|
|
|
|
| continue;
|
| }
|
|
|
| switch (vals[i]->Type) {
|
| case Sketcher::Tangent:
|
| case Sketcher::Perpendicular: {
|
|
|
|
|
|
|
|
|
|
|
| if (!doNotTransformTangencies) {
|
| constNew->Type = Sketcher::Coincident;
|
| }
|
| break;
|
| }
|
| case Sketcher::Angle:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| continue;
|
| default:
|
| break;
|
| }
|
|
|
| Constraint* constPtr = constNew.release();
|
| newVals[i] = constPtr;
|
| changed = true;
|
| }
|
| }
|
|
|
|
|
| if (changed) {
|
| this->Constraints.setValues(std::move(newVals));
|
| }
|
| return 0;
|
| }
|
|
|
|
|
| std::vector<int> SketchObject::chooseFilletsEdges(const std::vector<int>& GeoIdList) const
|
| {
|
| if (GeoIdList.size() == 2) {
|
| return GeoIdList;
|
| }
|
|
|
| std::vector<int> dst;
|
| for (auto id : GeoIdList) {
|
| if (!GeometryFacade::getFacade(getGeometry(id))->getConstruction()) {
|
| dst.push_back(id);
|
|
|
| if (dst.size() > 2) {
|
| return {};
|
| }
|
| }
|
| }
|
| return dst;
|
| }
|
| int SketchObject::fillet(int GeoId, PointPos PosId, double radius, bool trim, bool createCorner, bool chamfer)
|
| {
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex())
|
| return -1;
|
|
|
|
|
| std::vector<int> GeoIdList;
|
| std::vector<PointPos> PosIdList;
|
| getDirectlyCoincidentPoints(GeoId, PosId, GeoIdList, PosIdList);
|
|
|
| GeoIdList = chooseFilletsEdges(GeoIdList);
|
|
|
|
|
| if (GeoIdList.size() != 2 || GeoIdList[0] < 0 || GeoIdList[1] < 0) {
|
| return -1;
|
| }
|
|
|
| const Part::Geometry* geo1 = getGeometry(GeoIdList[0]);
|
| const Part::Geometry* geo2 = getGeometry(GeoIdList[1]);
|
|
|
| if (geo1->is<Part::GeomLineSegment>()
|
| && geo2->is<Part::GeomLineSegment>()) {
|
| auto* lineSeg1 = static_cast<const Part::GeomLineSegment*>(geo1);
|
| auto* lineSeg2 = static_cast<const Part::GeomLineSegment*>(geo2);
|
|
|
| Base::Vector3d midPnt1 = (lineSeg1->getStartPoint() + lineSeg1->getEndPoint()) / 2;
|
| Base::Vector3d midPnt2 = (lineSeg2->getStartPoint() + lineSeg2->getEndPoint()) / 2;
|
| return fillet(GeoIdList[0], GeoIdList[1], midPnt1, midPnt2, radius, trim, createCorner, chamfer);
|
| }
|
|
|
| return -1;
|
| }
|
|
|
| int SketchObject::fillet(int GeoId1, int GeoId2, const Base::Vector3d& refPnt1,
|
| const Base::Vector3d& refPnt2, double radius, bool trim, bool createCorner, bool chamfer)
|
| {
|
| if (GeoId1 < 0 || GeoId1 > getHighestCurveIndex() || GeoId2 < 0 || GeoId2 > getHighestCurveIndex()) {
|
| return -1;
|
| }
|
|
|
|
|
| const Part::Geometry* geo1 = getGeometry(GeoId1);
|
| const Part::Geometry* geo2 = getGeometry(GeoId2);
|
| if (trim && (GeometryFacade::getBlocked(geo1) || GeometryFacade::getBlocked(geo2))) {
|
| trim = false;
|
| }
|
|
|
| int pos1 = 0;
|
| int pos2 = 0;
|
| bool reverse = false;
|
| std::unique_ptr<Part::GeomArcOfCircle> arc(createFilletGeometry(geo1, geo2, refPnt1, refPnt2, radius, pos1, pos2, reverse));
|
| if (!arc) {
|
| return -1;
|
| }
|
|
|
| int filletId = addGeometry(arc.get());
|
| if (filletId < 0) {
|
| return -1;
|
| }
|
|
|
| PointPos PosId1 = static_cast<PointPos>(pos1);
|
| PointPos PosId2= static_cast<PointPos>(pos2);
|
| PointPos filletPosId1 = PointPos::none;
|
| PointPos filletPosId2 = PointPos::none;
|
|
|
| Base::Vector3d p1 = arc->getStartPoint(true);
|
| Base::Vector3d p2 = arc->getEndPoint(true);
|
|
|
| if (trim) {
|
| if (createCorner && geo1->is<Part::GeomLineSegment>() && geo2->is<Part::GeomLineSegment>()) {
|
| transferFilletConstraints(GeoId1, PosId1, GeoId2, PosId2);
|
| }
|
| else {
|
| delConstraintOnPoint(GeoId1, PosId1, false);
|
| delConstraintOnPoint(GeoId2, PosId2, false);
|
| }
|
|
|
| if (reverse) {
|
| filletPosId1 = PointPos::start;
|
| filletPosId2 = PointPos::end;
|
| moveGeometry(GeoId1, PosId1, p1, false, true);
|
| moveGeometry(GeoId2, PosId2, p2, false, true);
|
| }
|
| else {
|
| filletPosId1 = PointPos::end;
|
| filletPosId2 = PointPos::start;
|
| moveGeometry(GeoId1, PosId1, p2, false, true);
|
| moveGeometry(GeoId2, PosId2, p1, false, true);
|
| }
|
|
|
| auto tangent1 = std::make_unique<Sketcher::Constraint>();
|
| auto tangent2 = std::make_unique<Sketcher::Constraint>();
|
|
|
| tangent1->Type = Sketcher::Tangent;
|
| tangent1->First = GeoId1;
|
| tangent1->FirstPos = PosId1;
|
| tangent1->Second = filletId;
|
| tangent1->SecondPos = filletPosId1;
|
|
|
| tangent2->Type = Sketcher::Tangent;
|
| tangent2->First = GeoId2;
|
| tangent2->FirstPos = PosId2;
|
| tangent2->Second = filletId;
|
| tangent2->SecondPos = filletPosId2;
|
|
|
| addConstraint(std::move(tangent1));
|
| addConstraint(std::move(tangent2));
|
| }
|
|
|
| if (chamfer) {
|
| auto line = std::make_unique<Part::GeomLineSegment>();
|
| line->setPoints(p1, p2);
|
| int lineGeoId = addGeometry(line.get());
|
|
|
|
|
| auto coinc1 = std::make_unique<Sketcher::Constraint>();
|
| auto coinc2 = std::make_unique<Sketcher::Constraint>();
|
|
|
| coinc1->Type = Sketcher::Coincident;
|
| coinc1->First = lineGeoId;
|
| coinc1->FirstPos = filletPosId1;
|
|
|
| coinc2->Type = Sketcher::Coincident;
|
| coinc2->First = lineGeoId;
|
| coinc2->FirstPos = filletPosId2;
|
|
|
| if (trim) {
|
| coinc1->Second = GeoId1;
|
| coinc1->SecondPos = PosId1;
|
| coinc2->Second = GeoId2;
|
| coinc2->SecondPos = PosId2;
|
| }
|
| else {
|
| coinc1->Second = filletId;
|
| coinc1->SecondPos = PointPos::start;
|
| coinc2->Second = filletId;
|
| coinc2->SecondPos = PointPos::end;
|
| }
|
|
|
| addConstraint(std::move(coinc1));
|
| addConstraint(std::move(coinc2));
|
|
|
| setConstruction(filletId, true);
|
| }
|
|
|
|
|
|
|
| if (noRecomputes) {
|
| solve();
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::extend(int GeoId, double increment, PointPos endpoint)
|
| {
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex())
|
| return -1;
|
|
|
| const std::vector<Part::Geometry*>& geomList = getInternalGeometry();
|
| Part::Geometry* geom = geomList[GeoId];
|
| int retcode = -1;
|
| if (geom->is<Part::GeomLineSegment>()) {
|
| auto* seg = static_cast<Part::GeomLineSegment*>(geom);
|
| Base::Vector3d startVec = seg->getStartPoint();
|
| Base::Vector3d endVec = seg->getEndPoint();
|
| if (endpoint == PointPos::start) {
|
| Base::Vector3d newPoint = startVec - endVec;
|
| double scaleFactor = newPoint.Length() + increment;
|
| newPoint.Normalize();
|
| newPoint.Scale(scaleFactor, scaleFactor, scaleFactor);
|
| newPoint = newPoint + endVec;
|
| retcode = moveGeometry(GeoId, Sketcher::PointPos::start, newPoint, false, true);
|
| }
|
| else if (endpoint == PointPos::end) {
|
| Base::Vector3d newPoint = endVec - startVec;
|
| double scaleFactor = newPoint.Length() + increment;
|
| newPoint.Normalize();
|
| newPoint.Scale(scaleFactor, scaleFactor, scaleFactor);
|
| newPoint = newPoint + startVec;
|
| retcode = moveGeometry(GeoId, Sketcher::PointPos::end, newPoint, false, true);
|
| }
|
| }
|
| else if (geom->is<Part::GeomArcOfCircle>()) {
|
| auto* arc = static_cast<Part::GeomArcOfCircle*>(geom);
|
| double startArc, endArc;
|
| arc->getRange(startArc, endArc, true);
|
| if (endpoint == PointPos::start) {
|
| arc->setRange(startArc - increment, endArc, true);
|
| retcode = 0;
|
| }
|
| else if (endpoint == PointPos::end) {
|
| arc->setRange(startArc, endArc + increment, true);
|
| retcode = 0;
|
| }
|
| }
|
| if (retcode == 0 && noRecomputes) {
|
| solve();
|
| }
|
| return retcode;
|
| }
|
|
|
| std::unique_ptr<Constraint> SketchObject::createConstraint(
|
| Sketcher::ConstraintType constrType, int firstGeoId, Sketcher::PointPos firstPos,
|
| int secondGeoId, Sketcher::PointPos secondPos, int thirdGeoId, Sketcher::PointPos thirdPos)
|
| {
|
| auto newConstr = std::make_unique<Sketcher::Constraint>();
|
|
|
| newConstr->Type = constrType;
|
| newConstr->First = firstGeoId;
|
| newConstr->FirstPos = firstPos;
|
| newConstr->Second = secondGeoId;
|
| newConstr->SecondPos = secondPos;
|
| newConstr->Third = thirdGeoId;
|
| newConstr->ThirdPos = thirdPos;
|
| return newConstr;
|
| }
|
|
|
| void SketchObject::addConstraint(Sketcher::ConstraintType constrType, int firstGeoId,
|
| Sketcher::PointPos firstPos, int secondGeoId,
|
| Sketcher::PointPos secondPos, int thirdGeoId,
|
| Sketcher::PointPos thirdPos)
|
| {
|
| auto newConstr = createConstraint(
|
| constrType, firstGeoId, firstPos, secondGeoId, secondPos, thirdGeoId, thirdPos);
|
|
|
| this->addConstraint(std::move(newConstr));
|
| }
|
|
|
| std::unique_ptr<Constraint>
|
| SketchObject::getConstraintAfterDeletingGeo(const Constraint* constr,
|
| const int deletedGeoId) const
|
| {
|
| if (!constr) {
|
| return nullptr;
|
| }
|
|
|
|
|
| auto newConstr = std::unique_ptr<Constraint>(constr->clone());
|
|
|
| changeConstraintAfterDeletingGeo(newConstr.get(), deletedGeoId);
|
|
|
| if (newConstr->Type == ConstraintType::None) {
|
| return nullptr;
|
| }
|
|
|
| return newConstr;
|
| }
|
|
|
| void SketchObject::changeConstraintAfterDeletingGeo(Constraint* constr,
|
| const int deletedGeoId) const
|
| {
|
| if (!constr) {
|
| return;
|
| }
|
|
|
| if (constr->involvesGeoId(deletedGeoId)) {
|
| constr->Type = ConstraintType::None;
|
| return;
|
| }
|
|
|
| int step = 1;
|
| std::function<bool (const int&)> needsUpdate = [&deletedGeoId](const int& givenId) -> bool {
|
| return givenId > deletedGeoId;
|
| };
|
| if (deletedGeoId < 0) {
|
| step = -1;
|
| needsUpdate = [&deletedGeoId](const int& givenId) -> bool {
|
| return givenId < deletedGeoId && givenId != GeoEnum::GeoUndef;
|
| };
|
| }
|
|
|
| if (needsUpdate(constr->First)) {
|
| constr->First -= step;
|
| }
|
| if (needsUpdate(constr->Second)) {
|
| constr->Second -= step;
|
| }
|
| if (needsUpdate(constr->Third)) {
|
| constr->Third -= step;
|
| }
|
| }
|
|
|
|
|
| bool SketchObject::seekTrimPoints(
|
| int GeoId,
|
| const Base::Vector3d& point,
|
| int& GeoId1,
|
| Base::Vector3d& intersect1,
|
| int& GeoId2,
|
| Base::Vector3d& intersect2
|
| )
|
| {
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex()) {
|
| return false;
|
| }
|
|
|
| auto geos = getCompleteGeometry();
|
|
|
| geos.resize(geos.size() - 2);
|
|
|
| int localindex1, localindex2;
|
|
|
|
|
|
|
| if (!Part2DObject::seekTrimPoints(geos, GeoId, point, localindex1, intersect1, localindex2, intersect2)) {
|
| return false;
|
| }
|
|
|
|
|
| GeoId1 = getGeoIdFromCompleteGeometryIndex(localindex1);
|
| GeoId2 = getGeoIdFromCompleteGeometryIndex(localindex2);
|
|
|
| return true;
|
| }
|
|
|
|
|
|
|
|
|
| bool getIntersectionParameter(const Part::Geometry* geo, const Base::Vector3d point, double& pointParam)
|
| {
|
| const auto* curve = static_cast<const Part::GeomCurve*>(geo);
|
|
|
| try {
|
| curve->closestParameter(point, pointParam);
|
| }
|
| catch (Base::CADKernelError& e) {
|
| e.reportException();
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| bool arePointsWithinPrecision(const Base::Vector3d& point1, const Base::Vector3d& point2)
|
| {
|
|
|
|
|
| return ((point1 - point2).Length() < 500 * Precision::Confusion());
|
| }
|
|
|
| bool areParamsWithinApproximation(double param1, double param2)
|
| {
|
|
|
|
|
| return (std::abs(param1 - param2) < Precision::PApproximation());
|
| }
|
|
|
|
|
|
|
| bool isPointAtPosition(const SketchObject* obj, int GeoId1, PointPos pos1, const Base::Vector3d& point)
|
| {
|
| Base::Vector3d pp = obj->getPoint(GeoId1, pos1);
|
|
|
| return arePointsWithinPrecision(point, pp);
|
| }
|
|
|
|
|
|
|
|
|
|
|
| std::unique_ptr<Constraint> transformPreexistingConstraintForTrim(
|
| const SketchObject* obj,
|
| const Constraint* constr,
|
| int GeoId,
|
| int cuttingGeoId,
|
| const Base::Vector3d& cutPointVec,
|
| int newGeoId,
|
| PointPos newPosId
|
| )
|
| {
|
| |
| |
| |
| |
| |
|
|
|
|
| std::unique_ptr<Constraint> newConstr;
|
| if (cuttingGeoId == GeoEnum::GeoUndef || !constr->involvesGeoId(cuttingGeoId)
|
| || !constr->involvesGeoIdAndPosId(GeoId, PointPos::none)) {
|
| return newConstr;
|
| }
|
| switch (constr->Type) {
|
| case PointOnObject: {
|
|
|
|
|
|
|
| if (isPointAtPosition(obj, constr->First, constr->FirstPos, cutPointVec)) {
|
|
|
| newConstr.reset(constr->copy());
|
| newConstr->Type = Sketcher::Coincident;
|
| newConstr->Second = newGeoId;
|
| newConstr->SecondPos = newPosId;
|
| }
|
| break;
|
| }
|
| case Tangent:
|
| case Perpendicular: {
|
|
|
|
|
|
|
| newConstr.reset(constr->copy());
|
| newConstr->substituteIndexAndPos(GeoId, PointPos::none, newGeoId, newPosId);
|
|
|
| if (newConstr->FirstPos == PointPos::none) {
|
| std::swap(newConstr->First, newConstr->Second);
|
| std::swap(newConstr->FirstPos, newConstr->SecondPos);
|
| }
|
|
|
| newConstr->Third = GeoEnum::GeoUndef;
|
| newConstr->ThirdPos = PointPos::none;
|
| break;
|
| }
|
| default:
|
| break;
|
| }
|
| return newConstr;
|
| }
|
|
|
| std::unique_ptr<Constraint> getNewConstraintAtTrimCut(
|
| const SketchObject* obj,
|
| int cuttingGeoId,
|
| int cutGeoId,
|
| PointPos cutPosId,
|
| const Base::Vector3d& cutPointVec
|
| )
|
| {
|
| auto newConstr = std::make_unique<Sketcher::Constraint>();
|
| newConstr->First = cutGeoId;
|
| newConstr->FirstPos = cutPosId;
|
| newConstr->Second = cuttingGeoId;
|
| if (isPointAtPosition(obj, cuttingGeoId, PointPos::start, cutPointVec)) {
|
| newConstr->Type = Sketcher::Coincident;
|
| newConstr->SecondPos = PointPos::start;
|
| }
|
| else if (isPointAtPosition(obj, cuttingGeoId, PointPos::end, cutPointVec)) {
|
| newConstr->Type = Sketcher::Coincident;
|
| newConstr->SecondPos = PointPos::end;
|
| }
|
| else {
|
|
|
| newConstr->Type = Sketcher::PointOnObject;
|
| newConstr->SecondPos = PointPos::none;
|
| }
|
| return newConstr;
|
| }
|
|
|
| bool isGeoIdAllowedForTrim(const SketchObject* obj, int GeoId)
|
| {
|
| const auto* geo = obj->getGeometry(GeoId);
|
|
|
| return GeoId >= 0 && GeoId <= obj->getHighestCurveIndex()
|
| && GeometryFacade::isInternalType(geo, InternalType::None);
|
| }
|
|
|
| bool getParamLimitsOfNewGeosForTrim(
|
| const SketchObject* obj,
|
| int GeoId,
|
| std::array<int, 2>& cuttingGeoIds,
|
| std::array<Base::Vector3d, 2>& cutPoints,
|
| std::vector<std::pair<double, double>>& paramsOfNewGeos
|
| )
|
| {
|
| const auto* geoAsCurve = obj->getGeometry<Part::GeomCurve>(GeoId);
|
| double firstParam = geoAsCurve->getFirstParameter();
|
| double lastParam = geoAsCurve->getLastParameter();
|
| double cut0Param {firstParam}, cut1Param {lastParam};
|
|
|
| bool allParamsFound = getIntersectionParameter(geoAsCurve, cutPoints[0], cut0Param)
|
| && getIntersectionParameter(geoAsCurve, cutPoints[1], cut1Param);
|
| if (!allParamsFound) {
|
| return false;
|
| }
|
|
|
| if (!obj->isClosedCurve(geoAsCurve) && areParamsWithinApproximation(firstParam, cut0Param)) {
|
| cuttingGeoIds[0] = GeoEnum::GeoUndef;
|
| }
|
|
|
| if (!obj->isClosedCurve(geoAsCurve) && areParamsWithinApproximation(lastParam, cut1Param)) {
|
| cuttingGeoIds[1] = GeoEnum::GeoUndef;
|
| }
|
|
|
| size_t numUndefs = std::count(cuttingGeoIds.begin(), cuttingGeoIds.end(), GeoEnum::GeoUndef);
|
|
|
| if (numUndefs == 0 && arePointsWithinPrecision(cutPoints[0], cutPoints[1])) {
|
|
|
| paramsOfNewGeos.clear();
|
| return true;
|
| }
|
|
|
| paramsOfNewGeos.assign(2 - numUndefs, {firstParam, lastParam});
|
|
|
| if (paramsOfNewGeos.empty()) {
|
| return true;
|
| }
|
|
|
| if (obj->isClosedCurve(geoAsCurve)) {
|
| paramsOfNewGeos.pop_back();
|
| }
|
|
|
| if (cuttingGeoIds[0] != GeoEnum::GeoUndef) {
|
| paramsOfNewGeos.front().second = cut0Param;
|
| }
|
| if (cuttingGeoIds[1] != GeoEnum::GeoUndef) {
|
| paramsOfNewGeos.back().first = cut1Param;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| void createArcsFromGeoWithLimits(
|
| const Part::GeomCurve* geo,
|
| const std::vector<std::pair<double, double>>& paramsOfNewGeos,
|
| std::vector<Part::Geometry*>& newGeos
|
| )
|
| {
|
| for (auto& [u1, u2] : paramsOfNewGeos) {
|
| auto newGeo = static_cast<const Part::GeomCurve*>(geo)->createArc(u1, u2);
|
| assert(newGeo);
|
| newGeos.emplace_back(newGeo);
|
| }
|
| }
|
|
|
| void createNewConstraintsForTrim(
|
| const SketchObject* obj,
|
| const int GeoId,
|
| const std::array<int, 2>& cuttingGeoIds,
|
| const std::array<Base::Vector3d, 2>& cutPoints,
|
| const std::vector<int>& newIds,
|
| const std::vector<const Part::Geometry*> newGeos,
|
| std::vector<int>& idsOfOldConstraints,
|
| std::vector<Constraint*>& newConstraints,
|
| std::set<int, std::greater<>>& geoIdsToBeDeleted
|
| )
|
| {
|
| const auto& allConstraints = obj->Constraints.getValues();
|
|
|
| bool isPoint1ConstrainedOnGeoId1 = false;
|
| bool isPoint2ConstrainedOnGeoId2 = false;
|
|
|
| for (const auto& oldConstrId : idsOfOldConstraints) {
|
|
|
| const Constraint* con = allConstraints[oldConstrId];
|
| if (con->Type == InternalAlignment) {
|
| geoIdsToBeDeleted.insert(con->First);
|
| continue;
|
| }
|
| if (auto newConstr = transformPreexistingConstraintForTrim(
|
| obj,
|
| con,
|
| GeoId,
|
| cuttingGeoIds[0],
|
| cutPoints[0],
|
| newIds.front(),
|
| PointPos::end
|
| )) {
|
| newConstraints.push_back(newConstr.release());
|
| isPoint1ConstrainedOnGeoId1 = true;
|
| continue;
|
| }
|
| if (auto newConstr = transformPreexistingConstraintForTrim(
|
| obj,
|
| con,
|
| GeoId,
|
| cuttingGeoIds[1],
|
| cutPoints[1],
|
| newIds.back(),
|
| PointPos::start
|
| )) {
|
| newConstraints.push_back(newConstr.release());
|
| isPoint2ConstrainedOnGeoId2 = true;
|
| continue;
|
| }
|
|
|
|
|
| if (!(con->Type == Angle || con->involvesGeoIdAndPosId(GeoId, PointPos::none))) {
|
| continue;
|
| }
|
|
|
| obj->deriveConstraintsForPieces(GeoId, newIds, newGeos, con, newConstraints);
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (cuttingGeoIds[0] != GeoEnum::GeoUndef && !isPoint1ConstrainedOnGeoId1) {
|
| newConstraints.emplace_back(
|
| getNewConstraintAtTrimCut(obj, cuttingGeoIds[0], newIds.front(), PointPos::end, cutPoints[0])
|
| .release()
|
| );
|
| }
|
|
|
| if (cuttingGeoIds[1] != GeoEnum::GeoUndef && !isPoint2ConstrainedOnGeoId2) {
|
| newConstraints.emplace_back(
|
| getNewConstraintAtTrimCut(obj, cuttingGeoIds[1], newIds.back(), PointPos::start, cutPoints[1])
|
| .release()
|
| );
|
| }
|
| }
|
|
|
| std::optional<size_t> findPieceContainingPoint(
|
| const SketchObject* obj,
|
| const Part::Geometry* geo,
|
| const Base::Vector3d& point,
|
| const std::vector<int>& newIds,
|
| const std::vector<const Part::Geometry*>& newGeos
|
| )
|
| {
|
| double conParam;
|
| auto* geoAsCurve = static_cast<const Part::GeomCurve*>(geo);
|
| geoAsCurve->closestParameter(point, conParam);
|
|
|
|
|
| for (size_t i = 0; i < newIds.size(); ++i) {
|
| double newGeoFirstParam = static_cast<const Part::GeomCurve*>(newGeos[i])->getFirstParameter();
|
| double newGeoLastParam = static_cast<const Part::GeomCurve*>(newGeos[i])->getLastParameter();
|
|
|
| if ((newGeoFirstParam - conParam) > Precision::PApproximation() && obj->isClosedCurve(geo)) {
|
| conParam += (geoAsCurve->getLastParameter() - geoAsCurve->getFirstParameter());
|
| }
|
| if ((newGeoFirstParam - conParam) <= Precision::PApproximation()
|
| && (conParam - newGeoLastParam) <= Precision::PApproximation()) {
|
| return i;
|
| }
|
| }
|
| return std::nullopt;
|
| }
|
|
|
| int SketchObject::trim(int GeoId, const Base::Vector3d& point)
|
| {
|
| if (!isGeoIdAllowedForTrim(this, GeoId)) {
|
| return -1;
|
| }
|
|
|
|
|
|
|
| const auto* geoAsCurve = getGeometry<Part::GeomCurve>(GeoId);
|
|
|
| if (geoAsCurve == nullptr) {
|
| return -1;
|
| }
|
|
|
| bool isOriginalCurveConstruction = GeometryFacade::getConstruction(geoAsCurve);
|
| bool isOriginalCurvePeriodic = isClosedCurve(geoAsCurve);
|
|
|
|
|
|
|
|
|
| std::array<int, 2> cuttingGeoIds {GeoEnum::GeoUndef, GeoEnum::GeoUndef};
|
|
|
| std::array<Base::Vector3d, 2> cutPoints;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (!SketchObject::seekTrimPoints(
|
| GeoId,
|
| point,
|
| cuttingGeoIds[0],
|
| cutPoints[0],
|
| cuttingGeoIds[1],
|
| cutPoints[1]
|
| )) {
|
|
|
| delGeometry(GeoId);
|
| return 0;
|
| }
|
|
|
|
|
| std::vector<std::pair<double, double>> paramsOfNewGeos;
|
| paramsOfNewGeos.reserve(2);
|
| if (!getParamLimitsOfNewGeosForTrim(this, GeoId, cuttingGeoIds, cutPoints, paramsOfNewGeos)) {
|
| return -1;
|
| }
|
|
|
|
|
|
|
| std::vector<int> newIds;
|
| std::vector<Part::Geometry*> newGeos;
|
| std::vector<const Part::Geometry*> newGeosAsConsts;
|
|
|
| switch (paramsOfNewGeos.size()) {
|
| case 0: {
|
| delGeometry(GeoId);
|
| return 0;
|
| }
|
| case 1: {
|
| newIds.push_back(GeoId);
|
| break;
|
| }
|
| case 2: {
|
| newIds.push_back(GeoId);
|
| newIds.push_back(getHighestCurveIndex() + 1);
|
| break;
|
| }
|
| default: {
|
| return -1;
|
| }
|
| }
|
|
|
| createArcsFromGeoWithLimits(geoAsCurve, paramsOfNewGeos, newGeos);
|
| for (const auto* geo : newGeos) {
|
| newGeosAsConsts.push_back(geo);
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| const auto& allConstraints = this->Constraints.getValues();
|
| std::vector<Constraint*> newConstraints;
|
| std::vector<int> idsOfOldConstraints;
|
| std::set<int, std::greater<>> geoIdsToBeDeleted;
|
| getConstraintIndices(GeoId, idsOfOldConstraints);
|
|
|
|
|
| if (!isOriginalCurvePeriodic) {
|
| std::erase_if(idsOfOldConstraints, [&GeoId, &allConstraints, &cuttingGeoIds](const auto& i) {
|
| auto* constr = allConstraints[i];
|
| bool involvesStart = constr->involvesGeoIdAndPosId(GeoId, PointPos::start);
|
| bool involvesEnd = constr->involvesGeoIdAndPosId(GeoId, PointPos::end);
|
| bool keepStart = cuttingGeoIds[0] != GeoEnum::GeoUndef;
|
| bool keepEnd = cuttingGeoIds[1] != GeoEnum::GeoUndef;
|
| bool involvesBothButNotBothKept = involvesStart && involvesEnd && !(keepStart && keepEnd);
|
| return !involvesBothButNotBothKept
|
| && ((involvesStart && keepStart) || (involvesEnd && keepEnd));
|
| });
|
| }
|
| std::erase_if(idsOfOldConstraints, [&GeoId, &allConstraints](const auto& i) {
|
| return (allConstraints[i]->involvesGeoIdAndPosId(GeoId, PointPos::mid));
|
| });
|
|
|
| createNewConstraintsForTrim(
|
| this,
|
| GeoId,
|
| cuttingGeoIds,
|
| cutPoints,
|
| newIds,
|
| newGeosAsConsts,
|
| idsOfOldConstraints,
|
| newConstraints,
|
| geoIdsToBeDeleted
|
| );
|
|
|
|
|
|
|
|
|
|
|
| [[maybe_unused]] auto constrainAsEqual = [this](int GeoId1, int GeoId2) {
|
| auto newConstr = std::make_unique<Sketcher::Constraint>();
|
|
|
|
|
| newConstr->Type = Sketcher::Equal;
|
| newConstr->First = GeoId1;
|
| newConstr->FirstPos = Sketcher::PointPos::none;
|
| newConstr->Second = GeoId2;
|
| newConstr->SecondPos = Sketcher::PointPos::none;
|
| addConstraint(std::move(newConstr));
|
| };
|
|
|
| delConstraints(std::move(idsOfOldConstraints), DeleteOption::NoFlag);
|
|
|
| if (!isOriginalCurvePeriodic) {
|
| transferConstraints(GeoId, PointPos::start, newIds.front(), PointPos::start, true);
|
| transferConstraints(GeoId, PointPos::end, newIds.back(), PointPos::end, true);
|
| }
|
| bool geomHasMid = geoAsCurve->isDerivedFrom<Part::GeomConic>()
|
| || geoAsCurve->isDerivedFrom<Part::GeomArcOfConic>();
|
| if (geomHasMid) {
|
| transferConstraints(GeoId, PointPos::mid, newIds.front(), PointPos::mid, true);
|
|
|
| if (newIds.size() > 1) {
|
| auto* joint = new Constraint();
|
| joint->Type = Coincident;
|
| joint->First = newIds.front();
|
| joint->FirstPos = PointPos::mid;
|
| joint->Second = newIds.back();
|
| joint->SecondPos = PointPos::mid;
|
| newConstraints.push_back(joint);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| }
|
| }
|
|
|
| replaceGeometries({GeoId}, newGeos);
|
| for (auto newId : newIds) {
|
| setConstruction(newId, isOriginalCurveConstruction);
|
| }
|
|
|
| if (noRecomputes) {
|
| solve();
|
| }
|
|
|
| for (auto& deletedGeoId : geoIdsToBeDeleted) {
|
| for (auto& cons : newConstraints) {
|
| changeConstraintAfterDeletingGeo(cons, deletedGeoId);
|
| }
|
| }
|
| std::erase_if(newConstraints, [](const auto& constr) {
|
| return constr->Type == ConstraintType::None;
|
| });
|
| delGeometries(geoIdsToBeDeleted.begin(), geoIdsToBeDeleted.end());
|
| addConstraints(newConstraints);
|
|
|
| if (noRecomputes) {
|
| solve();
|
| }
|
|
|
|
|
|
|
|
|
|
|
| for (auto& cons : newConstraints) {
|
| delete cons;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| bool SketchObject::deriveConstraintsForPieces(
|
| const int oldId,
|
| const std::vector<int>& newIds,
|
| const Constraint* con,
|
| std::vector<Constraint*>& newConstraints
|
| ) const
|
| {
|
| std::vector<const Part::Geometry*> newGeos;
|
| for (auto& newId : newIds) {
|
| newGeos.push_back(getGeometry(newId));
|
| }
|
|
|
| return deriveConstraintsForPieces(oldId, newIds, newGeos, con, newConstraints);
|
| }
|
|
|
| bool SketchObject::deriveConstraintsForPieces(
|
| const int oldId,
|
| const std::vector<int>& newIds,
|
| const std::vector<const Part::Geometry*>& newGeos,
|
| const Constraint* con,
|
| std::vector<Constraint*>& newConstraints
|
| ) const
|
| {
|
| const Part::Geometry* geo = getGeometry(oldId);
|
| int conId = con->First;
|
| PointPos conPos = con->FirstPos;
|
| if (conId == oldId) {
|
| conId = con->Second;
|
| conPos = con->SecondPos;
|
| }
|
|
|
| bool newGeosLikelyNotCreated = std::ranges::find(newGeos, nullptr) != newGeos.end();
|
|
|
| bool transferToAll = false;
|
| switch (con->Type) {
|
| case Horizontal:
|
| case Vertical:
|
| case Parallel: {
|
| transferToAll = geo->is<Part::GeomLineSegment>();
|
| } break;
|
| case Tangent:
|
| case Perpendicular: {
|
| if (geo->is<Part::GeomLineSegment>()) {
|
| transferToAll = true;
|
| break;
|
| }
|
|
|
| const Part::Geometry* conGeo = getGeometry(conId);
|
| if (!(conGeo && conGeo->isDerivedFrom<Part::GeomCurve>())) {
|
| return false;
|
| }
|
|
|
|
|
| if (newGeosLikelyNotCreated) {
|
| break;
|
| }
|
|
|
|
|
|
|
|
|
| for (size_t i = 0; i < newIds.size(); ++i) {
|
| std::vector<std::pair<Base::Vector3d, Base::Vector3d>> intersections;
|
| bool intersects
|
| = static_cast<const Part::GeomCurve*>(newGeos[i])
|
| ->intersect(static_cast<const Part::GeomCurve*>(conGeo), intersections);
|
|
|
| if (intersects) {
|
| Constraint* trans = con->copy();
|
| trans->substituteIndex(oldId, newIds[i]);
|
| newConstraints.push_back(trans);
|
| return true;
|
| }
|
| }
|
| } break;
|
| case Angle: {
|
| const auto [thirdGeo, thirdPos] = con->getElement(2);
|
| if (thirdGeo == oldId) {
|
|
|
|
|
| std::vector<int> GeoIdList;
|
| std::vector<PointPos> PosIdList;
|
| getDirectlyCoincidentPoints(thirdGeo, thirdPos, GeoIdList, PosIdList);
|
| if (GeoIdList.size() <= 1) {
|
|
|
| return false;
|
| }
|
|
|
|
|
| Base::Vector3d point(getPoint(thirdGeo, thirdPos));
|
| std::optional<size_t> idx = findPieceContainingPoint(this, geo, point, newIds, newGeos);
|
|
|
| if (idx.has_value()) {
|
| Constraint* trans = con->copy();
|
| trans->substituteIndexAndPos(GeoIdList[0], PosIdList[0], GeoIdList[1], PosIdList[1]);
|
| trans->substituteIndex(oldId, newIds[idx.value()]);
|
| newConstraints.push_back(trans);
|
| return true;
|
| }
|
| }
|
| else if (thirdGeo != GeoEnum::GeoUndef) {
|
|
|
|
|
| Base::Vector3d point(getPoint(thirdGeo, thirdPos));
|
| std::optional<size_t> idx = findPieceContainingPoint(this, geo, point, newIds, newGeos);
|
|
|
| if (idx.has_value()) {
|
| Constraint* trans = con->copy();
|
| trans->substituteIndex(oldId, newIds[idx.value()]);
|
| newConstraints.push_back(trans);
|
| return true;
|
| }
|
| break;
|
| }
|
| else if (std::ranges::any_of(newGeos, [](const Part::Geometry* geo) {
|
| return !geo->is<Part::GeomLineSegment>();
|
| })) {
|
|
|
|
|
|
|
|
|
|
|
|
|
| return false;
|
| }
|
| else {
|
|
|
| transferToAll = true;
|
| break;
|
| }
|
| } break;
|
| case Distance:
|
| case DistanceX:
|
| case DistanceY:
|
| case PointOnObject: {
|
| if (con->FirstPos == PointPos::none && con->SecondPos == PointPos::none
|
| && newIds.size() > 1) {
|
| Constraint* dist = con->copy();
|
| dist->First = newIds.front();
|
| dist->FirstPos = PointPos::start;
|
| dist->Second = newIds.back();
|
| dist->SecondPos = PointPos::end;
|
| newConstraints.push_back(dist);
|
| return true;
|
| }
|
|
|
| if (conId == GeoEnum::GeoUndef || newGeosLikelyNotCreated) {
|
|
|
| return false;
|
| }
|
|
|
| Base::Vector3d conPoint(getPoint(conId, conPos));
|
| double conParam;
|
| auto* geoAsCurve = static_cast<const Part::GeomCurve*>(geo);
|
| geoAsCurve->closestParameter(conPoint, conParam);
|
|
|
|
|
| for (size_t i = 0; i < newIds.size(); ++i) {
|
| double newGeoFirstParam
|
| = static_cast<const Part::GeomCurve*>(newGeos[i])->getFirstParameter();
|
| double newGeoLastParam
|
| = static_cast<const Part::GeomCurve*>(newGeos[i])->getLastParameter();
|
|
|
| if ((newGeoFirstParam - conParam) > Precision::PApproximation()
|
| && isClosedCurve(geo)) {
|
| conParam += (geoAsCurve->getLastParameter() - geoAsCurve->getFirstParameter());
|
| }
|
| if ((newGeoFirstParam - conParam) <= Precision::PApproximation()
|
| && (conParam - newGeoLastParam) <= Precision::PApproximation()) {
|
| Constraint* trans = con->copy();
|
| trans->First = conId;
|
| trans->FirstPos = conPos;
|
| trans->Second = newIds[i];
|
| trans->SecondPos = PointPos::none;
|
| newConstraints.push_back(trans);
|
| return true;
|
| }
|
| }
|
| } break;
|
| case Radius:
|
| case Diameter:
|
| case Equal: {
|
|
|
|
|
|
|
|
|
| if (geo->isDerivedFrom<Part::GeomConic>() || geo->isDerivedFrom<Part::GeomArcOfConic>()) {
|
| Constraint* trans = con->copy();
|
| trans->substituteIndex(oldId, newIds.front());
|
| newConstraints.push_back(trans);
|
| break;
|
| }
|
| } break;
|
| default:
|
|
|
| break;
|
| }
|
|
|
| if (!transferToAll) {
|
| return false;
|
| }
|
|
|
| for (auto& newId : newIds) {
|
| Constraint* trans = con->copy();
|
| trans->substituteIndex(oldId, newId);
|
| newConstraints.push_back(trans);
|
| }
|
|
|
| return true;
|
| }
|
|
|
| int SketchObject::split(int GeoId, const Base::Vector3d& point)
|
| {
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex()) {
|
| return -1;
|
| }
|
|
|
|
|
| deleteUnusedInternalGeometryAndUpdateGeoId(GeoId);
|
| const auto* geoAsCurve = getGeometry<Part::GeomCurve>(GeoId);
|
|
|
| bool isOriginalCurvePeriodic = isClosedCurve(geoAsCurve);
|
| std::vector<int> newIds;
|
| std::vector<Part::Geometry*> newGeos;
|
| std::vector<Constraint*> newConstraints;
|
|
|
| double splitParam;
|
| geoAsCurve->closestParameter(point, splitParam);
|
|
|
|
|
| std::vector<std::pair<double, double>> paramsOfNewGeos(
|
| isOriginalCurvePeriodic ? 1 : 2,
|
| {geoAsCurve->getFirstParameter(), geoAsCurve->getLastParameter()}
|
| );
|
| paramsOfNewGeos.front().second = isOriginalCurvePeriodic
|
| ? (splitParam + geoAsCurve->getLastParameter() - geoAsCurve->getFirstParameter())
|
| : splitParam;
|
| paramsOfNewGeos.back().first = splitParam;
|
|
|
| switch (paramsOfNewGeos.size()) {
|
| case 0: {
|
| delGeometry(GeoId);
|
| return 0;
|
| }
|
| case 1: {
|
| newIds.push_back(GeoId);
|
| break;
|
| }
|
| case 2: {
|
| newIds.push_back(GeoId);
|
| newIds.push_back(getHighestCurveIndex() + 1);
|
| break;
|
| }
|
| default: {
|
| return -1;
|
| }
|
| }
|
|
|
| createArcsFromGeoWithLimits(geoAsCurve, paramsOfNewGeos, newGeos);
|
|
|
| std::vector<int> idsOfOldConstraints;
|
| getConstraintIndices(GeoId, idsOfOldConstraints);
|
|
|
| const auto& allConstraints = this->Constraints.getValues();
|
|
|
| std::erase_if(idsOfOldConstraints, [&GeoId, &allConstraints](const auto& i) {
|
| return !allConstraints[i]->involvesGeoIdAndPosId(GeoId, PointPos::none);
|
| });
|
|
|
| for (const auto& oldConstrId : idsOfOldConstraints) {
|
| Constraint* con = allConstraints[oldConstrId];
|
| deriveConstraintsForPieces(GeoId, newIds, con, newConstraints);
|
| }
|
|
|
|
|
|
|
| geoAsCurve = getGeometry<Part::GeomCurve>(GeoId);
|
|
|
| if (!isOriginalCurvePeriodic) {
|
| auto* joint = new Constraint();
|
| joint->Type = Coincident;
|
| joint->First = newIds.front();
|
| joint->FirstPos = PointPos::end;
|
| joint->Second = newIds.back();
|
| joint->SecondPos = PointPos::start;
|
| newConstraints.push_back(joint);
|
|
|
| transferConstraints(GeoId, PointPos::start, newIds.front(), PointPos::start);
|
| transferConstraints(GeoId, PointPos::end, newIds.back(), PointPos::end);
|
| }
|
|
|
|
|
|
|
| if (geoAsCurve->is<Part::GeomArcOfCircle>()) {
|
| auto* joint = new Constraint();
|
| joint->Type = Coincident;
|
| joint->First = newIds.front();
|
| joint->FirstPos = PointPos::mid;
|
| joint->Second = newIds.back();
|
| joint->SecondPos = PointPos::mid;
|
| newConstraints.push_back(joint);
|
| }
|
|
|
| if (geoAsCurve->isDerivedFrom<Part::GeomConic>()
|
| || geoAsCurve->isDerivedFrom<Part::GeomArcOfConic>()) {
|
| transferConstraints(GeoId, PointPos::mid, newIds.front(), PointPos::mid);
|
| }
|
|
|
| delConstraints(std::move(idsOfOldConstraints), DeleteOption::NoSolve);
|
| replaceGeometries({GeoId}, newGeos);
|
| addConstraints(newConstraints);
|
|
|
|
|
|
|
| solve();
|
|
|
| for (auto& cons : newConstraints) {
|
| delete cons;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::join(
|
| int geoId1,
|
| Sketcher::PointPos posId1,
|
| int geoId2,
|
| Sketcher::PointPos posId2,
|
| int continuity
|
| )
|
| {
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (Sketcher::PointPos::start != posId1 && Sketcher::PointPos::end != posId1
|
| && Sketcher::PointPos::start != posId2 && Sketcher::PointPos::end != posId2) {
|
| THROWM(ValueError, "Invalid positions: points must be start or end points of a curve.");
|
| return -1;
|
| }
|
|
|
| if (geoId1 == geoId2) {
|
| THROWM(ValueError, "Connecting the end points of the same curve is not yet supported.");
|
| return -1;
|
| }
|
|
|
| if (geoId1 < 0 || geoId1 > getHighestCurveIndex() || geoId2 < 0
|
| || geoId2 > getHighestCurveIndex()) {
|
| return -1;
|
| }
|
|
|
|
|
| auto* geo1 = dynamic_cast<const Part::GeomCurve*>(getGeometry(geoId1));
|
| auto* geo2 = dynamic_cast<const Part::GeomCurve*>(getGeometry(geoId2));
|
|
|
| if (GeometryFacade::getConstruction(geo1) != GeometryFacade::getConstruction(geo2)) {
|
| THROWM(ValueError, "Cannot join construction and non-construction geometries.");
|
| return -1;
|
| }
|
| bool areOriginalCurvesConstruction = GeometryFacade::getConstruction(geo1);
|
|
|
|
|
| if (!geo1 || !geo2) {
|
| return -1;
|
| }
|
|
|
|
|
|
|
|
|
| std::unique_ptr<Part::GeomBSplineCurve> bsp1(
|
| geo1->toNurbs(geo1->getFirstParameter(), geo1->getLastParameter())
|
| );
|
| std::unique_ptr<Part::GeomBSplineCurve> bsp2(
|
| geo2->toNurbs(geo2->getFirstParameter(), geo2->getLastParameter())
|
| );
|
|
|
| if (bsp1->isPeriodic() || bsp2->isPeriodic()) {
|
| THROWM(ValueError, "It is only possible to join non-periodic curves.");
|
| return -1;
|
| }
|
|
|
|
|
| if (Sketcher::PointPos::start == posId1) {
|
| bsp1->reverse();
|
| }
|
| if (Sketcher::PointPos::end == posId2) {
|
| bsp2->reverse();
|
| }
|
|
|
|
|
| if (bsp1->getDegree() < bsp2->getDegree()) {
|
| bsp1->increaseDegree(bsp2->getDegree());
|
| }
|
| else if (bsp2->getDegree() < bsp1->getDegree()) {
|
| bsp2->increaseDegree(bsp1->getDegree());
|
| }
|
|
|
|
|
| bool makeC1Continuous = (continuity >= 1);
|
|
|
|
|
|
|
|
|
| if (makeC1Continuous) {
|
|
|
|
|
| Base::Vector3d slope1 = bsp1->firstDerivativeAtParameter(bsp1->getLastParameter());
|
| Base::Vector3d slope2 = bsp2->firstDerivativeAtParameter(bsp2->getFirstParameter());
|
|
|
|
|
|
|
| double scale = slope2.Length() / slope1.Length();
|
| bsp2->scaleKnotsToBounds(0, scale * (bsp2->getLastParameter() - bsp2->getFirstParameter()));
|
| }
|
|
|
|
|
| std::vector<Base::Vector3d> poles1 = bsp1->getPoles();
|
| std::vector<double> weights1 = bsp1->getWeights();
|
| std::vector<double> knots1 = bsp1->getKnots();
|
| std::vector<int> mults1 = bsp1->getMultiplicities();
|
| std::vector<Base::Vector3d> poles2 = bsp2->getPoles();
|
| std::vector<double> weights2 = bsp2->getWeights();
|
| std::vector<double> knots2 = bsp2->getKnots();
|
| std::vector<int> mults2 = bsp2->getMultiplicities();
|
|
|
| std::vector<Base::Vector3d> newPoles(std::move(poles1));
|
| std::vector<double> newWeights(std::move(weights1));
|
| std::vector<double> newKnots(std::move(knots1));
|
| std::vector<int> newMults(std::move(mults1));
|
|
|
| poles2.erase(poles2.begin());
|
| if (makeC1Continuous) {
|
| newPoles.erase(newPoles.end() - 1);
|
| }
|
| newPoles.insert(
|
| newPoles.end(),
|
| std::make_move_iterator(poles2.begin()),
|
| std::make_move_iterator(poles2.end())
|
| );
|
|
|
|
|
| weights2.erase(weights2.begin());
|
| if (makeC1Continuous) {
|
| newWeights.erase(newWeights.end() - 1);
|
| }
|
| newWeights.insert(
|
| newWeights.end(),
|
| std::make_move_iterator(weights2.begin()),
|
| std::make_move_iterator(weights2.end())
|
| );
|
|
|
|
|
| double offset = newKnots.back() - knots2.front();
|
| knots2.erase(knots2.begin());
|
| for (auto& knot : knots2) {
|
| knot += offset;
|
| }
|
| newKnots.insert(
|
| newKnots.end(),
|
| std::make_move_iterator(knots2.begin()),
|
| std::make_move_iterator(knots2.end())
|
| );
|
|
|
|
|
| if (bsp1->getDegree() < newMults.back()) {
|
| newMults.back() = bsp1->getDegree();
|
| if (makeC1Continuous) {
|
| newMults.back() -= 1;
|
| }
|
| }
|
|
|
| mults2.erase(mults2.begin());
|
| newMults.insert(
|
| newMults.end(),
|
| std::make_move_iterator(mults2.begin()),
|
| std::make_move_iterator(mults2.end())
|
| );
|
|
|
| auto* newSpline = new Part::GeomBSplineCurve(
|
| newPoles,
|
| newWeights,
|
| newKnots,
|
| newMults,
|
| bsp1->getDegree(),
|
| false,
|
| true
|
| );
|
|
|
|
|
| std::vector<Part::Geometry*> newGeos {newSpline};
|
| replaceGeometries({geoId1, geoId2}, newGeos);
|
|
|
| exposeInternalGeometry(geoId1);
|
| setConstruction(geoId1, areOriginalCurvesConstruction);
|
|
|
|
|
| auto otherPosId1 = (Sketcher::PointPos::start == posId1) ? Sketcher::PointPos::end
|
| : Sketcher::PointPos::start;
|
| auto otherPosId2 = (Sketcher::PointPos::start == posId2) ? Sketcher::PointPos::end
|
| : Sketcher::PointPos::start;
|
|
|
| transferConstraints(geoId1, otherPosId1, geoId1, PointPos::start, true);
|
| transferConstraints(geoId2, otherPosId2, geoId1, PointPos::end, true);
|
|
|
| return 0;
|
| }
|
|
|
|
|
| bool SketchObject::isExternalAllowed(App::Document* pDoc, App::DocumentObject* pObj,
|
| eReasonList* rsn) const
|
| {
|
| if (rsn)
|
| *rsn = rlAllowed;
|
|
|
|
|
| if (this->getDocument() != pDoc) {
|
| if (rsn)
|
| *rsn = rlOtherDoc;
|
| return false;
|
| }
|
|
|
|
|
| try {
|
| if (!(this->testIfLinkDAGCompatible(pObj))) {
|
| if (rsn)
|
| *rsn = rlCircularReference;
|
| return false;
|
| }
|
| }
|
| catch (Base::Exception& e) {
|
| Base::Console().warning(
|
| "Probably, there is a circular reference in the document. Error: %s\n", e.what());
|
| return true;
|
| }
|
|
|
|
|
|
|
|
|
| Part::BodyBase* body_this = Part::BodyBase::findBodyOf(this);
|
| Part::BodyBase* body_obj = Part::BodyBase::findBodyOf(pObj);
|
| App::Part* part_this = App::Part::getPartOfObject(this);
|
| App::Part* part_obj = App::Part::getPartOfObject(pObj);
|
| if (part_this == part_obj) {
|
| if (!body_this) {
|
| return true;
|
| }
|
| else if (body_this == body_obj) {
|
| return true;
|
| }
|
| else {
|
| if (rsn)
|
| *rsn = rlOtherBody;
|
| return false;
|
| }
|
| }
|
| else {
|
|
|
| if (rsn)
|
| *rsn = rlOtherPart;
|
| return false;
|
| }
|
| }
|
|
|
| bool SketchObject::isCarbonCopyAllowed(App::Document* pDoc, App::DocumentObject* pObj, bool& xinv,
|
| bool& yinv, eReasonList* rsn) const
|
| {
|
| auto setReason = [&rsn](eReasonList reasonFromList) {
|
| if (rsn)
|
| *rsn = reasonFromList;
|
| };
|
|
|
| setReason(rlAllowed);
|
|
|
| std::string sketchArchType ("Sketcher::SketchObjectPython");
|
|
|
|
|
| if (!pObj->is<Sketcher::SketchObject>()
|
| && sketchArchType != pObj->getTypeId().getName()) {
|
| setReason(rlNotASketch);
|
| return false;
|
| }
|
|
|
|
|
| auto* psObj = static_cast<SketchObject*>(pObj);
|
|
|
|
|
| if (this->getDocument() != pDoc) {
|
| setReason(rlOtherDoc);
|
| return false;
|
| }
|
|
|
|
|
| try {
|
| if (!(this->testIfLinkDAGCompatible(pObj))) {
|
| setReason(rlCircularReference);
|
| return false;
|
| }
|
| }
|
| catch (Base::Exception& e) {
|
| Base::Console().warning(
|
| "Probably, there is a circular reference in the document. Error: %s\n", e.what());
|
| return true;
|
| }
|
|
|
|
|
|
|
|
|
| Part::BodyBase* body_this = Part::BodyBase::findBodyOf(this);
|
| Part::BodyBase* body_obj = Part::BodyBase::findBodyOf(pObj);
|
| App::Part* part_this = App::Part::getPartOfObject(this);
|
| App::Part* part_obj = App::Part::getPartOfObject(pObj);
|
| if (part_this != part_obj) {
|
|
|
| setReason(rlOtherPart);
|
| return false;
|
| }
|
|
|
|
|
| if (body_this && body_this != body_obj) {
|
| if (!this->allowOtherBody) {
|
| setReason(rlOtherBody);
|
| return false;
|
| }
|
|
|
|
|
| else if (psObj->getExternalGeometryCount() > 2) {
|
| setReason(rlOtherBodyWithLinks);
|
| return false;
|
| }
|
| }
|
|
|
| const Rotation& srot = psObj->Placement.getValue().getRotation();
|
| const Rotation& lrot = this->Placement.getValue().getRotation();
|
|
|
| Base::Vector3d snormal(0, 0, 1);
|
| Base::Vector3d sx(1, 0, 0);
|
| Base::Vector3d sy(0, 1, 0);
|
| srot.multVec(snormal, snormal);
|
| srot.multVec(sx, sx);
|
| srot.multVec(sy, sy);
|
|
|
| Base::Vector3d lnormal(0, 0, 1);
|
| Base::Vector3d lx(1, 0, 0);
|
| Base::Vector3d ly(0, 1, 0);
|
| lrot.multVec(lnormal, lnormal);
|
| lrot.multVec(lx, lx);
|
| lrot.multVec(ly, ly);
|
|
|
| double dot = snormal * lnormal;
|
| double dotx = sx * lx;
|
| double doty = sy * ly;
|
|
|
|
|
| if (!allowUnaligned && fabs(fabs(dot) - 1) > Precision::Confusion()) {
|
| setReason(rlNonParallel);
|
| return false;
|
| }
|
|
|
|
|
| if (!allowUnaligned
|
| && ((fabs(fabs(dotx) - 1) > Precision::Confusion())
|
| || (fabs(fabs(doty) - 1) > Precision::Confusion()))) {
|
| setReason(rlAxesMisaligned);
|
| return false;
|
| }
|
|
|
|
|
|
|
| Base::Vector3d ddir =
|
| (psObj->Placement.getValue().getPosition() - this->Placement.getValue().getPosition())
|
| .Normalize();
|
|
|
| double alignment = ddir * lnormal;
|
|
|
| if (!allowUnaligned && (fabs(fabs(alignment) - 1) > Precision::Confusion())
|
| && (psObj->Placement.getValue().getPosition()
|
| != this->Placement.getValue().getPosition())) {
|
| setReason(rlOriginsMisaligned);
|
| return false;
|
| }
|
|
|
| xinv = allowUnaligned ? false : (fabs(dotx - 1) > Precision::Confusion());
|
| yinv = allowUnaligned ? false : (fabs(doty - 1) > Precision::Confusion());
|
|
|
| return true;
|
| }
|
|
|
|
|
| int SketchObject::addSymmetric(
|
| const std::vector<int>& geoIdList,
|
| int refGeoId,
|
| Sketcher::PointPos refPosId,
|
| bool addSymmetryConstraints
|
| )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& constrvals = this->Constraints.getValues();
|
| std::vector<Constraint*> newconstrVals(constrvals);
|
|
|
| std::map<int, int> geoIdMap;
|
| std::map<int, bool> isStartEndInverted;
|
|
|
|
|
|
|
| bool refIsLine = refPosId == Sketcher::PointPos::none;
|
| bool refIsAxisAligned = refGeoId == Sketcher::GeoEnum::VAxis
|
| || refGeoId == Sketcher::GeoEnum::HAxis || !refIsLine
|
| || std::ranges::any_of(constrvals, [&refGeoId](auto* constr) {
|
| return constr->getElement(0).GeoId == refGeoId
|
| && (constr->Type == Sketcher::Vertical
|
| || constr->Type == Sketcher::Horizontal);
|
| });
|
|
|
| std::vector<Part::Geometry*> symgeos
|
| = getSymmetric(geoIdList, geoIdMap, isStartEndInverted, refGeoId, refPosId);
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (addSymmetryConstraints) {
|
| for (auto* geo : symgeos) {
|
| if (auto* arc = dynamic_cast<Part::GeomArcOfCircle*>(geo)) {
|
| double start, end;
|
| arc->getRange(start, end, true);
|
| arc->setRange(start + Precision::Angular(), end, true);
|
| }
|
| }
|
| }
|
|
|
| {
|
| addGeometry(symgeos);
|
|
|
| for (auto* constr : constrvals) {
|
|
|
| auto firstIt = geoIdMap.find(constr->getElement(0).GeoId);
|
|
|
| if (firstIt == geoIdMap.end()) {
|
| continue;
|
| }
|
|
|
|
|
| if (addSymmetryConstraints && constr->Type != Sketcher::InternalAlignment) {
|
|
|
|
|
| continue;
|
| }
|
|
|
| if (constr->getElement(1).GeoId == GeoEnum::GeoUndef
|
| ) {
|
| if (refIsAxisAligned
|
| && (constr->Type == Sketcher::DistanceX || constr->Type == Sketcher::DistanceY)) {
|
|
|
|
|
|
|
|
|
| continue;
|
| }
|
| if (!refIsAxisAligned
|
| && (constr->Type == Sketcher::DistanceX
|
| || constr->Type == Sketcher::DistanceY
|
| || constr->Type == Sketcher::Vertical
|
| || constr->Type == Sketcher::Horizontal)) {
|
|
|
|
|
| continue;
|
| }
|
| Constraint* constNew = constr->copy();
|
| constNew->Name = "";
|
| GeoElementId rep = constr->getElement(0);
|
| rep.GeoId = firstIt->second;
|
| constNew->setElement(0, rep);
|
| newconstrVals.push_back(constNew);
|
|
|
| continue;
|
| }
|
|
|
|
|
| auto secondIt = geoIdMap.find(constr->getElement(1).GeoId);
|
|
|
| if (secondIt == geoIdMap.end()) {
|
| continue;
|
| }
|
|
|
|
|
|
|
| auto flipStartEndIfRelevant =
|
| [&isStartEndInverted](GeoElementId geId, Sketcher::PointPos& posIdNew) {
|
| if (isStartEndInverted[geId.GeoId]) {
|
| if (geId.Pos == Sketcher::PointPos::start) {
|
| posIdNew = Sketcher::PointPos::end;
|
| }
|
| else if (geId.Pos == Sketcher::PointPos::end) {
|
| posIdNew = Sketcher::PointPos::start;
|
| }
|
| }
|
| };
|
|
|
| if (constr->getElement(2).GeoId == GeoEnum::GeoUndef) {
|
| if (!(constr->Type == Sketcher::Coincident
|
| || constr->Type == Sketcher::Perpendicular
|
| || constr->Type == Sketcher::Parallel
|
| || constr->Type == Sketcher::Tangent
|
| || constr->Type == Sketcher::Distance
|
| || constr->Type == Sketcher::Equal
|
| || constr->Type == Sketcher::Angle
|
| || constr->Type == Sketcher::PointOnObject
|
| || constr->Type == Sketcher::InternalAlignment)) {
|
| continue;
|
| }
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->Name = "";
|
| auto rep0 = constNew->getElement(0);
|
| auto rep1 = constNew->getElement(1);
|
| rep0.GeoId = firstIt->second;
|
| rep1.GeoId = secondIt->second;
|
| flipStartEndIfRelevant(constr->getElement(0), rep0.Pos);
|
| flipStartEndIfRelevant(constr->getElement(1), rep1.Pos);
|
| constNew->setElement(0, rep0);
|
| constNew->setElement(1, rep1);
|
|
|
| if (constNew->Type == Tangent || constNew->Type == Perpendicular) {
|
| AutoLockTangencyAndPerpty(constNew, true);
|
| }
|
|
|
| if ((constr->Type == Sketcher::Angle) && (refPosId == Sketcher::PointPos::none)) {
|
| constNew->setValue(-constr->getValue());
|
| }
|
|
|
| newconstrVals.push_back(constNew);
|
| continue;
|
| }
|
|
|
|
|
| auto thirdIt = geoIdMap.find(constr->getElement(2).GeoId);
|
|
|
| if (thirdIt == geoIdMap.end()) {
|
| continue;
|
| }
|
|
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->Name = "";
|
| auto rep0 = constNew->getElement(0);
|
| auto rep1 = constNew->getElement(1);
|
| auto rep2 = constNew->getElement(2);
|
| rep0.GeoId = firstIt->second;
|
| rep1.GeoId = secondIt->second;
|
| rep2.GeoId = thirdIt->second;
|
| flipStartEndIfRelevant(constr->getElement(0), rep0.Pos);
|
| flipStartEndIfRelevant(constr->getElement(1), rep1.Pos);
|
| flipStartEndIfRelevant(constr->getElement(2), rep2.Pos);
|
| constNew->setElement(0, rep0);
|
| constNew->setElement(1, rep1);
|
| constNew->setElement(2, rep2);
|
| newconstrVals.push_back(constNew);
|
| }
|
|
|
| if (!addSymmetryConstraints) {
|
| if (newconstrVals.size() > constrvals.size()) {
|
| Constraints.setValues(std::move(newconstrVals));
|
| }
|
|
|
|
|
|
|
|
|
| Geometry.touch();
|
|
|
| return Geometry.getSize() - 1;
|
| }
|
|
|
| auto createSymConstr =
|
| [&](int first, int second, Sketcher::PointPos firstPos, Sketcher::PointPos secondPos) {
|
| auto* symConstr = new Constraint();
|
| symConstr->Type = Symmetric;
|
| symConstr->setElement(0, GeoElementId {first, firstPos});
|
| symConstr->setElement(1, GeoElementId {second, secondPos});
|
| symConstr->setElement(2, GeoElementId {refGeoId, refPosId});
|
| newconstrVals.push_back(symConstr);
|
| };
|
| auto createEqualityConstr = [&](int first, int second) {
|
| auto* symConstr = new Constraint();
|
| symConstr->Type = Equal;
|
| symConstr->setElement(0, GeoElementId {first});
|
| symConstr->setElement(1, GeoElementId {second});
|
| newconstrVals.push_back(symConstr);
|
| };
|
|
|
| for (auto geoIdPair : geoIdMap) {
|
| int geoId1 = geoIdPair.first;
|
| int geoId2 = geoIdPair.second;
|
| const Part::Geometry* geo = getGeometry(geoId1);
|
|
|
| if (geo->is<Part::GeomLineSegment>()) {
|
| auto gf = GeometryFacade::getFacade(geo);
|
| if (!gf->isInternalAligned()) {
|
|
|
|
|
| createSymConstr(
|
| geoId1,
|
| geoId2,
|
| PointPos::start,
|
| isStartEndInverted[geoId1] ? PointPos::end : PointPos::start
|
| );
|
| createSymConstr(
|
| geoId1,
|
| geoId2,
|
| PointPos::end,
|
| isStartEndInverted[geoId1] ? PointPos::start : PointPos::end
|
| );
|
| }
|
| }
|
| else if (geo->is<Part::GeomCircle>() || geo->is<Part::GeomEllipse>()) {
|
| createEqualityConstr(geoId1, geoId2);
|
| createSymConstr(geoId1, geoId2, PointPos::mid, PointPos::mid);
|
| }
|
| else if (geo->is<Part::GeomArcOfCircle>()
|
| || geo->is<Part::GeomArcOfEllipse>()
|
| || geo->is<Part::GeomArcOfHyperbola>()
|
| || geo->is<Part::GeomArcOfParabola>()) {
|
| createEqualityConstr(geoId1, geoId2);
|
| createSymConstr(
|
| geoId1,
|
| geoId2,
|
| PointPos::start,
|
| isStartEndInverted[geoId1] ? PointPos::end : PointPos::start
|
| );
|
| createSymConstr(
|
| geoId1,
|
| geoId2,
|
| PointPos::end,
|
| isStartEndInverted[geoId1] ? PointPos::start : PointPos::end
|
| );
|
| }
|
| else if (geo->is<Part::GeomPoint>()) {
|
| auto gf = GeometryFacade::getFacade(geo);
|
| if (!gf->isInternalAligned()) {
|
| createSymConstr(geoId1, geoId2, PointPos::start, PointPos::start);
|
| }
|
| }
|
|
|
| }
|
|
|
| if (newconstrVals.size() > constrvals.size()) {
|
| Constraints.setValues(std::move(newconstrVals));
|
| }
|
| }
|
|
|
|
|
|
|
|
|
| Geometry.touch();
|
|
|
| return Geometry.getSize() - 1;
|
| }
|
|
|
| std::vector<Part::Geometry*> SketchObject::getSymmetric(
|
| const std::vector<int>& geoIdList,
|
| std::map<int, int>& geoIdMap,
|
| std::map<int, bool>& isStartEndInverted,
|
| int refGeoId,
|
| Sketcher::PointPos refPosId
|
| )
|
| {
|
| using std::numbers::pi;
|
|
|
| std::vector<Part::Geometry*> symmetricVals;
|
| bool refIsLine = refPosId == Sketcher::PointPos::none;
|
| int cgeoid = getHighestCurveIndex() + 1;
|
|
|
| auto shouldCopyGeometry = [&](auto* geo, int geoId) -> bool {
|
| auto gf = GeometryFacade::getFacade(geo);
|
| if (!gf->isInternalAligned()) {
|
|
|
| return true;
|
| }
|
|
|
|
|
| const auto& constraints = Constraints.getValues();
|
| auto constrIt = std::ranges::find_if(constraints, [&geoId](auto* c) {
|
| return c->Type == Sketcher::InternalAlignment && c->getElement(0).GeoId == geoId;
|
| });
|
| int definedGeo = (constrIt == constraints.end()) ? GeoEnum::GeoUndef
|
| : (*constrIt)->getElement(1).GeoId;
|
|
|
| return std::ranges::find(geoIdList, definedGeo) != geoIdList.end();
|
| };
|
|
|
| if (refIsLine) {
|
| const Part::Geometry* georef = getGeometry(refGeoId);
|
| if (!georef->is<Part::GeomLineSegment>()) {
|
| return {};
|
| }
|
|
|
| auto* refGeoLine = static_cast<const Part::GeomLineSegment*>(georef);
|
|
|
| Base::Vector3d refstart = refGeoLine->getStartPoint();
|
| Base::Vector3d vectline = refGeoLine->getEndPoint() - refstart;
|
|
|
| for (auto geoId : geoIdList) {
|
| const Part::Geometry* geo = getGeometry(geoId);
|
| Part::Geometry* geosym;
|
|
|
| if (!shouldCopyGeometry(geo, geoId)) {
|
| continue;
|
| }
|
|
|
| geosym = geo->copy();
|
|
|
|
|
| if (geosym->is<Part::GeomLineSegment>()) {
|
| auto* geosymline = static_cast<Part::GeomLineSegment*>(geosym);
|
| Base::Vector3d sp = geosymline->getStartPoint();
|
| Base::Vector3d ep = geosymline->getEndPoint();
|
|
|
| geosymline->setPoints(
|
| sp + 2.0 * (sp.Perpendicular(refGeoLine->getStartPoint(), vectline) - sp),
|
| ep + 2.0 * (ep.Perpendicular(refGeoLine->getStartPoint(), vectline) - ep)
|
| );
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomCircle>()) {
|
| auto* geosymcircle = static_cast<Part::GeomCircle*>(geosym);
|
| Base::Vector3d cp = geosymcircle->getCenter();
|
|
|
| geosymcircle->setCenter(
|
| cp + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp)
|
| );
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomArcOfCircle>()) {
|
| auto* geoaoc = static_cast<Part::GeomArcOfCircle*>(geosym);
|
| Base::Vector3d sp = geoaoc->getStartPoint(true);
|
| Base::Vector3d ep = geoaoc->getEndPoint(true);
|
| Base::Vector3d cp = geoaoc->getCenter();
|
|
|
| Base::Vector3d ssp = sp
|
| + 2.0 * (sp.Perpendicular(refGeoLine->getStartPoint(), vectline) - sp);
|
| Base::Vector3d sep = ep
|
| + 2.0 * (ep.Perpendicular(refGeoLine->getStartPoint(), vectline) - ep);
|
| Base::Vector3d scp = cp
|
| + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp);
|
|
|
| double theta1 = Base::fmod(atan2(sep.y - scp.y, sep.x - scp.x), 2.f * std::numbers::pi);
|
| double theta2 = Base::fmod(atan2(ssp.y - scp.y, ssp.x - scp.x), 2.f * std::numbers::pi);
|
|
|
| geoaoc->setCenter(scp);
|
| geoaoc->setRange(theta1, theta2, true);
|
| isStartEndInverted.insert(std::make_pair(geoId, true));
|
| }
|
| else if (geosym->is<Part::GeomEllipse>()) {
|
| auto* geosymellipse = static_cast<Part::GeomEllipse*>(geosym);
|
| Base::Vector3d cp = geosymellipse->getCenter();
|
|
|
| Base::Vector3d majdir = geosymellipse->getMajorAxisDir();
|
| double majord = geosymellipse->getMajorRadius();
|
| double minord = geosymellipse->getMinorRadius();
|
| double df = sqrt(majord * majord - minord * minord);
|
| Base::Vector3d f1 = cp + df * majdir;
|
|
|
| Base::Vector3d sf1 = f1
|
| + 2.0 * (f1.Perpendicular(refGeoLine->getStartPoint(), vectline) - f1);
|
| Base::Vector3d scp = cp
|
| + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp);
|
|
|
| geosymellipse->setMajorAxisDir(sf1 - scp);
|
|
|
| geosymellipse->setCenter(scp);
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomArcOfEllipse>()) {
|
| auto* geosymaoe = static_cast<Part::GeomArcOfEllipse*>(geosym);
|
| Base::Vector3d cp = geosymaoe->getCenter();
|
|
|
| Base::Vector3d majdir = geosymaoe->getMajorAxisDir();
|
| double majord = geosymaoe->getMajorRadius();
|
| double minord = geosymaoe->getMinorRadius();
|
| double df = sqrt(majord * majord - minord * minord);
|
| Base::Vector3d f1 = cp + df * majdir;
|
|
|
| Base::Vector3d sf1 = f1
|
| + 2.0 * (f1.Perpendicular(refGeoLine->getStartPoint(), vectline) - f1);
|
| Base::Vector3d scp = cp
|
| + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp);
|
|
|
| geosymaoe->setMajorAxisDir(sf1 - scp);
|
|
|
| geosymaoe->setCenter(scp);
|
|
|
| double theta1, theta2;
|
| geosymaoe->getRange(theta1, theta2, true);
|
| theta1 = 2.0 * pi - theta1;
|
| theta2 = 2.0 * pi - theta2;
|
| std::swap(theta1, theta2);
|
| if (theta1 < 0) {
|
| theta1 += 2.0 * pi;
|
| theta2 += 2.0 * pi;
|
| }
|
|
|
| geosymaoe->setRange(theta1, theta2, true);
|
| isStartEndInverted.insert(std::make_pair(geoId, true));
|
| }
|
| else if (geosym->is<Part::GeomArcOfHyperbola>()) {
|
| auto* geosymaoe = static_cast<Part::GeomArcOfHyperbola*>(geosym);
|
| Base::Vector3d cp = geosymaoe->getCenter();
|
|
|
| Base::Vector3d majdir = geosymaoe->getMajorAxisDir();
|
| double majord = geosymaoe->getMajorRadius();
|
| double minord = geosymaoe->getMinorRadius();
|
| double df = sqrt(majord * majord + minord * minord);
|
| Base::Vector3d f1 = cp + df * majdir;
|
|
|
| Base::Vector3d sf1 = f1
|
| + 2.0 * (f1.Perpendicular(refGeoLine->getStartPoint(), vectline) - f1);
|
| Base::Vector3d scp = cp
|
| + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp);
|
|
|
| geosymaoe->setMajorAxisDir(sf1 - scp);
|
|
|
| geosymaoe->setCenter(scp);
|
|
|
| double theta1, theta2;
|
| geosymaoe->getRange(theta1, theta2, true);
|
| theta1 = -theta1;
|
| theta2 = -theta2;
|
| std::swap(theta1, theta2);
|
|
|
| geosymaoe->setRange(theta1, theta2, true);
|
| isStartEndInverted.insert(std::make_pair(geoId, true));
|
| }
|
| else if (geosym->is<Part::GeomArcOfParabola>()) {
|
| auto* geosymaoe = static_cast<Part::GeomArcOfParabola*>(geosym);
|
| Base::Vector3d cp = geosymaoe->getCenter();
|
|
|
| Base::Vector3d f1 = geosymaoe->getFocus();
|
|
|
| Base::Vector3d sf1 = f1
|
| + 2.0 * (f1.Perpendicular(refGeoLine->getStartPoint(), vectline) - f1);
|
| Base::Vector3d scp = cp
|
| + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp);
|
|
|
| geosymaoe->setXAxisDir(sf1 - scp);
|
| geosymaoe->setCenter(scp);
|
|
|
| double theta1, theta2;
|
| geosymaoe->getRange(theta1, theta2, true);
|
| theta1 = -theta1;
|
| theta2 = -theta2;
|
| std::swap(theta1, theta2);
|
|
|
| geosymaoe->setRange(theta1, theta2, true);
|
| isStartEndInverted.insert(std::make_pair(geoId, true));
|
| }
|
| else if (geosym->is<Part::GeomBSplineCurve>()) {
|
| auto* geosymbsp = static_cast<Part::GeomBSplineCurve*>(geosym);
|
|
|
| std::vector<Base::Vector3d> poles = geosymbsp->getPoles();
|
|
|
| for (auto& pole : poles) {
|
| pole = pole
|
| + 2.0 * (pole.Perpendicular(refGeoLine->getStartPoint(), vectline) - pole);
|
| }
|
|
|
| geosymbsp->setPoles(poles);
|
|
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomPoint>()) {
|
| auto* geosympoint = static_cast<Part::GeomPoint*>(geosym);
|
| Base::Vector3d cp = geosympoint->getPoint();
|
|
|
| geosympoint->setPoint(
|
| cp + 2.0 * (cp.Perpendicular(refGeoLine->getStartPoint(), vectline) - cp)
|
| );
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else {
|
| Base::Console().error("Unsupported Geometry!! Just copying it.\n");
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
|
|
| symmetricVals.push_back(geosym);
|
| geoIdMap.insert(std::make_pair(geoId, cgeoid));
|
| cgeoid++;
|
| }
|
|
|
| return symmetricVals;
|
| }
|
|
|
|
|
| Vector3d refpoint;
|
| const Part::Geometry* georef = getGeometry(refGeoId);
|
|
|
| if (georef->is<Part::GeomPoint>()) {
|
| refpoint = static_cast<const Part::GeomPoint*>(georef)->getPoint();
|
| }
|
| else if (refGeoId == -1 && refPosId == Sketcher::PointPos::start) {
|
| refpoint = Vector3d(0, 0, 0);
|
| }
|
| else {
|
| if (refPosId == Sketcher::PointPos::none) {
|
| Base::Console().error("Wrong PointPosId.\n");
|
| return {};
|
| }
|
| refpoint = getPoint(georef, refPosId);
|
| }
|
|
|
| for (auto geoId : geoIdList) {
|
| const Part::Geometry* geo = getGeometry(geoId);
|
| Part::Geometry* geosym;
|
|
|
| if (!shouldCopyGeometry(geo, geoId)) {
|
| continue;
|
| }
|
|
|
| geosym = geo->copy();
|
|
|
|
|
| if (geosym->is<Part::GeomLineSegment>()) {
|
| auto* geosymline = static_cast<Part::GeomLineSegment*>(geosym);
|
| Base::Vector3d sp = geosymline->getStartPoint();
|
| Base::Vector3d ep = geosymline->getEndPoint();
|
| Base::Vector3d ssp = sp + 2.0 * (refpoint - sp);
|
| Base::Vector3d sep = ep + 2.0 * (refpoint - ep);
|
|
|
| geosymline->setPoints(ssp, sep);
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomCircle>()) {
|
| auto* geosymcircle = static_cast<Part::GeomCircle*>(geosym);
|
| Base::Vector3d cp = geosymcircle->getCenter();
|
|
|
| geosymcircle->setCenter(cp + 2.0 * (refpoint - cp));
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomArcOfCircle>()) {
|
| auto* geoaoc = static_cast<Part::GeomArcOfCircle*>(geosym);
|
| Base::Vector3d sp = geoaoc->getStartPoint(true);
|
| Base::Vector3d ep = geoaoc->getEndPoint(true);
|
| Base::Vector3d cp = geoaoc->getCenter();
|
|
|
| Base::Vector3d ssp = sp + 2.0 * (refpoint - sp);
|
| Base::Vector3d sep = ep + 2.0 * (refpoint - ep);
|
| Base::Vector3d scp = cp + 2.0 * (refpoint - cp);
|
|
|
| double theta1 = Base::fmod(atan2(ssp.y - scp.y, ssp.x - scp.x), 2.f * pi);
|
| double theta2 = Base::fmod(atan2(sep.y - scp.y, sep.x - scp.x), 2.f * pi);
|
|
|
| geoaoc->setCenter(scp);
|
| geoaoc->setRange(theta1, theta2, true);
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomEllipse>()) {
|
| auto* geosymellipse = static_cast<Part::GeomEllipse*>(geosym);
|
| Base::Vector3d cp = geosymellipse->getCenter();
|
|
|
| Base::Vector3d majdir = geosymellipse->getMajorAxisDir();
|
| double majord = geosymellipse->getMajorRadius();
|
| double minord = geosymellipse->getMinorRadius();
|
| double df = sqrt(majord * majord - minord * minord);
|
| Base::Vector3d f1 = cp + df * majdir;
|
|
|
| Base::Vector3d sf1 = f1 + 2.0 * (refpoint - f1);
|
| Base::Vector3d scp = cp + 2.0 * (refpoint - cp);
|
|
|
| geosymellipse->setMajorAxisDir(sf1 - scp);
|
|
|
| geosymellipse->setCenter(scp);
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomArcOfEllipse>()) {
|
| auto* geosymaoe = static_cast<Part::GeomArcOfEllipse*>(geosym);
|
| Base::Vector3d cp = geosymaoe->getCenter();
|
|
|
| Base::Vector3d majdir = geosymaoe->getMajorAxisDir();
|
| double majord = geosymaoe->getMajorRadius();
|
| double minord = geosymaoe->getMinorRadius();
|
| double df = sqrt(majord * majord - minord * minord);
|
| Base::Vector3d f1 = cp + df * majdir;
|
|
|
| Base::Vector3d sf1 = f1 + 2.0 * (refpoint - f1);
|
| Base::Vector3d scp = cp + 2.0 * (refpoint - cp);
|
|
|
| geosymaoe->setMajorAxisDir(sf1 - scp);
|
|
|
| geosymaoe->setCenter(scp);
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomArcOfHyperbola>()) {
|
| auto* geosymaoe = static_cast<Part::GeomArcOfHyperbola*>(geosym);
|
| Base::Vector3d cp = geosymaoe->getCenter();
|
|
|
| Base::Vector3d majdir = geosymaoe->getMajorAxisDir();
|
| double majord = geosymaoe->getMajorRadius();
|
| double minord = geosymaoe->getMinorRadius();
|
| double df = sqrt(majord * majord + minord * minord);
|
| Base::Vector3d f1 = cp + df * majdir;
|
|
|
| Base::Vector3d sf1 = f1 + 2.0 * (refpoint - f1);
|
| Base::Vector3d scp = cp + 2.0 * (refpoint - cp);
|
|
|
| geosymaoe->setMajorAxisDir(sf1 - scp);
|
|
|
| geosymaoe->setCenter(scp);
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomArcOfParabola>()) {
|
| auto* geosymaoe = static_cast<Part::GeomArcOfParabola*>(geosym);
|
| Base::Vector3d cp = geosymaoe->getCenter();
|
| Base::Vector3d f1 = geosymaoe->getFocus();
|
|
|
| Base::Vector3d sf1 = f1 + 2.0 * (refpoint - f1);
|
| Base::Vector3d scp = cp + 2.0 * (refpoint - cp);
|
|
|
| geosymaoe->setXAxisDir(sf1 - scp);
|
| geosymaoe->setCenter(scp);
|
|
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else if (geosym->is<Part::GeomBSplineCurve>()) {
|
| auto* geosymbsp = static_cast<Part::GeomBSplineCurve*>(geosym);
|
|
|
| std::vector<Base::Vector3d> poles = geosymbsp->getPoles();
|
|
|
| for (auto& pole : poles) {
|
| pole = pole + 2.0 * (refpoint - pole);
|
| }
|
|
|
| geosymbsp->setPoles(poles);
|
| }
|
| else if (geosym->is<Part::GeomPoint>()) {
|
| auto* geosympoint = static_cast<Part::GeomPoint*>(geosym);
|
| Base::Vector3d cp = geosympoint->getPoint();
|
|
|
| geosympoint->setPoint(cp + 2.0 * (refpoint - cp));
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
| else {
|
| Base::Console().error("Unsupported Geometry!! Just copying it.\n");
|
| isStartEndInverted.insert(std::make_pair(geoId, false));
|
| }
|
|
|
| symmetricVals.push_back(geosym);
|
| geoIdMap.insert(std::make_pair(geoId, cgeoid));
|
| cgeoid++;
|
| }
|
|
|
| return symmetricVals;
|
| }
|
|
|
| int SketchObject::addCopy(
|
| const std::vector<int>& geoIdList,
|
| const Base::Vector3d& displacement,
|
| bool moveonly,
|
| bool clone,
|
| int csize,
|
| int rsize,
|
| bool constraindisplacement,
|
| double perpscale
|
| )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Part::Geometry*>& geovals = getInternalGeometry();
|
| std::vector<Part::Geometry*> newgeoVals(geovals);
|
|
|
| const std::vector<Constraint*>& constrvals = this->Constraints.getValues();
|
| std::vector<Constraint*> newconstrVals(constrvals);
|
|
|
| if (!moveonly) {
|
| newgeoVals.reserve(geovals.size() + geoIdList.size());
|
| }
|
|
|
| std::vector<int> newgeoIdList(geoIdList);
|
|
|
| if (newgeoIdList.empty()) {
|
| for (int i = 0; i < int(geovals.size()); i++) {
|
| newgeoIdList.push_back(i);
|
| }
|
| }
|
|
|
| int cgeoid = getHighestCurveIndex() + 1;
|
|
|
| int iterfirstgeoid = -1;
|
|
|
| Base::Vector3d iterfirstpoint;
|
|
|
| int refgeoid = -1;
|
|
|
| int colrefgeoid = 0, rowrefgeoid = 0;
|
|
|
| int currentrowfirstgeoid = -1, prevrowstartfirstgeoid = -1, prevfirstgeoid = -1;
|
|
|
| Sketcher::PointPos refposId = Sketcher::PointPos::none;
|
|
|
| std::map<int, int> geoIdMap;
|
|
|
| Base::Vector3d perpendicularDisplacement
|
| = Base::Vector3d(perpscale * displacement.y, perpscale * -displacement.x, 0);
|
|
|
| int x, y;
|
|
|
| auto makeCopyAtRowColumn = [&](int x, int y) {
|
|
|
|
|
| if (x == 0 && y == 0) {
|
| const Part::Geometry* geo = getGeometry(*(newgeoIdList.begin()));
|
|
|
| auto gf = GeometryFacade::getFacade(geo);
|
|
|
| if (gf->isInternalAligned() && !moveonly) {
|
|
|
|
|
|
|
| auto constrIt = std::ranges::find_if(constrvals, [&newgeoIdList](auto c) {
|
| return (
|
| c->Type == Sketcher::InternalAlignment && c->First == *(newgeoIdList.begin())
|
| );
|
| });
|
|
|
| int definedGeo = (constrIt != constrvals.end()) ? (*constrIt)->Second
|
| : GeoEnum::GeoUndef;
|
|
|
| if (std::ranges::find(newgeoIdList, definedGeo) == newgeoIdList.end()) {
|
|
|
|
|
|
|
| THROWM(
|
| Base::ValueError,
|
| "A move/copy/array operation on an internal alignment geometry is "
|
| "only possible together with the geometry it defines."
|
| );
|
| }
|
| }
|
|
|
| refgeoid = *(newgeoIdList.begin());
|
| currentrowfirstgeoid = refgeoid;
|
| iterfirstgeoid = refgeoid;
|
| if (geo->is<Part::GeomCircle>() || geo->is<Part::GeomEllipse>()) {
|
| refposId = Sketcher::PointPos::mid;
|
| }
|
| else {
|
| refposId = Sketcher::PointPos::start;
|
| }
|
|
|
| return;
|
| }
|
|
|
| prevfirstgeoid = iterfirstgeoid;
|
|
|
| iterfirstgeoid = cgeoid;
|
|
|
| if (x == 0) {
|
| prevrowstartfirstgeoid = currentrowfirstgeoid;
|
| currentrowfirstgeoid = cgeoid;
|
| }
|
|
|
| int index = 0;
|
| for (auto it = newgeoIdList.cbegin(); it != newgeoIdList.cend(); ++it, ++index) {
|
| const Part::Geometry* geo = getGeometry(*it);
|
|
|
| Part::Geometry* geocopy;
|
|
|
| auto gf = GeometryFacade::getFacade(geo);
|
|
|
| if (gf->isInternalAligned() && !moveonly) {
|
|
|
|
|
| int definedGeo = GeoEnum::GeoUndef;
|
|
|
| auto constrIt = std::ranges::find_if(constrvals, [&it](auto c) {
|
| return (c->Type == Sketcher::InternalAlignment && c->First == *it);
|
| });
|
| if (constrIt != constrvals.end()) {
|
| definedGeo = (*constrIt)->Second;
|
| }
|
|
|
| if (std::ranges::find(newgeoIdList, definedGeo) == newgeoIdList.end()) {
|
|
|
|
|
| continue;
|
| }
|
| }
|
|
|
|
|
|
|
| if (!moveonly) {
|
| geocopy = geo->copy();
|
| generateId(geocopy);
|
| }
|
| else {
|
| geocopy = newgeoVals[*it];
|
| }
|
|
|
|
|
| if (geocopy->is<Part::GeomLineSegment>()) {
|
| auto* geosymline = static_cast<Part::GeomLineSegment*>(geocopy);
|
| Base::Vector3d ep = geosymline->getEndPoint();
|
| Base::Vector3d ssp = geosymline->getStartPoint() + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geosymline->setPoints(
|
| ssp,
|
| ep + double(x) * displacement + double(y) * perpendicularDisplacement
|
| );
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = ssp;
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomCircle>()) {
|
| auto* geosymcircle = static_cast<Part::GeomCircle*>(geocopy);
|
| Base::Vector3d cp = geosymcircle->getCenter();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geosymcircle->setCenter(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = scp;
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomArcOfCircle>()) {
|
| auto* geoaoc = static_cast<Part::GeomArcOfCircle*>(geocopy);
|
| Base::Vector3d cp = geoaoc->getCenter();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geoaoc->setCenter(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = geoaoc->getStartPoint(true);
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomEllipse>()) {
|
| auto* geosymellipse = static_cast<Part::GeomEllipse*>(geocopy);
|
| Base::Vector3d cp = geosymellipse->getCenter();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geosymellipse->setCenter(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = scp;
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomArcOfEllipse>()) {
|
| auto* geoaoe = static_cast<Part::GeomArcOfEllipse*>(geocopy);
|
| Base::Vector3d cp = geoaoe->getCenter();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geoaoe->setCenter(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = geoaoe->getStartPoint(true);
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomArcOfHyperbola>()) {
|
| auto* geoaoe = static_cast<Part::GeomArcOfHyperbola*>(geocopy);
|
| Base::Vector3d cp = geoaoe->getCenter();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geoaoe->setCenter(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = geoaoe->getStartPoint(true);
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomArcOfParabola>()) {
|
| auto* geoaoe = static_cast<Part::GeomArcOfParabola*>(geocopy);
|
| Base::Vector3d cp = geoaoe->getCenter();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
|
|
| geoaoe->setCenter(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = geoaoe->getStartPoint(true);
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomBSplineCurve>()) {
|
| auto* geobsp = static_cast<Part::GeomBSplineCurve*>(geocopy);
|
|
|
| std::vector<Base::Vector3d> poles = geobsp->getPoles();
|
|
|
| for (auto& pole : poles) {
|
| pole = pole + double(x) * displacement + double(y) * perpendicularDisplacement;
|
| }
|
|
|
| geobsp->setPoles(poles);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = geobsp->getStartPoint();
|
| }
|
| }
|
| else if (geocopy->is<Part::GeomPoint>()) {
|
| auto* geopoint = static_cast<Part::GeomPoint*>(geocopy);
|
| Base::Vector3d cp = geopoint->getPoint();
|
| Base::Vector3d scp = cp + double(x) * displacement
|
| + double(y) * perpendicularDisplacement;
|
| geopoint->setPoint(scp);
|
|
|
| if (it == newgeoIdList.begin()) {
|
| iterfirstpoint = scp;
|
| }
|
| }
|
| else {
|
| Base::Console().error("Unsupported Geometry!! Just skipping it.\n");
|
| continue;
|
| }
|
|
|
| if (!moveonly) {
|
| newgeoVals.push_back(geocopy);
|
| geoIdMap.insert(std::make_pair(*it, cgeoid));
|
| cgeoid++;
|
| }
|
| }
|
|
|
| if (moveonly) {
|
| return;
|
| }
|
|
|
|
|
| for (const auto& constr : constrvals) {
|
| auto fit = geoIdMap.find(constr->First);
|
|
|
| if (fit == geoIdMap.end()) {
|
| continue;
|
| }
|
|
|
|
|
| if (constr->Second == GeoEnum::GeoUndef ) {
|
| if ((constr->Type == Sketcher::DistanceX || constr->Type == Sketcher::DistanceY)
|
| && constr->FirstPos != Sketcher::PointPos::none) {
|
| continue;
|
| }
|
|
|
| if ((constr->Type == Sketcher::DistanceX || constr->Type == Sketcher::DistanceY
|
| || constr->Type == Sketcher::Distance || constr->Type == Sketcher::Diameter
|
| || constr->Type == Sketcher::Weight || constr->Type == Sketcher::Radius)
|
| && clone) {
|
|
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->Type = Sketcher::Equal;
|
| constNew->isDriving = true;
|
|
|
| constNew->Second = fit->second;
|
| newconstrVals.push_back(constNew);
|
| continue;
|
| }
|
| if (!(constr->Type == Sketcher::Angle && clone)) {
|
| Constraint* constNew = constr->copy();
|
| constNew->First = fit->second;
|
| newconstrVals.push_back(constNew);
|
| continue;
|
| }
|
| if (getGeometry(constr->First)->is<Part::GeomLineSegment>()) {
|
|
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->Type = Sketcher::Parallel;
|
| constNew->isDriving = true;
|
|
|
| constNew->Second = fit->second;
|
| newconstrVals.push_back(constNew);
|
| }
|
| continue;
|
| }
|
|
|
|
|
| auto sit = geoIdMap.find(constr->Second);
|
|
|
| if (sit == geoIdMap.end()) {
|
| continue;
|
| }
|
|
|
|
|
| if (constr->Third == GeoEnum::GeoUndef) {
|
| if ((constr->Type == Sketcher::DistanceX || constr->Type == Sketcher::DistanceY
|
| || constr->Type == Sketcher::Distance)
|
| && (constr->First == constr->Second) && clone) {
|
|
|
|
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->Type = Sketcher::Equal;
|
| constNew->isDriving = true;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
|
|
| constNew->Second = fit->second;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
| continue;
|
| }
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->First = fit->second;
|
| constNew->Second = sit->second;
|
| newconstrVals.push_back(constNew);
|
| continue;
|
| }
|
|
|
| auto tit = geoIdMap.find(constr->Third);
|
|
|
| if (tit != geoIdMap.end()) {
|
| continue;
|
| }
|
|
|
|
|
| Constraint* constNew = constr->copy();
|
| constNew->First = fit->second;
|
| constNew->Second = sit->second;
|
| constNew->Third = tit->second;
|
|
|
| newconstrVals.push_back(constNew);
|
| }
|
|
|
|
|
| if (!constraindisplacement) {
|
|
|
|
|
| geoIdMap.clear();
|
| }
|
|
|
|
|
| auto* constrline = new Part::GeomLineSegment();
|
|
|
|
|
| Base::Vector3d sp = getPoint(refgeoid, refposId)
|
| + ((x == 0) ? (double(x) * displacement + double(y - 1) * perpendicularDisplacement)
|
| : (double(x - 1) * displacement + double(y) * perpendicularDisplacement));
|
|
|
|
|
| Base::Vector3d ep = iterfirstpoint;
|
| constrline->setPoints(sp, ep);
|
| GeometryFacade::setConstruction(constrline, true);
|
|
|
| generateId(constrline);
|
| newgeoVals.push_back(constrline);
|
|
|
| Constraint* constNew;
|
|
|
| if (x == 0) {
|
|
|
|
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Coincident;
|
| constNew->First = prevrowstartfirstgeoid;
|
| constNew->FirstPos = refposId;
|
| constNew->Second = cgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::start;
|
| newconstrVals.push_back(constNew);
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Coincident;
|
| constNew->First = iterfirstgeoid;
|
| constNew->FirstPos = refposId;
|
| constNew->Second = cgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::end;
|
| newconstrVals.push_back(constNew);
|
|
|
|
|
|
|
| if (y == 1) {
|
| rowrefgeoid = cgeoid;
|
| cgeoid++;
|
|
|
|
|
| if (perpscale == 1.0) {
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Equal;
|
| constNew->First = rowrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->Second = colrefgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
| }
|
| else {
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Distance;
|
| constNew->First = rowrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->setValue(perpendicularDisplacement.Length());
|
| newconstrVals.push_back(constNew);
|
| }
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Perpendicular;
|
| constNew->First = rowrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->Second = colrefgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
| }
|
| else {
|
|
|
| cgeoid++;
|
|
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Equal;
|
| constNew->First = rowrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->Second = cgeoid - 1;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Perpendicular;
|
| constNew->First = cgeoid - 1;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->Second = colrefgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
| }
|
| }
|
| else {
|
|
|
|
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Coincident;
|
| constNew->First = prevfirstgeoid;
|
| constNew->FirstPos = refposId;
|
| constNew->Second = cgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::start;
|
| newconstrVals.push_back(constNew);
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Coincident;
|
| constNew->First = iterfirstgeoid;
|
| constNew->FirstPos = refposId;
|
| constNew->Second = cgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::end;
|
| newconstrVals.push_back(constNew);
|
|
|
| if (y == 0 && x == 1) {
|
|
|
| colrefgeoid = cgeoid;
|
| cgeoid++;
|
|
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Distance;
|
| constNew->First = colrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->setValue(displacement.Length());
|
| newconstrVals.push_back(constNew);
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Angle;
|
| constNew->First = colrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->setValue(atan2(displacement.y, displacement.x));
|
| newconstrVals.push_back(constNew);
|
| }
|
| else {
|
|
|
| cgeoid++;
|
|
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Equal;
|
| constNew->First = colrefgeoid;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->Second = cgeoid - 1;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
|
|
| constNew = new Constraint();
|
| constNew->Type = Sketcher::Parallel;
|
| constNew->First = cgeoid - 1;
|
| constNew->FirstPos = Sketcher::PointPos::none;
|
| constNew->Second = colrefgeoid;
|
| constNew->SecondPos = Sketcher::PointPos::none;
|
| newconstrVals.push_back(constNew);
|
| }
|
| }
|
|
|
|
|
|
|
| geoIdMap.clear();
|
| };
|
|
|
| for (y = 0; y < rsize; y++) {
|
| for (x = 0; x < csize; x++) {
|
| makeCopyAtRowColumn(x, y);
|
| }
|
| }
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| Geometry.setValues(std::move(newgeoVals));
|
|
|
| if (newconstrVals.size() > constrvals.size()) {
|
| Constraints.setValues(std::move(newconstrVals));
|
| }
|
| }
|
|
|
|
|
|
|
|
|
| Geometry.touch();
|
|
|
| return Geometry.getSize() - 1;
|
| }
|
|
|
|
|
| int SketchObject::removeAxesAlignment(const std::vector<int>& geoIdList)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& constrvals = this->Constraints.getValues();
|
|
|
| std::map<Sketcher::ConstraintType, size_t> numConstrOfType =
|
| {{Sketcher::Horizontal, 0}, {Sketcher::Vertical, 0}};
|
|
|
| bool changed = false;
|
|
|
| std::vector<std::pair<size_t, Sketcher::ConstraintType>> changeConstraintIndices;
|
|
|
| auto chooseActionForConstraint = [&]
|
| (size_t i, const int geoid) {
|
| if (!constrvals[i]->involvesGeoId(geoid)) {
|
| return;
|
| }
|
| switch (constrvals[i]->Type) {
|
| case Sketcher::Horizontal:
|
| case Sketcher::Vertical: {
|
| if (constrvals[i]->FirstPos == Sketcher::PointPos::none
|
| && constrvals[i]->SecondPos == Sketcher::PointPos::none) {
|
| changeConstraintIndices.emplace_back(i, constrvals[i]->Type);
|
| numConstrOfType[constrvals[i]->Type]++;
|
| }
|
| break;
|
| }
|
| case Sketcher::Symmetric: {
|
|
|
| if ((constrvals[i]->Third == GeoEnum::HAxis || constrvals[i]->Third == GeoEnum::VAxis)
|
| && constrvals[i]->ThirdPos == Sketcher::PointPos::none)
|
| changeConstraintIndices.emplace_back(i, constrvals[i]->Type);
|
| break;
|
| }
|
| case Sketcher::PointOnObject: {
|
| if ((constrvals[i]->Second == GeoEnum::HAxis || constrvals[i]->Second == GeoEnum::VAxis)
|
| && constrvals[i]->SecondPos == Sketcher::PointPos::none)
|
| changeConstraintIndices.emplace_back(i, constrvals[i]->Type);
|
| break;
|
| }
|
| case Sketcher::DistanceX:
|
| case Sketcher::DistanceY: {
|
| changeConstraintIndices.emplace_back(i, constrvals[i]->Type);
|
| break;
|
| }
|
| default:
|
| break;
|
| }
|
| };
|
|
|
| for (size_t i = 0; i < constrvals.size(); i++) {
|
| for (const auto& geoid : geoIdList) {
|
| chooseActionForConstraint(i, geoid);
|
| }
|
| }
|
|
|
| if (changeConstraintIndices.empty())
|
| return 0;
|
|
|
| std::vector<Constraint*> newconstrVals;
|
| newconstrVals.reserve(constrvals.size());
|
|
|
| std::map<Sketcher::ConstraintType, int> refConstrOfType =
|
| {{Sketcher::Horizontal, GeoEnum::GeoUndef},
|
| {Sketcher::Vertical, GeoEnum::GeoUndef}};
|
|
|
| int cindex = 0;
|
| for (size_t i = 0; i < constrvals.size(); i++) {
|
| if (i != changeConstraintIndices[cindex].first) {
|
| newconstrVals.push_back(constrvals[i]);
|
| continue;
|
| }
|
|
|
| switch (changeConstraintIndices[cindex].second) {
|
| case Sketcher::Horizontal:
|
| case Sketcher::Vertical: {
|
| if (!(numConstrOfType[changeConstraintIndices[cindex].second] > 0)) {
|
| break;
|
| }
|
| changed = true;
|
| if (refConstrOfType[changeConstraintIndices[cindex].second] == GeoEnum::GeoUndef) {
|
| refConstrOfType[changeConstraintIndices[cindex].second] = constrvals[i]->First;
|
| ++cindex;
|
| continue;
|
| }
|
| auto newConstr = new Constraint();
|
|
|
| newConstr->Type = Sketcher::Parallel;
|
| newConstr->First = refConstrOfType[changeConstraintIndices[cindex].second];
|
| newConstr->Second = constrvals[i]->First;
|
|
|
| newconstrVals.push_back(newConstr);
|
| break;
|
| }
|
| case Sketcher::Symmetric:
|
| case Sketcher::PointOnObject: {
|
| changed = true;
|
| break;
|
| }
|
| case Sketcher::DistanceX:
|
| case Sketcher::DistanceY: {
|
| changed = true;
|
|
|
| newconstrVals.push_back(constrvals[i]->clone());
|
| newconstrVals.back()->Type = Sketcher::Distance;
|
| break;
|
| }
|
| default: break;
|
| }
|
|
|
| ++cindex;
|
| }
|
|
|
| if (numConstrOfType[Sketcher::Horizontal] > 0 && numConstrOfType[Sketcher::Vertical] > 0) {
|
| auto newConstr = new Constraint();
|
|
|
| newConstr->Type = Sketcher::Perpendicular;
|
| newConstr->First = refConstrOfType[Sketcher::Horizontal];
|
| newConstr->Second = refConstrOfType[Sketcher::Vertical];
|
|
|
| newconstrVals.push_back(newConstr);
|
| }
|
|
|
| if (changed) {
|
| Constraints.setValues(std::move(newconstrVals));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| template <>
|
| int SketchObject::exposeInternalGeometryForType<Part::GeomEllipse>(const int GeoId)
|
| {
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| bool major = false;
|
| bool minor = false;
|
| bool focus1 = false;
|
| bool focus2 = false;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| for (const auto& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::EllipseMajorDiameter:
|
| major = true;
|
| break;
|
| case Sketcher::EllipseMinorDiameter:
|
| minor = true;
|
| break;
|
| case Sketcher::EllipseFocus1:
|
| focus1 = true;
|
| break;
|
| case Sketcher::EllipseFocus2:
|
| focus2 = true;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
| int currentgeoid = getHighestCurveIndex();
|
| int incrgeo = 0;
|
|
|
| std::vector<Part::Geometry*> igeo;
|
| std::vector<Constraint*> icon;
|
|
|
| const auto* ellipse = static_cast<const Part::GeomEllipse*>(geo);
|
|
|
| Base::Vector3d center {ellipse->getCenter()};
|
| double majord {ellipse->getMajorRadius()};
|
| double minord {ellipse->getMinorRadius()};
|
| Base::Vector3d majdir {ellipse->getMajorAxisDir()};
|
|
|
| Base::Vector3d mindir = Vector3d(-majdir.y, majdir.x);
|
|
|
| Base::Vector3d majorpositiveend = center + majord * majdir;
|
| Base::Vector3d majornegativeend = center - majord * majdir;
|
| Base::Vector3d minorpositiveend = center + minord * mindir;
|
| Base::Vector3d minornegativeend = center - minord * mindir;
|
|
|
| double df = sqrt(majord * majord - minord * minord);
|
|
|
| Base::Vector3d focus1P = center + df * majdir;
|
| Base::Vector3d focus2P = center - df * majdir;
|
|
|
| if (!major) {
|
| auto* lmajor = new Part::GeomLineSegment();
|
| lmajor->setPoints(majorpositiveend, majornegativeend);
|
|
|
| igeo.push_back(lmajor);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseMajorDiameter;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!minor) {
|
| auto* lminor = new Part::GeomLineSegment();
|
| lminor->setPoints(minorpositiveend, minornegativeend);
|
|
|
| igeo.push_back(lminor);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseMinorDiameter;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!focus1) {
|
| auto* pf1 = new Part::GeomPoint();
|
| pf1->setPoint(focus1P);
|
|
|
| igeo.push_back(pf1);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseFocus1;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!focus2) {
|
| auto* pf2 = new Part::GeomPoint();
|
| pf2->setPoint(focus2P);
|
| igeo.push_back(pf2);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseFocus2;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| }
|
|
|
| addAndCleanup(igeo, icon);
|
| return incrgeo;
|
| }
|
|
|
| void SketchObject::addAndCleanup(std::vector<Part::Geometry*> igeo, std::vector<Constraint*> icon)
|
| {
|
| this->addGeometry(igeo, true);
|
| this->addConstraints(icon);
|
|
|
| for (auto& geoToDelete : igeo) {
|
| delete geoToDelete;
|
| }
|
|
|
| for (auto& constraintToDelete : icon) {
|
| delete constraintToDelete;
|
| }
|
| }
|
|
|
|
|
| template <>
|
| int SketchObject::exposeInternalGeometryForType<Part::GeomArcOfEllipse>(const int GeoId)
|
| {
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| bool major = false;
|
| bool minor = false;
|
| bool focus1 = false;
|
| bool focus2 = false;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| for (const auto& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::EllipseMajorDiameter:
|
| major = true;
|
| break;
|
| case Sketcher::EllipseMinorDiameter:
|
| minor = true;
|
| break;
|
| case Sketcher::EllipseFocus1:
|
| focus1 = true;
|
| break;
|
| case Sketcher::EllipseFocus2:
|
| focus2 = true;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
| int currentgeoid = getHighestCurveIndex();
|
| int incrgeo = 0;
|
|
|
| std::vector<Part::Geometry*> igeo;
|
| std::vector<Constraint*> icon;
|
|
|
| const auto* aoe = static_cast<const Part::GeomArcOfEllipse*>(geo);
|
|
|
| Base::Vector3d center {aoe->getCenter()};
|
| double majord {aoe->getMajorRadius()};
|
| double minord {aoe->getMinorRadius()};
|
| Base::Vector3d majdir {aoe->getMajorAxisDir()};
|
|
|
| Base::Vector3d mindir {-majdir.y, majdir.x};
|
|
|
| Base::Vector3d majorpositiveend {center + majord * majdir};
|
| Base::Vector3d majornegativeend {center - majord * majdir};
|
| Base::Vector3d minorpositiveend {center + minord * mindir};
|
| Base::Vector3d minornegativeend {center - minord * mindir};
|
|
|
| double df = sqrt(majord * majord - minord * minord);
|
|
|
| Base::Vector3d focus1P {center + df * majdir};
|
| Base::Vector3d focus2P {center - df * majdir};
|
|
|
| if (!major) {
|
| auto* lmajor = new Part::GeomLineSegment();
|
| lmajor->setPoints(majorpositiveend, majornegativeend);
|
|
|
| igeo.push_back(lmajor);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseMajorDiameter;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!minor) {
|
| auto* lminor = new Part::GeomLineSegment();
|
| lminor->setPoints(minorpositiveend, minornegativeend);
|
|
|
| igeo.push_back(lminor);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseMinorDiameter;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!focus1) {
|
| auto* pf1 = new Part::GeomPoint();
|
| pf1->setPoint(focus1P);
|
|
|
| igeo.push_back(pf1);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseFocus1;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!focus2) {
|
| auto* pf2 = new Part::GeomPoint();
|
| pf2->setPoint(focus2P);
|
| igeo.push_back(pf2);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = EllipseFocus2;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| }
|
|
|
| addAndCleanup(igeo, icon);
|
| return incrgeo;
|
| }
|
|
|
| template <>
|
| int SketchObject::exposeInternalGeometryForType<Part::GeomArcOfHyperbola>(const int GeoId)
|
| {
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| bool major = false;
|
| bool minor = false;
|
| bool focus = false;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| for (auto const& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::HyperbolaMajor:
|
| major = true;
|
| break;
|
| case Sketcher::HyperbolaMinor:
|
| minor = true;
|
| break;
|
| case Sketcher::HyperbolaFocus:
|
| focus = true;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
| int currentgeoid = getHighestCurveIndex();
|
| int incrgeo = 0;
|
|
|
| const auto* aoh = static_cast<const Part::GeomArcOfHyperbola*>(geo);
|
|
|
| Base::Vector3d center {aoh->getCenter()};
|
| double majord {aoh->getMajorRadius()};
|
| double minord {aoh->getMinorRadius()};
|
| Base::Vector3d majdir {aoh->getMajorAxisDir()};
|
|
|
| std::vector<Part::Geometry*> igeo;
|
| std::vector<Constraint*> icon;
|
|
|
| Base::Vector3d mindir = Vector3d(-majdir.y, majdir.x);
|
|
|
| Base::Vector3d majorpositiveend = center + majord * majdir;
|
| Base::Vector3d majornegativeend = center - majord * majdir;
|
| Base::Vector3d minorpositiveend = majorpositiveend + minord * mindir;
|
| Base::Vector3d minornegativeend = majorpositiveend - minord * mindir;
|
|
|
| double df = sqrt(majord * majord + minord * minord);
|
|
|
| Base::Vector3d focus1P = center + df * majdir;
|
|
|
| if (!major) {
|
| auto* lmajor = new Part::GeomLineSegment();
|
| lmajor->setPoints(majorpositiveend, majornegativeend);
|
|
|
| igeo.push_back(lmajor);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::HyperbolaMajor;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
| if (!minor) {
|
| auto* lminor = new Part::GeomLineSegment();
|
| lminor->setPoints(minorpositiveend, minornegativeend);
|
|
|
| igeo.push_back(lminor);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::HyperbolaMinor;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
|
|
| incrgeo++;
|
| }
|
| if (!focus) {
|
| auto* pf1 = new Part::GeomPoint();
|
| pf1->setPoint(focus1P);
|
|
|
| igeo.push_back(pf1);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::HyperbolaFocus;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
|
|
| addAndCleanup(igeo, icon);
|
| return incrgeo;
|
| }
|
|
|
| template <>
|
| int SketchObject::exposeInternalGeometryForType<Part::GeomArcOfParabola>(const int GeoId)
|
| {
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| bool focus = false;
|
| bool focus_to_vertex = false;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| for (auto const& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::ParabolaFocus:
|
| focus = true;
|
| break;
|
| case Sketcher::ParabolaFocalAxis:
|
| focus_to_vertex = true;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
| int currentgeoid = getHighestCurveIndex();
|
| int incrgeo = 0;
|
|
|
| const auto* aop = static_cast<const Part::GeomArcOfParabola*>(geo);
|
|
|
| Base::Vector3d center {aop->getCenter()};
|
| Base::Vector3d focusp {aop->getFocus()};
|
|
|
| std::vector<Part::Geometry*> igeo;
|
| std::vector<Constraint*> icon;
|
|
|
| if (!focus) {
|
| auto* pf1 = new Part::GeomPoint();
|
| pf1->setPoint(focusp);
|
|
|
| igeo.push_back(pf1);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::ParabolaFocus;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
| incrgeo++;
|
| }
|
|
|
| if (!focus_to_vertex) {
|
| auto* paxis = new Part::GeomLineSegment();
|
| paxis->setPoints(center, focusp);
|
|
|
| igeo.push_back(paxis);
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::ParabolaFocalAxis;
|
| newConstr->First = currentgeoid + incrgeo + 1;
|
| newConstr->FirstPos = Sketcher::PointPos::none;
|
| newConstr->Second = GeoId;
|
|
|
| icon.push_back(newConstr);
|
|
|
| incrgeo++;
|
| }
|
|
|
| addAndCleanup(igeo, icon);
|
| return incrgeo;
|
| }
|
|
|
| template <>
|
| int SketchObject::exposeInternalGeometryForType<Part::GeomBSplineCurve>(const int GeoId)
|
| {
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| const auto* bsp = static_cast<const Part::GeomBSplineCurve*>(geo);
|
|
|
| std::vector<int> controlpointgeoids(bsp->countPoles(), GeoEnum::GeoUndef);
|
|
|
| std::vector<int> knotgeoids(bsp->countKnots(), GeoEnum::GeoUndef);
|
|
|
| bool isfirstweightconstrained = false;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
|
|
| for (auto const& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::BSplineControlPoint:
|
| controlpointgeoids[constr->InternalAlignmentIndex] = constr->First;
|
| break;
|
| case Sketcher::BSplineKnotPoint:
|
| knotgeoids[constr->InternalAlignmentIndex] = constr->First;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
| if (controlpointgeoids[0] != GeoEnum::GeoUndef) {
|
| isfirstweightconstrained =
|
| std::ranges::any_of(vals, [&controlpointgeoids](const auto& constr) {
|
| return (constr->Type == Sketcher::Weight && constr->First == controlpointgeoids[0]);
|
| });
|
| }
|
|
|
| int currentgeoid = getHighestCurveIndex();
|
| int incrgeo = 0;
|
|
|
| std::vector<Part::Geometry*> igeo;
|
| std::vector<Constraint*> icon;
|
|
|
| std::vector<Base::Vector3d> poles = bsp->getPoles();
|
| std::vector<double> weights = bsp->getWeights();
|
| std::vector<double> knots = bsp->getKnots();
|
|
|
| double distance_p0_p1 = (poles[1] - poles[0]).Length();
|
|
|
| for (size_t index = 0; index < controlpointgeoids.size(); ++index) {
|
| auto& cpGeoId = controlpointgeoids.at(index);
|
| if (cpGeoId != GeoEnum::GeoUndef) {
|
| continue;
|
| }
|
|
|
|
|
| auto* pc = new Part::GeomCircle();
|
| pc->setCenter(poles[index]);
|
| pc->setRadius(distance_p0_p1 / 6);
|
|
|
| igeo.push_back(pc);
|
| incrgeo++;
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::BSplineControlPoint;
|
| newConstr->First = currentgeoid + incrgeo;
|
| newConstr->FirstPos = Sketcher::PointPos::mid;
|
| newConstr->Second = GeoId;
|
| newConstr->InternalAlignmentIndex = index;
|
|
|
| icon.push_back(newConstr);
|
|
|
| if (index == 0) {
|
| controlpointgeoids[0] = currentgeoid + incrgeo;
|
| if (weights[0] == 1.0) {
|
|
|
| auto* newConstr3 = new Sketcher::Constraint();
|
| newConstr3->Type = Sketcher::Weight;
|
| newConstr3->First = controlpointgeoids[0];
|
| newConstr3->setValue(weights[0]);
|
|
|
| icon.push_back(newConstr3);
|
|
|
| isfirstweightconstrained = true;
|
| }
|
|
|
| continue;
|
| }
|
|
|
| if (isfirstweightconstrained && weights[0] == weights[index]) {
|
|
|
|
|
| auto* newConstr2 = new Sketcher::Constraint();
|
| newConstr2->Type = Sketcher::Equal;
|
| newConstr2->First = currentgeoid + incrgeo;
|
| newConstr2->FirstPos = Sketcher::PointPos::none;
|
| newConstr2->Second = controlpointgeoids[0];
|
| newConstr2->SecondPos = Sketcher::PointPos::none;
|
|
|
| icon.push_back(newConstr2);
|
| }
|
| }
|
|
|
| for (size_t index = 0; index < knotgeoids.size(); ++index) {
|
| auto& kGeoId = knotgeoids.at(index);
|
| if (kGeoId != GeoEnum::GeoUndef) {
|
| continue;
|
| }
|
|
|
|
|
| auto* kp = new Part::GeomPoint();
|
|
|
| kp->setPoint(bsp->pointAtParameter(knots[index]));
|
|
|
| igeo.push_back(kp);
|
| incrgeo++;
|
|
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::BSplineKnotPoint;
|
| newConstr->First = currentgeoid + incrgeo;
|
| newConstr->FirstPos = Sketcher::PointPos::start;
|
| newConstr->Second = GeoId;
|
| newConstr->InternalAlignmentIndex = index;
|
|
|
| icon.push_back(newConstr);
|
| }
|
|
|
| Q_UNUSED(isfirstweightconstrained);
|
|
|
| addAndCleanup(igeo, icon);
|
| return incrgeo;
|
| }
|
|
|
| int SketchObject::exposeInternalGeometry(int GeoId)
|
| {
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex())
|
| return -1;
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (geo->is<Part::GeomEllipse>()) {
|
| return exposeInternalGeometryForType<Part::GeomEllipse>(GeoId);
|
| }
|
| else if (geo->is<Part::GeomArcOfEllipse>()) {
|
| return exposeInternalGeometryForType<Part::GeomArcOfEllipse>(GeoId);
|
| }
|
| else if (geo->is<Part::GeomArcOfHyperbola>()) {
|
| return exposeInternalGeometryForType<Part::GeomArcOfHyperbola>(GeoId);
|
| }
|
| else if (geo->is<Part::GeomArcOfParabola>()) {
|
| return exposeInternalGeometryForType<Part::GeomArcOfParabola>(GeoId);
|
| }
|
| else if (geo->is<Part::GeomBSplineCurve>()) {
|
| return exposeInternalGeometryForType<Part::GeomBSplineCurve>(GeoId);
|
| }
|
| else
|
| return -1;
|
| }
|
|
|
| int SketchObject::deleteUnusedInternalGeometry(int GeoId, bool delgeoid)
|
| {
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex())
|
| return -1;
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (geo->is<Part::GeomEllipse>()
|
| || geo->is<Part::GeomArcOfEllipse>()
|
| || geo->is<Part::GeomArcOfHyperbola>()) {
|
| return deleteUnusedInternalGeometryWhenTwoFoci(GeoId, delgeoid);
|
| }
|
|
|
| if (geo->is<Part::GeomArcOfParabola>()) {
|
| return deleteUnusedInternalGeometryWhenOneFocus(GeoId, delgeoid);
|
| }
|
|
|
| if (geo->is<Part::GeomBSplineCurve>()) {
|
| return deleteUnusedInternalGeometryWhenBSpline(GeoId, delgeoid);
|
| }
|
|
|
|
|
| return -1;
|
| }
|
|
|
| int SketchObject::deleteUnusedInternalGeometryWhenTwoFoci(int GeoId, bool delgeoid)
|
| {
|
| int majorelementindex = -1;
|
| int minorelementindex = -1;
|
| int focus1elementindex = -1;
|
| int focus2elementindex = -1;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| for (auto const& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::EllipseMajorDiameter:
|
| case Sketcher::HyperbolaMajor:
|
| majorelementindex = constr->First;
|
| break;
|
| case Sketcher::EllipseMinorDiameter:
|
| case Sketcher::HyperbolaMinor:
|
| minorelementindex = constr->First;
|
| break;
|
| case Sketcher::EllipseFocus1:
|
| case Sketcher::HyperbolaFocus:
|
| focus1elementindex = constr->First;
|
| break;
|
| case Sketcher::EllipseFocus2:
|
| focus2elementindex = constr->First;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
|
|
| int majorconstraints = 0;
|
| int minorconstraints = 0;
|
| int focus1constraints = 0;
|
| int focus2constraints = 0;
|
|
|
| for (const auto& constr : vals) {
|
| if (constr->involvesGeoId(majorelementindex))
|
| majorconstraints++;
|
| else if (constr->involvesGeoId(minorelementindex))
|
| minorconstraints++;
|
| else if (constr->involvesGeoId(focus1elementindex))
|
| focus1constraints++;
|
| else if (constr->involvesGeoId(focus2elementindex))
|
| focus2constraints++;
|
| }
|
|
|
| std::vector<int> delgeometries;
|
|
|
|
|
| if (focus2constraints < 2)
|
| delgeometries.push_back(focus2elementindex);
|
|
|
| if (focus1constraints < 2)
|
| delgeometries.push_back(focus1elementindex);
|
|
|
| if (minorconstraints < 2)
|
| delgeometries.push_back(minorelementindex);
|
|
|
| if (majorconstraints < 2)
|
| delgeometries.push_back(majorelementindex);
|
|
|
| if (delgeoid)
|
| delgeometries.push_back(GeoId);
|
|
|
|
|
| std::sort(delgeometries.begin(), delgeometries.end(), std::greater<>());
|
|
|
| for (auto& dGeoId : delgeometries) {
|
| delGeometry(dGeoId, DeleteOption::UpdateGeometry);
|
| }
|
|
|
| int ndeleted = delgeometries.size();
|
|
|
| return ndeleted;
|
| }
|
|
|
| int SketchObject::deleteUnusedInternalGeometryWhenOneFocus(int GeoId, bool delgeoid)
|
| {
|
|
|
|
|
|
|
| int majorelementindex = -1;
|
| int focus1elementindex = -1;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| for (auto const& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::ParabolaFocus:
|
| focus1elementindex = constr->First;
|
| break;
|
| case Sketcher::ParabolaFocalAxis:
|
| majorelementindex = constr->First;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
|
|
|
|
|
|
| int majorconstraints = 0;
|
| int focus1constraints = 0;
|
|
|
| for (const auto& constr : vals) {
|
| if (constr->involvesGeoId(majorelementindex)) {
|
| majorconstraints++;
|
| }
|
| else if (constr->involvesGeoId(focus1elementindex)) {
|
| focus1constraints++;
|
| }
|
| }
|
|
|
| std::vector<int> delgeometries;
|
|
|
|
|
| if (majorelementindex != -1 && majorconstraints < 2)
|
| delgeometries.push_back(majorelementindex);
|
|
|
|
|
| if (focus1elementindex != -1 && focus1constraints < 2)
|
| delgeometries.push_back(focus1elementindex);
|
|
|
| if (delgeoid)
|
| delgeometries.push_back(GeoId);
|
|
|
|
|
| std::sort(delgeometries.begin(), delgeometries.end(), std::greater<>());
|
|
|
| for (auto& dGeoId : delgeometries) {
|
| delGeometry(dGeoId, DeleteOption::UpdateGeometry);
|
| }
|
|
|
| int ndeleted = delgeometries.size();
|
|
|
| delgeometries.clear();
|
|
|
| return ndeleted;
|
| }
|
|
|
| int SketchObject::deleteUnusedInternalGeometryWhenBSpline(int GeoId, bool delgeoid)
|
| {
|
|
|
| std::map<int, int> poleGeoIdsAndConstraints;
|
| std::map<int, int> knotGeoIdsAndConstraints;
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
|
|
| for (auto const& constr : vals) {
|
| if (constr->Type != Sketcher::InternalAlignment || constr->Second != GeoId) {
|
| continue;
|
| }
|
|
|
| switch (constr->AlignmentType) {
|
| case Sketcher::BSplineControlPoint:
|
| poleGeoIdsAndConstraints[constr->First] = 0;
|
| break;
|
| case Sketcher::BSplineKnotPoint:
|
| knotGeoIdsAndConstraints[constr->First] = 0;
|
| break;
|
| default:
|
| return -1;
|
| }
|
| }
|
|
|
| std::vector<int> delgeometries;
|
|
|
|
|
|
|
| for (auto const& constr : vals) {
|
|
|
|
|
| if (constr->Type == Sketcher::InternalAlignment
|
| || constr->Type == Sketcher::Weight) {
|
| continue;
|
| }
|
| bool firstIsInCPGeoIds = poleGeoIdsAndConstraints.count(constr->First) == 1;
|
| bool secondIsInCPGeoIds = poleGeoIdsAndConstraints.count(constr->Second) == 1;
|
| if (constr->Type == Sketcher::Equal && firstIsInCPGeoIds == secondIsInCPGeoIds) {
|
| continue;
|
| }
|
|
|
| if (firstIsInCPGeoIds) {
|
| ++poleGeoIdsAndConstraints[constr->First];
|
| }
|
| if (secondIsInCPGeoIds) {
|
| ++poleGeoIdsAndConstraints[constr->Second];
|
| }
|
| }
|
|
|
| for (auto& [cpGeoId, numConstr] : poleGeoIdsAndConstraints) {
|
| if (numConstr < 1) {
|
| delgeometries.push_back(cpGeoId);
|
| }
|
| }
|
|
|
| for (auto& [kGeoId, numConstr] : knotGeoIdsAndConstraints) {
|
|
|
|
|
| auto tempGeoID = kGeoId;
|
| numConstr = std::count_if(vals.begin(), vals.end(), [&tempGeoID](const auto& constr) {
|
| return constr->involvesGeoId(tempGeoID);
|
| });
|
|
|
| if (numConstr < 2) {
|
| delgeometries.push_back(kGeoId);
|
| }
|
| }
|
|
|
| if (delgeoid) {
|
| delgeometries.push_back(GeoId);
|
| }
|
|
|
| int ndeleted = delGeometriesExclusiveList(delgeometries);
|
|
|
| return ndeleted;
|
| }
|
|
|
| int SketchObject::deleteUnusedInternalGeometryAndUpdateGeoId(int& GeoId, bool delgeoid)
|
| {
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (!hasInternalGeometry(geo)) {
|
| return -1;
|
| }
|
|
|
|
|
|
|
| boost::uuids::uuid GeoIdTag;
|
|
|
| GeoIdTag = geo->getTag();
|
|
|
| int returnValue = deleteUnusedInternalGeometry(GeoId, delgeoid);
|
|
|
| if (delgeoid) {
|
| GeoId = GeoEnum::GeoUndef;
|
| return returnValue;
|
| }
|
|
|
| auto vals = getCompleteGeometry();
|
|
|
| for (size_t i = 0; i < vals.size(); i++) {
|
| if (vals[i]->getTag() == GeoIdTag) {
|
| GeoId = getGeoIdFromCompleteGeometryIndex(i);
|
| break;
|
| }
|
| }
|
|
|
| return returnValue;
|
| }
|
|
|
| bool SketchObject::convertToNURBS(int GeoId)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId > getHighestCurveIndex()
|
| || (GeoId < 0 && -GeoId > static_cast<int>(ExternalGeo.getSize())) || GeoId == -1
|
| || GeoId == -2)
|
| return false;
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (geo->is<Part::GeomPoint>())
|
| return false;
|
|
|
| const auto* geo1 = static_cast<const Part::GeomCurve*>(geo);
|
|
|
| Part::GeomBSplineCurve* bspline;
|
|
|
| try {
|
| bspline = geo1->toNurbs(geo1->getFirstParameter(), geo1->getLastParameter());
|
|
|
| if (geo1->isDerivedFrom<Part::GeomArcOfConic>()) {
|
| const auto* geoaoc = static_cast<const Part::GeomArcOfConic*>(geo1);
|
|
|
| if (geoaoc->isReversed())
|
| bspline->reverse();
|
| }
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
|
|
| return false;
|
| }
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
|
|
| if (GeoId < 0) {
|
| newVals.push_back(bspline);
|
| generateId(bspline);
|
| }
|
| else {
|
|
|
| newVals[GeoId] = bspline;
|
| GeometryFacade::copyId(geo, bspline);
|
|
|
| const std::vector<Sketcher::Constraint*>& cvals = Constraints.getValues();
|
|
|
| std::vector<Constraint*> newcVals(cvals);
|
|
|
| int index = cvals.size() - 1;
|
|
|
|
|
|
|
| for (; index >= 0; index--) {
|
| auto otherthancoincident = cvals[index]->Type != Sketcher::Coincident
|
| && cvals[index]->involvesGeoId(GeoId);
|
|
|
| auto coincidentonmidpoint = cvals[index]->Type == Sketcher::Coincident
|
| && cvals[index]->involvesGeoIdAndPosId(GeoId, Sketcher::PointPos::mid);
|
|
|
| if (otherthancoincident || coincidentonmidpoint)
|
| newcVals.erase(newcVals.begin() + index);
|
| }
|
|
|
| this->Constraints.setValues(std::move(newcVals));
|
| }
|
|
|
| Geometry.setValues(std::move(newVals));
|
| }
|
|
|
|
|
|
|
|
|
| Geometry.touch();
|
|
|
| return true;
|
| }
|
|
|
| bool SketchObject::increaseBSplineDegree(int GeoId, int degreeincrement )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex()) {
|
| return false;
|
| }
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (!geo->is<Part::GeomBSplineCurve>()) {
|
| return false;
|
| }
|
|
|
| const auto* bsp = static_cast<const Part::GeomBSplineCurve*>(geo);
|
|
|
| const Handle(Geom_BSplineCurve) curve = Handle(Geom_BSplineCurve)::DownCast(bsp->handle());
|
|
|
| std::unique_ptr<Part::GeomBSplineCurve> bspline(new Part::GeomBSplineCurve(curve));
|
|
|
| try {
|
| int cdegree = bspline->getDegree();
|
|
|
| bspline->increaseDegree(cdegree + degreeincrement);
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
| return false;
|
| }
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
| GeometryFacade::copyId(geo, bspline.get());
|
| newVals[GeoId] = bspline.release();
|
|
|
|
|
| Geometry.setValues(std::move(newVals));
|
|
|
| return true;
|
| }
|
|
|
| bool SketchObject::decreaseBSplineDegree(int GeoId, int degreedecrement )
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex())
|
| return false;
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (!geo->is<Part::GeomBSplineCurve>())
|
| return false;
|
|
|
| const auto* bsp = static_cast<const Part::GeomBSplineCurve*>(geo);
|
|
|
| const Handle(Geom_BSplineCurve) curve = Handle(Geom_BSplineCurve)::DownCast(bsp->handle());
|
|
|
| std::unique_ptr<Part::GeomBSplineCurve> bspline(new Part::GeomBSplineCurve(curve));
|
|
|
| try {
|
| int cdegree = bspline->getDegree();
|
|
|
|
|
| int maxdegree = cdegree - degreedecrement;
|
| if (maxdegree == 0)
|
| return false;
|
| bspline->approximate(Precision::Confusion(), 20, maxdegree, GeomAbs_C0);
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
| return false;
|
| }
|
|
|
|
|
|
|
| #if 0
|
| const std::vector< Part::Geometry * > &vals = getInternalGeometry();
|
|
|
| std::vector< Part::Geometry * > newVals(vals);
|
|
|
| newVals[GeoId] = bspline.release();
|
|
|
|
|
| Geometry.setValues(newVals);
|
| #else
|
| delGeometry(GeoId);
|
| int newId = addGeometry(bspline.release());
|
| exposeInternalGeometry(newId);
|
| #endif
|
|
|
| return true;
|
| }
|
|
|
|
|
| bool SketchObject::modifyBSplineKnotMultiplicity(int GeoId, int knotIndex, int multiplicityincr)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex()) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP("Exceptions", "B-spline Geometry Index (GeoID) is out of bounds.")
|
| );
|
| }
|
|
|
| if (multiplicityincr == 0) {
|
|
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP("Exceptions", "You are requesting no change in knot multiplicity.")
|
| );
|
| }
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (!geo->is<Part::GeomBSplineCurve>()) {
|
| THROWMT(
|
| Base::TypeError,
|
| QT_TRANSLATE_NOOP("Exceptions", "The Geometry Index (GeoId) provided is not a B-spline.")
|
| );
|
| }
|
|
|
| const auto* bsp = static_cast<const Part::GeomBSplineCurve*>(geo);
|
|
|
| int degree = bsp->getDegree();
|
|
|
| if (knotIndex > bsp->countKnots() || knotIndex < 1) {
|
|
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP(
|
| "Exceptions",
|
| "The knot index is out of bounds. Note that in accordance with "
|
| "OCC notation, the first knot has index 1 and not zero."
|
| )
|
| );
|
| }
|
|
|
| std::unique_ptr<Part::GeomBSplineCurve> bspline;
|
|
|
| int curmult = bsp->getMultiplicity(knotIndex);
|
|
|
|
|
| if ((curmult + multiplicityincr) > degree) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP(
|
| "Exceptions",
|
| "The multiplicity cannot be increased beyond the degree of the B-spline."
|
| )
|
| );
|
| }
|
|
|
|
|
| if ((curmult + multiplicityincr) < 0) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP("Exceptions", "The multiplicity cannot be decreased beyond zero.")
|
| );
|
| }
|
|
|
| try {
|
| bspline.reset(static_cast<Part::GeomBSplineCurve*>(bsp->clone()));
|
|
|
| if (multiplicityincr > 0) {
|
| bspline->increaseMultiplicity(knotIndex, curmult + multiplicityincr);
|
| }
|
| else {
|
| bool result = bspline->removeKnot(knotIndex, curmult + multiplicityincr, 1E6);
|
|
|
| if (!result) {
|
| THROWMT(
|
| Base::CADKernelError,
|
| QT_TRANSLATE_NOOP(
|
| "Exceptions",
|
| "OCC is unable to decrease the multiplicity within the "
|
| "maximum tolerance."
|
| )
|
| );
|
| }
|
| }
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
| return false;
|
| }
|
|
|
|
|
|
|
| std::vector<int> delGeoId;
|
|
|
| std::vector<Base::Vector3d> poles = bsp->getPoles();
|
| std::vector<Base::Vector3d> newPoles = bspline->getPoles();
|
|
|
|
|
| std::vector<double> knots = bsp->getKnots();
|
| std::vector<double> newKnots = bspline->getKnots();
|
|
|
| std::map<Sketcher::InternalAlignmentType, std::vector<int>> indexInNew {
|
| {Sketcher::BSplineControlPoint, {}},
|
| {Sketcher::BSplineKnotPoint, {}}
|
| };
|
| indexInNew[Sketcher::BSplineControlPoint].reserve(poles.size());
|
| indexInNew[Sketcher::BSplineKnotPoint].reserve(knots.size());
|
|
|
| for (const auto& pole : poles) {
|
| const auto it = std::ranges::find(newPoles, pole);
|
| indexInNew[Sketcher::BSplineControlPoint].emplace_back(it - newPoles.begin());
|
| }
|
| std::ranges::replace(indexInNew[Sketcher::BSplineControlPoint], int(newPoles.size()), -1);
|
|
|
| for (const auto& knot : knots) {
|
| const auto it = std::ranges::find(newKnots, knot);
|
| indexInNew[Sketcher::BSplineKnotPoint].emplace_back(it - newKnots.begin());
|
| }
|
| std::ranges::replace(indexInNew[Sketcher::BSplineKnotPoint], int(newKnots.size()), -1);
|
|
|
| const std::vector<Sketcher::Constraint*>& cvals = Constraints.getValues();
|
|
|
| std::vector<Constraint*> newcVals(0);
|
|
|
|
|
| for (const auto& constr : cvals) {
|
| if (!(constr->Type == Sketcher::InternalAlignment && constr->Second == GeoId)) {
|
| newcVals.push_back(constr);
|
| continue;
|
| }
|
|
|
| int index = indexInNew.at(constr->AlignmentType).at(constr->InternalAlignmentIndex);
|
|
|
| if (index == -1) {
|
|
|
|
|
| delGeoId.push_back(constr->First);
|
| continue;
|
| }
|
|
|
| Constraint* newConstr = constr->clone();
|
| newConstr->InternalAlignmentIndex = index;
|
| newcVals.push_back(newConstr);
|
| }
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
| GeometryFacade::copyId(geo, bspline.get());
|
| newVals[GeoId] = bspline.release();
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| Geometry.setValues(std::move(newVals));
|
|
|
| this->Constraints.setValues(std::move(newcVals));
|
| }
|
|
|
|
|
|
|
|
|
| if (!delGeoId.empty()) {
|
| delGeometriesExclusiveList(delGeoId);
|
| }
|
| else {
|
| Geometry.touch();
|
| }
|
| return true;
|
| }
|
|
|
| bool SketchObject::insertBSplineKnot(int GeoId, double param, int multiplicity)
|
| {
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| if (GeoId < 0 || GeoId > getHighestCurveIndex()) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP("Exceptions", "B-spline Geometry Index (GeoID) is out of bounds.")
|
| );
|
| }
|
|
|
| if (multiplicity == 0) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP("Exceptions", "Knot cannot have zero multiplicity.")
|
| );
|
| }
|
|
|
| const Part::Geometry* geo = getGeometry(GeoId);
|
|
|
| if (!geo->is<Part::GeomBSplineCurve>()) {
|
| THROWMT(
|
| Base::TypeError,
|
| QT_TRANSLATE_NOOP("Exceptions", "The Geometry Index (GeoId) provided is not a B-spline.")
|
| );
|
| }
|
|
|
| const auto* bsp = static_cast<const Part::GeomBSplineCurve*>(geo);
|
|
|
| int degree = bsp->getDegree();
|
| double firstParam = bsp->getFirstParameter();
|
| double lastParam = bsp->getLastParameter();
|
|
|
| if (multiplicity > degree) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP(
|
| "Exceptions",
|
| "Knot multiplicity cannot be higher than the degree of the B-spline."
|
| )
|
| );
|
| }
|
|
|
| if (param > lastParam || param < firstParam) {
|
| THROWMT(
|
| Base::ValueError,
|
| QT_TRANSLATE_NOOP("Exceptions", "Knot cannot be inserted outside the B-spline parameter range.")
|
| );
|
| }
|
|
|
| std::unique_ptr<Part::GeomBSplineCurve> bspline;
|
|
|
|
|
| try {
|
| bspline.reset(static_cast<Part::GeomBSplineCurve*>(bsp->clone()));
|
|
|
| bspline->insertKnot(param, multiplicity);
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
| return false;
|
| }
|
|
|
|
|
| std::vector<int> delGeoId;
|
|
|
| std::vector<Base::Vector3d> poles = bsp->getPoles();
|
| std::vector<Base::Vector3d> newPoles = bspline->getPoles();
|
| std::vector<int> poleIndexInNew(poles.size(), -1);
|
|
|
| for (size_t j = 0; j < poles.size(); j++) {
|
| const auto it = std::ranges::find(newPoles, poles[j]);
|
| poleIndexInNew[j] = it - newPoles.begin();
|
| }
|
| std::ranges::replace(poleIndexInNew, int(newPoles.size()), -1);
|
|
|
| std::vector<double> knots = bsp->getKnots();
|
| std::vector<double> newKnots = bspline->getKnots();
|
| std::vector<int> knotIndexInNew(knots.size(), -1);
|
|
|
| for (size_t j = 0; j < knots.size(); j++) {
|
| const auto it = std::ranges::find(newKnots, knots[j]);
|
| knotIndexInNew[j] = it - newKnots.begin();
|
| }
|
| std::ranges::replace(knotIndexInNew, int(newKnots.size()), -1);
|
|
|
| const std::vector<Sketcher::Constraint*>& cvals = Constraints.getValues();
|
|
|
| std::vector<Constraint*> newcVals(0);
|
|
|
|
|
| for (const auto& constr : cvals) {
|
| if (!(constr->Type == Sketcher::InternalAlignment && constr->Second == GeoId)) {
|
| newcVals.push_back(constr);
|
| continue;
|
| }
|
|
|
| std::vector<int>* indexInNew = nullptr;
|
|
|
| if (constr->AlignmentType == Sketcher::BSplineControlPoint) {
|
| indexInNew = &poleIndexInNew;
|
| }
|
| else if (constr->AlignmentType == Sketcher::BSplineKnotPoint) {
|
| indexInNew = &knotIndexInNew;
|
| }
|
| else {
|
|
|
| newcVals.push_back(constr);
|
| continue;
|
| }
|
|
|
| if (indexInNew && indexInNew->at(constr->InternalAlignmentIndex) == -1) {
|
|
|
|
|
| delGeoId.push_back(constr->First);
|
| continue;
|
| }
|
|
|
| Constraint* newConstr = constr->clone();
|
| newConstr->InternalAlignmentIndex = indexInNew->at(constr->InternalAlignmentIndex);
|
| newcVals.push_back(newConstr);
|
| }
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
| GeometryFacade::copyId(geo, bspline.get());
|
| newVals[GeoId] = bspline.release();
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| Geometry.setValues(std::move(newVals));
|
|
|
| this->Constraints.setValues(std::move(newcVals));
|
| }
|
|
|
|
|
|
|
|
|
| if (!delGeoId.empty()) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| delGeometriesExclusiveList(delGeoId);
|
| return true;
|
| }
|
|
|
| Geometry.touch();
|
|
|
| return true;
|
| }
|
|
|
| int SketchObject::carbonCopy(App::DocumentObject* pObj, bool construction)
|
| {
|
| using std::numbers::pi;
|
|
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| bool xinv = false, yinv = false;
|
|
|
| if (!isCarbonCopyAllowed(pObj->getDocument(), pObj, xinv, yinv)) {
|
| return -1;
|
| }
|
|
|
| auto* psObj = static_cast<SketchObject*>(pObj);
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| const std::vector<Sketcher::Constraint*>& cvals = Constraints.getValues();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
| std::vector<Constraint*> newcVals(cvals);
|
|
|
| int nextgeoid = vals.size();
|
|
|
| int nextextgeoid = getExternalGeometryCount();
|
|
|
| int nextcid = cvals.size();
|
|
|
| const std::vector<Part::Geometry*>& svals = psObj->getInternalGeometry();
|
|
|
| const std::vector<Sketcher::Constraint*>& scvals = psObj->Constraints.getValues();
|
|
|
| newVals.reserve(vals.size() + svals.size());
|
| newcVals.reserve(cvals.size() + scvals.size());
|
|
|
| const Base::Vector3d& origin = this->Placement.getValue().getPosition();
|
| const Base::Rotation& rotation = this->Placement.getValue().getRotation();
|
| const Base::Vector3d axisH = rotation.multVec(Base::Vector3d::UnitX);
|
| const Base::Vector3d axisV = rotation.multVec(Base::Vector3d::UnitY);
|
|
|
| std::map<int, int> extMap;
|
| if (psObj->ExternalGeo.getSize() > 1) {
|
| int i = -1;
|
| auto geos = this->ExternalGeo.getValues();
|
| std::string myName(this->getNameInDocument());
|
| myName += ".";
|
| for (const auto& geo : psObj->ExternalGeo.getValues()) {
|
| if (++i < 2) {
|
| continue;
|
| }
|
| else {
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| const auto& ref = egf->getRef();
|
| if (boost::starts_with(ref, myName)) {
|
| int geoId;
|
| PointPos posId;
|
| if (this->geoIdFromShapeType(ref.c_str() + myName.size(), geoId, posId)) {
|
| extMap[-i - 1] = geoId;
|
| continue;
|
| }
|
| }
|
| }
|
| auto copy = geo->copy();
|
| auto egf = ExternalGeometryFacade::getFacade(copy);
|
| egf->setId(++geoLastId);
|
| if (!egf->getRef().empty()) {
|
| auto& refs = this->externalGeoRefMap[egf->getRef()];
|
| refs.push_back(geoLastId);
|
| }
|
| this->externalGeoMap[geoLastId] = (int)geos.size();
|
| geos.push_back(copy);
|
| extMap[-i - 1] = -(int)geos.size();
|
| }
|
| Base::ObjectStatusLocker<App::Property::Status, App::Property> guard(
|
| App::Property::User3,
|
| &this->ExternalGeo
|
| );
|
| this->ExternalGeo.setValues(std::move(geos));
|
| }
|
|
|
| if (psObj->ExternalGeometry.getSize() > 0) {
|
| std::vector<DocumentObject*> Objects = ExternalGeometry.getValues();
|
| std::vector<std::string> SubElements = ExternalGeometry.getSubValues();
|
|
|
| const std::vector<DocumentObject*> originalObjects = Objects;
|
| const std::vector<std::string> originalSubElements = SubElements;
|
|
|
| std::vector<DocumentObject*> sObjects = psObj->ExternalGeometry.getValues();
|
| std::vector<std::string> sSubElements = psObj->ExternalGeometry.getSubValues();
|
|
|
| if (Objects.size() != SubElements.size() || sObjects.size() != sSubElements.size()) {
|
| assert(0 );
|
| Base::Console().error(
|
| "Internal error: counts of objects and subelements in external "
|
| "geometry links do not match\n"
|
| );
|
| return -1;
|
| }
|
|
|
| int si = 0;
|
| for (auto& sobj : sObjects) {
|
| int i = 0;
|
| for (auto& obj : Objects) {
|
| if (obj == sobj && SubElements[i] == sSubElements[si]) {
|
| Base::Console().error(
|
| "Link to %s already exists in this sketch. Delete the link and try again\n",
|
| sSubElements[si].c_str()
|
| );
|
| return -1;
|
| }
|
|
|
| i++;
|
| }
|
|
|
| Objects.push_back(sobj);
|
| SubElements.push_back(sSubElements[si]);
|
|
|
| si++;
|
| }
|
|
|
| ExternalGeometry.setValues(Objects, SubElements);
|
|
|
| try {
|
| rebuildExternalGeometry();
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
|
|
| ExternalGeometry.setValues(originalObjects, originalSubElements);
|
| return -1;
|
| }
|
|
|
| solverNeedsUpdate = true;
|
| }
|
|
|
| auto applyGeometryFlipCorrection = [xinv, yinv, origin, axisV, axisH](Part::Geometry* geoNew) {
|
| if (!xinv && !yinv) {
|
| return;
|
| }
|
|
|
| if (xinv) {
|
| geoNew->mirror(origin, axisV);
|
| }
|
| if (yinv) {
|
| geoNew->mirror(origin, axisH);
|
| }
|
| };
|
|
|
| for (const auto& geoOld : svals) {
|
| Part::Geometry* geoNew = geoOld->copy();
|
| if (xinv || yinv) {
|
|
|
| applyGeometryFlipCorrection(geoNew);
|
| }
|
| generateId(geoNew);
|
| if (construction && !geoNew->is<Part::GeomPoint>()) {
|
| GeometryFacade::setConstruction(geoNew, true);
|
| }
|
| newVals.push_back(geoNew);
|
| }
|
|
|
| auto applyConstraintFlipCorrection = [xinv, yinv](Sketcher::Constraint* newConstr) {
|
| if (!xinv && !yinv) {
|
| return;
|
| }
|
|
|
|
|
| if ((xinv && newConstr->Type == Sketcher::DistanceX)
|
| || (yinv && newConstr->Type == Sketcher::DistanceY)) {
|
| if (newConstr->First == newConstr->Second) {
|
| std::swap(newConstr->FirstPos, newConstr->SecondPos);
|
| }
|
| else {
|
| newConstr->setValue(-newConstr->getValue());
|
| }
|
| }
|
|
|
|
|
| if (newConstr->Type == Sketcher::Angle) {
|
| auto normalizeAngle = [](double angleDeg) {
|
| while (angleDeg > pi) {
|
| angleDeg -= pi * 2.0;
|
| }
|
| while (angleDeg <= -pi) {
|
| angleDeg += pi * 2.0;
|
| }
|
| return angleDeg;
|
| };
|
|
|
| if (xinv && yinv) {
|
| if (newConstr->First == -1 || newConstr->Second == -1 || newConstr->First == -2
|
| || newConstr->Second == -2 || newConstr->Second == GeoEnum::GeoUndef) {
|
|
|
| newConstr->setValue(normalizeAngle(newConstr->getValue() + pi));
|
| }
|
| else {
|
|
|
|
|
| }
|
| }
|
| else if (xinv) {
|
| if (newConstr->First == -1 || newConstr->Second == -1
|
| || newConstr->Second == GeoEnum::GeoUndef) {
|
|
|
| newConstr->setValue(normalizeAngle(pi - newConstr->getValue()));
|
| }
|
| else {
|
|
|
| newConstr->setValue(normalizeAngle(-newConstr->getValue()));
|
| }
|
| }
|
| else if (yinv) {
|
| if (newConstr->First == -2 || newConstr->Second == -2) {
|
|
|
| newConstr->setValue(normalizeAngle(pi - newConstr->getValue()));
|
| }
|
| else {
|
|
|
| newConstr->setValue(normalizeAngle(-newConstr->getValue()));
|
| }
|
| }
|
| }
|
| };
|
|
|
| for (const auto& constr : scvals) {
|
| Sketcher::Constraint* newConstr = constr->copy();
|
| if (constr->First >= 0) {
|
| newConstr->First += nextgeoid;
|
| }
|
| if (constr->Second >= 0) {
|
| newConstr->Second += nextgeoid;
|
| }
|
| if (constr->Third >= 0) {
|
| newConstr->Third += nextgeoid;
|
| }
|
|
|
| if (constr->First < -2 && constr->First != GeoEnum::GeoUndef) {
|
| newConstr->First -= (nextextgeoid - 2);
|
| }
|
| if (constr->Second < -2 && constr->Second != GeoEnum::GeoUndef) {
|
| newConstr->Second -= (nextextgeoid - 2);
|
| }
|
| if (constr->Third < -2 && constr->Third != GeoEnum::GeoUndef) {
|
| newConstr->Third -= (nextextgeoid - 2);
|
| }
|
|
|
| if (xinv || yinv) {
|
|
|
| applyConstraintFlipCorrection(newConstr);
|
| }
|
|
|
| newcVals.push_back(newConstr);
|
| }
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| Geometry.setValues(std::move(newVals));
|
| this->Constraints.setValues(std::move(newcVals));
|
| }
|
|
|
|
|
|
|
| Geometry.touch();
|
|
|
| auto makeCorrectedExpressionString =
|
| [xinv, yinv](const Sketcher::Constraint* constr, const std::string expr) -> std::string {
|
| if (!xinv && !yinv) {
|
| return expr;
|
| }
|
|
|
|
|
| if ((xinv && constr->Type == Sketcher::DistanceX)
|
| || (yinv && constr->Type == Sketcher::DistanceY)) {
|
| if (constr->First == constr->Second) {
|
| return expr;
|
| }
|
| else {
|
| return "-(" + expr + ")";
|
| }
|
| }
|
|
|
|
|
| if (constr->Type == Sketcher::Angle) {
|
| if (xinv && yinv) {
|
| if (constr->First == -1 || constr->Second == -1 || constr->First == -2
|
| || constr->Second == -2 || constr->Second == GeoEnum::GeoUndef) {
|
|
|
| return "(" + expr + ") + 180 deg";
|
| }
|
| else {
|
|
|
|
|
| return expr;
|
| }
|
| }
|
| else if (xinv) {
|
| if (constr->First == -1 || constr->Second == -1
|
| || constr->Second == GeoEnum::GeoUndef) {
|
|
|
| return "180 deg - (" + expr + ")";
|
| }
|
| else {
|
|
|
| return "-(" + expr + ")";
|
| }
|
| }
|
| else if (yinv) {
|
| if (constr->First == -2 || constr->Second == -2) {
|
|
|
| return "180 deg - (" + expr + ")";
|
| }
|
| else {
|
|
|
| return "-(" + expr + ")";
|
| }
|
| }
|
| }
|
| return expr;
|
| };
|
|
|
| int sourceid = 0;
|
| for (auto it = scvals.cbegin(); it != scvals.cend(); ++it, ++nextcid, ++sourceid) {
|
| if (!((*it)->isDimensional() && (*it)->isDriving)) {
|
| continue;
|
| }
|
|
|
| App::ObjectIdentifier spath;
|
| std::shared_ptr<App::Expression> expr;
|
| std::string scname = (*it)->Name;
|
| std::string sref;
|
| if (App::ExpressionParser::isTokenAnIndentifier(scname)) {
|
| spath = App::ObjectIdentifier(psObj->Constraints)
|
| << App::ObjectIdentifier::SimpleComponent(scname);
|
| sref = spath.getDocumentObjectName().getString() + spath.toString();
|
| }
|
| else {
|
| spath = psObj->Constraints.createPath(sourceid);
|
| sref = spath.getDocumentObjectName().getString() + std::string(1, '.') + spath.toString();
|
| }
|
| if (xinv || yinv) {
|
|
|
| sref = makeCorrectedExpressionString((*it), sref);
|
| }
|
| expr = std::shared_ptr<App::Expression>(App::Expression::parse(this, sref));
|
| setExpression(Constraints.createPath(nextcid), std::move(expr));
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| solve();
|
|
|
| return svals.size();
|
| }
|
|
|
| int SketchObject::addExternal(App::DocumentObject* Obj, const char* SubName, bool defining, bool intersection)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| if (!isExternalAllowed(Obj->getDocument(), Obj)) {
|
| return -1;
|
| }
|
|
|
| auto wholeShape = Part::Feature::getTopoShape(
|
| Obj,
|
| Part::ShapeOption::ResolveLink | Part::ShapeOption::Transform
|
| );
|
| auto shape = wholeShape.getSubTopoShape(SubName, true);
|
| TopAbs_ShapeEnum shapeType = TopAbs_SHAPE;
|
| if (shape.shapeType( true) != TopAbs_FACE) {
|
| if (shape.hasSubShape(TopAbs_FACE)) {
|
| shapeType = TopAbs_FACE;
|
| }
|
| else if (shape.shapeType( true) != TopAbs_EDGE && shape.hasSubShape(TopAbs_EDGE)) {
|
| shapeType = TopAbs_EDGE;
|
| }
|
| }
|
|
|
| if (shapeType != TopAbs_SHAPE) {
|
| std::string element = Part::TopoShape::shapeName(shapeType);
|
| std::size_t elementNameSize = element.size();
|
| int geometryCount = ExternalGeometry.getSize();
|
|
|
| gp_Pln sketchPlane;
|
| if (intersection) {
|
| Base::Placement Plm = Placement.getValue();
|
| Base::Vector3d Pos = Plm.getPosition();
|
| Base::Rotation Rot = Plm.getRotation();
|
| Base::Vector3d dN(0, 0, 1);
|
| Rot.multVec(dN, dN);
|
| Base::Vector3d dX(1, 0, 0);
|
| Rot.multVec(dX, dX);
|
| gp_Ax3 sketchAx3(
|
| gp_Pnt(Pos.x, Pos.y, Pos.z),
|
| gp_Dir(dN.x, dN.y, dN.z),
|
| gp_Dir(dX.x, dX.y, dX.z)
|
| );
|
| sketchPlane.SetPosition(sketchAx3);
|
| }
|
| for (const auto& subShape : shape.getSubShapes(shapeType)) {
|
| int idx = wholeShape.findShape(subShape);
|
| if (idx == 0) {
|
| continue;
|
| }
|
| if (intersection) {
|
| try {
|
| FCBRepAlgoAPI_Section maker(subShape, sketchPlane);
|
| if (!maker.IsDone() || maker.Shape().IsNull()) {
|
| continue;
|
| }
|
| }
|
| catch (Standard_Failure&) {
|
| continue;
|
| }
|
| }
|
| element += std::to_string(idx);
|
| addExternal(Obj, element.c_str(), defining, intersection);
|
| element.resize(elementNameSize);
|
| }
|
| if (ExternalGeometry.getSize() == geometryCount) {
|
| return -1;
|
| }
|
| return geometryCount;
|
| }
|
|
|
|
|
| std::vector<long> Types = ExternalTypes.getValues();
|
| std::vector<DocumentObject*> Objects = ExternalGeometry.getValues();
|
| std::vector<std::string> SubElements = ExternalGeometry.getSubValues();
|
| Types.resize(Objects.size(), static_cast<long>(ExtType::Projection));
|
|
|
| const std::vector<DocumentObject*> originalObjects = Objects;
|
| const std::vector<std::string> originalSubElements = SubElements;
|
|
|
| if (Objects.size() != SubElements.size()) {
|
| assert(0 );
|
| Base::Console().error(
|
| "Internal error: counts of objects and subelements in external "
|
| "geometry links do not match\n"
|
| );
|
| return -1;
|
| }
|
|
|
| bool add = true;
|
| for (size_t i = 0; i < Objects.size(); ++i) {
|
| if (!(Objects[i] == Obj && std::string(SubName) == SubElements[i])) {
|
| continue;
|
| }
|
| if (Types[i] == static_cast<int>(ExtType::Both)
|
| || (Types[i] == static_cast<int>(ExtType::Projection) && !intersection)
|
| || (Types[i] == static_cast<int>(ExtType::Intersection) && intersection)) {
|
| Base::Console().error("Link to %s already exists in this sketch.\n", SubName);
|
| return -1;
|
| }
|
|
|
| add = false;
|
| Types[i] = static_cast<int>(ExtType::Both);
|
| }
|
| if (add) {
|
|
|
| Objects.push_back(Obj);
|
| SubElements.emplace_back(SubName);
|
| Types.push_back(static_cast<int>(intersection ? ExtType::Intersection : ExtType::Projection));
|
| if (intersection) {
|
| }
|
|
|
|
|
| ExternalGeometry.setValues(Objects, SubElements);
|
| }
|
| ExternalTypes.setValues(Types);
|
|
|
| try {
|
| ExternalToAdd ext {Obj, std::string(SubName), defining, intersection};
|
| rebuildExternalGeometry(ext);
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
|
|
| ExternalGeometry.setValues(originalObjects, originalSubElements);
|
| return -1;
|
| }
|
|
|
| acceptGeometry();
|
|
|
| solverNeedsUpdate = true;
|
| return ExternalGeometry.getValues().size() - 1;
|
| }
|
|
|
|
|
| int SketchObject::delExternal(int ExtGeoId)
|
| {
|
| return delExternal(std::vector<int>{ExtGeoId});
|
| }
|
|
|
| int SketchObject::delExternal(const std::vector<int>& ExtGeoIds)
|
| {
|
| std::set<long> geoIds;
|
| for (int ExtGeoId : ExtGeoIds) {
|
| int GeoId = ExtGeoId >= 0 ? GeoEnum::RefExt - ExtGeoId : ExtGeoId;
|
| if (GeoId > GeoEnum::RefExt || -GeoId - 1 >= ExternalGeo.getSize())
|
| return -1;
|
|
|
| auto geo = getGeometry(GeoId);
|
| if (!geo)
|
| return -1;
|
|
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| geoIds.insert(egf->getId());
|
| if (egf->getRef().size()) {
|
| auto& refs = externalGeoRefMap[egf->getRef()];
|
| geoIds.insert(refs.begin(), refs.end());
|
| }
|
| }
|
|
|
| delExternalPrivate(geoIds, true);
|
| return 0;
|
| }
|
|
|
|
|
| void SketchObject::delExternalPrivate(const std::set<long>& ids, bool removeRef)
|
| {
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| std::set<std::string> refs;
|
|
|
|
|
| std::set<int, std::greater<int>> geoIds;
|
|
|
| for (auto id : ids) {
|
| auto it = externalGeoMap.find(id);
|
| if (it == externalGeoMap.end()) {
|
| continue;
|
| }
|
|
|
| auto egf = ExternalGeometryFacade::getFacade(ExternalGeo[it->second]);
|
| if (removeRef && egf->getRef().size()) {
|
| refs.insert(egf->getRef());
|
| }
|
| geoIds.insert(-it->second - 1);
|
| }
|
|
|
| if (geoIds.empty()) {
|
| return;
|
| }
|
|
|
| std::vector<Constraint*> newConstraints;
|
| for (const auto& cstr : Constraints.getValues()) {
|
| if (geoIds.count(cstr->First)
|
| || (cstr->Second != GeoEnum::GeoUndef && geoIds.count(cstr->Second))
|
| || (cstr->Third != GeoEnum::GeoUndef && geoIds.count(cstr->Third))) {
|
| continue;
|
| }
|
| int offset = 0;
|
| std::unique_ptr<Constraint> newCstr(cstr->clone());
|
| for (auto GeoId : geoIds) {
|
| GeoId += offset++;
|
| if (newCstr->First >= GeoId && newCstr->Second >= GeoId && newCstr->Third >= GeoId) {
|
| break;
|
| }
|
| changeConstraintAfterDeletingGeo(newCstr.get(), GeoId);
|
| }
|
|
|
| newConstraints.push_back(newCstr.release());
|
| }
|
|
|
| auto geos = ExternalGeo.getValues();
|
| int offset = 0;
|
| for (auto geoId : geoIds) {
|
| int idx = -geoId - 1;
|
| geos.erase(geos.begin() + idx - offset);
|
| ++offset;
|
| }
|
|
|
| if (refs.empty()) {
|
| ExternalGeo.setValues(std::move(geos));
|
|
|
| solverNeedsUpdate = true;
|
| Constraints.setValues(std::move(newConstraints));
|
| acceptGeometry();
|
| }
|
|
|
| std::vector<std::string> newSubs;
|
| std::vector<App::DocumentObject*> newObjs;
|
| const auto& subs = ExternalGeometry.getSubValues();
|
| auto itSub = subs.begin();
|
| const auto& objs = ExternalGeometry.getValues();
|
| auto itObj = objs.begin();
|
| bool touched = false;
|
| assert(externalGeoRef.size() == objs.size());
|
| assert(externalGeoRef.size() == subs.size());
|
| for (auto it = externalGeoRef.begin(); it != externalGeoRef.end(); ++it, ++itObj, ++itSub) {
|
| if (refs.count(*it) == 0) {
|
| touched = true;
|
| newObjs.push_back(*itObj);
|
| newSubs.push_back(*itSub);
|
| }
|
| }
|
| if (touched) {
|
| ExternalGeometry.setValues(newObjs, newSubs);
|
| }
|
|
|
| ExternalGeo.setValues(std::move(geos));
|
|
|
| solverNeedsUpdate = true;
|
| Constraints.setValues(std::move(newConstraints));
|
| acceptGeometry();
|
| }
|
|
|
|
|
|
|
| int SketchObject::delAllExternal()
|
| {
|
| int count = 0;
|
| std::map<int, int> indexMap;
|
| std::vector<Part::Geometry*> geos;
|
| for (int i = 0; i < ExternalGeo.getSize(); ++i) {
|
| auto geo = ExternalGeo[i];
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if (egf->getRef().empty()) {
|
| indexMap[i] = count++;
|
| }
|
| geos.push_back(geo);
|
| }
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
| std::vector<DocumentObject*> Objects = ExternalGeometry.getValues();
|
| std::vector<std::string> SubElements = ExternalGeometry.getSubValues();
|
|
|
| const std::vector<DocumentObject*> originalObjects = Objects;
|
| const std::vector<std::string> originalSubElements = SubElements;
|
|
|
| Objects.clear();
|
| SubElements.clear();
|
|
|
| const std::vector<Constraint*>& constraints = Constraints.getValues();
|
| std::vector<Constraint*> newConstraints(0);
|
|
|
| for (const auto& constr : constraints) {
|
| if (constr->First > GeoEnum::RefExt
|
| && (constr->Second > GeoEnum::RefExt || constr->Second == GeoEnum::GeoUndef)
|
| && (constr->Third > GeoEnum::RefExt || constr->Third == GeoEnum::GeoUndef)) {
|
| Constraint* copiedConstr = constr->clone();
|
|
|
| newConstraints.push_back(copiedConstr);
|
| }
|
| }
|
|
|
| ExternalGeometry.setValues(Objects, SubElements);
|
| try {
|
| rebuildExternalGeometry();
|
| }
|
| catch (const Base::Exception& e) {
|
| Base::Console().error("%s\n", e.what());
|
|
|
| ExternalGeometry.setValues(originalObjects, originalSubElements);
|
| for (Constraint* it : newConstraints) {
|
| delete it;
|
| }
|
| return -1;
|
| }
|
|
|
| ExternalGeometry.setValue(0);
|
| ExternalGeo.setValues(std::move(geos));
|
| solverNeedsUpdate = true;
|
| Constraints.setValues(std::move(newConstraints));
|
| acceptGeometry();
|
| return 0;
|
| }
|
|
|
|
|
| int SketchObject::delConstraintsToExternal(DeleteOptions options)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| const std::vector<Constraint*>& constraints = Constraints.getValuesForce();
|
| std::vector<Constraint*> newConstraints(0);
|
| int GeoId = GeoEnum::RefExt, NullId = GeoEnum::GeoUndef;
|
| for (const auto& constr : constraints) {
|
| if (constr->First > GeoId && (constr->Second > GeoId || constr->Second == NullId)
|
| && (constr->Third > GeoId || constr->Third == NullId)) {
|
| newConstraints.push_back(constr);
|
| }
|
| }
|
|
|
| Constraints.setValues(std::move(newConstraints));
|
| Constraints.acceptGeometry(getCompleteGeometry());
|
|
|
|
|
| if (noRecomputes && !options.testFlag(DeleteOption::NoFlag)) {
|
| solve(options.testFlag(DeleteOption::UpdateGeometry));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::attachExternal(
|
| const std::vector<int> &geoIds, App::DocumentObject *Obj, const char* SubName)
|
| {
|
| if (!isExternalAllowed(Obj->getDocument(), Obj))
|
| return -1;
|
|
|
| std::set<std::string> detached;
|
| std::set<int> idSet;
|
| for (int geoId : geoIds) {
|
| if (geoId > GeoEnum::RefExt || -geoId - 1 >= ExternalGeo.getSize())
|
| continue;
|
| auto geo = getGeometry(geoId);
|
| if(!geo)
|
| continue;
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if(egf->getRef().size())
|
| detached.insert(egf->getRef());
|
| for(int id : getRelatedGeometry(geoId))
|
| idSet.insert(id);
|
| }
|
|
|
| auto geos = ExternalGeo.getValues();
|
|
|
| std::vector<DocumentObject*> Objects = ExternalGeometry.getValues();
|
| auto itObj = Objects.begin();
|
| std::vector<std::string> SubElements = ExternalGeometry.getSubValues();
|
| auto itSub = SubElements.begin();
|
|
|
| assert(Objects.size()==SubElements.size());
|
| assert(externalGeoRef.size() == Objects.size());
|
|
|
| for(auto &key : externalGeoRef) {
|
| if (*itObj == Obj && *itSub == SubName){
|
| FC_ERR("Duplicate external element reference in " << getFullName() << ": " << key);
|
| return -1;
|
| }
|
|
|
| if(detached.count(key)) {
|
| itObj = Objects.erase(itObj);
|
| itSub = SubElements.erase(itSub);
|
| }else{
|
| ++itObj;
|
| ++itSub;
|
| }
|
| }
|
|
|
|
|
| Objects.push_back(Obj);
|
| SubElements.push_back(std::string(SubName));
|
|
|
| ExternalGeometry.setValues(Objects,SubElements);
|
| if(externalGeoRef.size()!=Objects.size())
|
| return -1;
|
|
|
| std::string ref = externalGeoRef.back();
|
| for(auto geoId : idSet) {
|
| auto &geo = geos[-geoId-1];
|
| geo = geo->clone();
|
| ExternalGeometryFacade::getFacade(geo)->setRef(ref);
|
| }
|
|
|
| ExternalGeo.setValues(std::move(geos));
|
| rebuildExternalGeometry();
|
| return ExternalGeometry.getSize()-1;
|
| }
|
|
|
| std::vector<int> SketchObject::getRelatedGeometry(int GeoId) const {
|
| std::vector<int> res;
|
| if(GeoId>GeoEnum::RefExt || -GeoId-1>=ExternalGeo.getSize())
|
| return res;
|
| auto geo = getGeometry(GeoId);
|
| if(!geo)
|
| return res;
|
| const std::string &ref = ExternalGeometryFacade::getFacade(geo)->getRef();
|
| if(!ref.size())
|
| return {GeoId};
|
| auto iter = externalGeoRefMap.find(ref);
|
| if(iter == externalGeoRefMap.end())
|
| return {GeoId};
|
| for(auto id : iter->second) {
|
| auto it = externalGeoMap.find(id);
|
| if(it!=externalGeoMap.end())
|
| res.push_back(-it->second-1);
|
| }
|
| return res;
|
| }
|
|
|
| int SketchObject::syncGeometry(const std::vector<int> &geoIds) {
|
| bool touched = false;
|
| auto geos = ExternalGeo.getValues();
|
| std::set<int> idSet;
|
| for(int geoId : geoIds) {
|
| auto geo = getGeometry(geoId);
|
| if(!geo || !ExternalGeometryFacade::getFacade(geo)->testFlag(ExternalGeometryExtension::Frozen))
|
| continue;
|
| for(int gid : getRelatedGeometry(geoId))
|
| idSet.insert(gid);
|
| }
|
| for(int geoId : idSet) {
|
| if(geoId <= GeoEnum::RefExt && -geoId-1 < ExternalGeo.getSize()) {
|
| auto &geo = geos[-geoId-1];
|
| geo = geo->clone();
|
| ExternalGeometryFacade::getFacade(geo)->setFlag(ExternalGeometryExtension::Sync);
|
| touched = true;
|
| }
|
| }
|
| if(touched)
|
| ExternalGeo.setValues(std::move(geos));
|
| return 0;
|
| }
|
|
|
| const Part::Geometry* SketchObject::_getGeometry(int GeoId) const
|
| {
|
| if (GeoId >= 0) {
|
| const std::vector<Part::Geometry *> &geomlist = getInternalGeometry();
|
| if (GeoId < int(geomlist.size()))
|
| return geomlist[GeoId];
|
| }
|
| else if (-GeoId-1 < ExternalGeo.getSize()) {
|
| return ExternalGeo[-GeoId-1];
|
| }
|
|
|
| return nullptr;
|
| }
|
|
|
| int SketchObject::getCompleteGeometryIndex(int GeoId) const
|
| {
|
| if (GeoId >= 0) {
|
| if (GeoId < int(Geometry.getSize()))
|
| return GeoId;
|
| }
|
| else if (-GeoId <= int(ExternalGeo.getSize()))
|
| return -GeoId - 1;
|
|
|
| return GeoEnum::GeoUndef;
|
| }
|
|
|
| int SketchObject::getGeoIdFromCompleteGeometryIndex(int completeGeometryIndex) const
|
| {
|
| int completeGeometryCount = int(Geometry.getSize() + ExternalGeo.getSize());
|
|
|
| if (completeGeometryIndex < 0 || completeGeometryIndex >= completeGeometryCount)
|
| return GeoEnum::GeoUndef;
|
|
|
| if (completeGeometryIndex < Geometry.getSize())
|
| return completeGeometryIndex;
|
| else
|
| return (completeGeometryIndex - completeGeometryCount);
|
| }
|
| int SketchObject::getSingleScaleDefiningConstraint() const
|
| {
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| int found = -1;
|
| for (size_t i = 0; i < vals.size(); ++i) {
|
|
|
| if (vals[i]->isDimensional() && vals[i]->Type != Angle) {
|
| if (found != -1) {
|
| return -1;
|
| }
|
| found = i;
|
| }
|
| }
|
| return found;
|
| }
|
|
|
| std::unique_ptr<const GeometryFacade> SketchObject::getGeometryFacade(int GeoId) const
|
| {
|
| return GeometryFacade::getFacade(getGeometry(GeoId));
|
| }
|
|
|
| int SketchObject::setGeometry(int GeoId, const Part::Geometry *geo) {
|
| std::unique_ptr<Part::Geometry> g(geo->clone());
|
| if(GeoId>=0 && GeoId <Geometry.getSize()) {
|
| Geometry.set1Value(GeoId,std::move(g));
|
| } else if(GeoId <= GeoEnum::RefExt && -GeoId-1 < ExternalGeo.getSize()) {
|
| ExternalGeo.set1Value(-GeoId-1,std::move(g));
|
| } else
|
| return -1;
|
| return 0;
|
| }
|
|
|
| namespace {
|
|
|
|
|
| static gp_Vec2d ProjVecOnPlane_UV(const gp_Vec& V, const gp_Pln& Pl)
|
| {
|
| return gp_Vec2d(V.Dot(Pl.Position().XDirection()), V.Dot(Pl.Position().YDirection()));
|
| }
|
|
|
|
|
| static gp_Vec ProjVecOnPlane_UVN(const gp_Vec& V, const gp_Pln& Pl)
|
| {
|
| gp_Vec2d vector = ProjVecOnPlane_UV(V, Pl);
|
| return gp_Vec(vector.X(), vector.Y(), 0.0);
|
| }
|
|
|
|
|
|
|
| static gp_Vec2d ProjPointOnPlane_UV(const gp_Pnt& P, const gp_Pln& Pl)
|
| {
|
| gp_Vec OP = gp_Vec(Pl.Location(), P);
|
| return ProjVecOnPlane_UV(OP, Pl);
|
| }
|
|
|
|
|
| static gp_Vec ProjPointOnPlane_UVN(const gp_Pnt& P, const gp_Pln& Pl)
|
| {
|
| gp_Vec2d vec2 = ProjPointOnPlane_UV(P, Pl);
|
| return gp_Vec(vec2.X(), vec2.Y(), 0.0);
|
| }
|
|
|
|
|
| static gp_Pnt ProjPointOnPlane_XYZ(const gp_Pnt& P, const gp_Pln& Pl)
|
| {
|
| gp_Vec positionUVN = ProjPointOnPlane_UVN(P, Pl);
|
| return gp_Pnt((positionUVN.X() * Pl.Position().XDirection()
|
| + positionUVN.Y() * Pl.Position().YDirection() + gp_Vec(Pl.Location().XYZ()))
|
| .XYZ());
|
| }
|
|
|
|
|
| Part::Geometry* projectLine(const BRepAdaptor_Curve& curve, const Handle(Geom_Plane) & gPlane,
|
| const Base::Placement& invPlm)
|
| {
|
| double first = curve.FirstParameter();
|
|
|
| if (fabs(first) > 1E99) {
|
|
|
|
|
|
|
| first = -10000;
|
| }
|
|
|
| double last = curve.LastParameter();
|
| if (fabs(last) > 1E99) {
|
| last = +10000;
|
| }
|
|
|
| gp_Pnt P1 = curve.Value(first);
|
| gp_Pnt P2 = curve.Value(last);
|
|
|
| GeomAPI_ProjectPointOnSurf proj1(P1, gPlane);
|
| P1 = proj1.NearestPoint();
|
| GeomAPI_ProjectPointOnSurf proj2(P2, gPlane);
|
| P2 = proj2.NearestPoint();
|
|
|
| Base::Vector3d p1(P1.X(), P1.Y(), P1.Z());
|
| Base::Vector3d p2(P2.X(), P2.Y(), P2.Z());
|
| invPlm.multVec(p1, p1);
|
| invPlm.multVec(p2, p2);
|
|
|
| if (Base::Distance(p1, p2) < Precision::Confusion()) {
|
| Base::Vector3d p = (p1 + p2) / 2;
|
| auto* point = new Part::GeomPoint(p);
|
| GeometryFacade::setConstruction(point, true);
|
| return point;
|
| }
|
| else {
|
| auto* line = new Part::GeomLineSegment();
|
| line->setPoints(p1, p2);
|
| GeometryFacade::setConstruction(line, true);
|
| return line;
|
| }
|
| }
|
|
|
| }
|
|
|
| bool SketchObject::evaluateSupport()
|
| {
|
|
|
| App::DocumentObject* link = AttachmentSupport.getValue();
|
| if (!link || !link->isDerivedFrom<Part::Feature>())
|
| return false;
|
| return true;
|
| }
|
|
|
| static Part::Geometry *fitArcs(std::vector<std::unique_ptr<Part::Geometry> > &arcs,
|
| const gp_Pnt &P1,
|
| const gp_Pnt &P2,
|
| double tol)
|
| {
|
| double radius = 0.0;
|
| double m = 0.0;
|
| Base::Vector3d center;
|
| for (auto &geo : arcs) {
|
| if (auto arc = freecad_cast<Part::GeomArcOfCircle*>(geo.get())) {
|
| if (radius == 0.0) {
|
| radius = arc->getRadius();
|
| center = arc->getCenter();
|
| double f = arc->getFirstParameter();
|
| double l = arc->getLastParameter();
|
| m = (l-f)*0.5 + f;
|
| } else if (std::abs(radius - arc->getRadius()) > tol)
|
| return nullptr;
|
| } else
|
| return nullptr;
|
| }
|
| if (radius == 0.0) {
|
| return nullptr;
|
| }
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* circle = new Part::GeomCircle();
|
| circle->setCenter(center);
|
| circle->setRadius(radius);
|
| return circle;
|
| }
|
| if (arcs.size() == 1) {
|
| auto res = arcs.front().release();
|
| arcs.clear();
|
| return res;
|
| }
|
|
|
| GeomLProp_CLProps prop(Handle(Geom_Curve)::DownCast(arcs.front()->handle()),m,0,Precision::Confusion());
|
| gp_Pnt midPoint = prop.Value();
|
| GC_MakeArcOfCircle arc(P1, midPoint, P2);
|
| auto* geo = new Part::GeomArcOfCircle();
|
| geo->setHandle(arc.Value());
|
| return geo;
|
| }
|
|
|
| void SketchObject::validateExternalLinks()
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| std::vector<DocumentObject*> Objects = ExternalGeometry.getValues();
|
| std::vector<std::string> SubElements = ExternalGeometry.getSubValues();
|
|
|
| bool rebuild = false;
|
|
|
| for (int i = 0; i < int(Objects.size()); i++) {
|
| const App::DocumentObject* Obj = Objects[i];
|
| const std::string SubElement = SubElements[i];
|
|
|
| TopoDS_Shape refSubShape;
|
| try {
|
| if (Obj->isDerivedFrom<Part::Datum>()) {
|
| const auto* datum = static_cast<const Part::Datum*>(Obj);
|
| refSubShape = datum->getShape();
|
| }
|
| else if (Obj->isDerivedFrom<App::DatumElement>()) {
|
|
|
| }
|
| else {
|
| const auto* refObj = static_cast<const Part::Feature*>(Obj);
|
| const Part::TopoShape& refShape = refObj->Shape.getShape();
|
| refSubShape = refShape.getSubShape(SubElement.c_str());
|
| }
|
| continue;
|
| }
|
| catch (Base::IndexError& indexError) {
|
| Base::Console().warning(
|
| this->getFullLabel(), (indexError.getMessage() + "\n").c_str());
|
| }
|
| catch (Base::ValueError& valueError) {
|
| Base::Console().warning(
|
| this->getFullLabel(), (valueError.getMessage() + "\n").c_str());
|
| }
|
| catch (Standard_Failure&) {
|
| }
|
|
|
| rebuild = true;
|
| Objects.erase(Objects.begin() + i);
|
| SubElements.erase(SubElements.begin() + i);
|
|
|
| const std::vector<Constraint*>& constraints = Constraints.getValues();
|
| std::vector<Constraint*> newConstraints;
|
| newConstraints.reserve(constraints.size());
|
| int GeoId = GeoEnum::RefExt - i;
|
| for (const auto& constr : constraints) {
|
| auto newConstr = getConstraintAfterDeletingGeo(constr, GeoId);
|
| if (newConstr) {
|
| newConstraints.push_back(newConstr.release());
|
| }
|
| }
|
|
|
| Constraints.setValues(std::move(newConstraints));
|
| i--;
|
| }
|
|
|
| if (rebuild) {
|
| ExternalGeometry.setValues(Objects, SubElements);
|
| rebuildExternalGeometry();
|
| acceptGeometry();
|
| solve(true);
|
| }
|
| }
|
|
|
| namespace {
|
|
|
| void adjustParameterRange(const TopoDS_Edge &edge,
|
| Handle(Geom_Plane) gPlane,
|
| const gp_Trsf &mov,
|
| Handle(Geom_Curve) curve,
|
| double &firstParameter,
|
| double &lastParameter)
|
| {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Handle(Geom_Curve) origCurve = BRepAdaptor_Curve(edge).Curve().Curve();
|
|
|
|
|
|
|
| auto e = edge.Located(TopLoc_Location());
|
|
|
| gp_Pnt firstPoint = BRep_Tool::Pnt(TopExp::FirstVertex(TopoDS::Edge(e)));
|
| double f = GeomAPI_ProjectPointOnCurve(firstPoint, origCurve).LowerDistanceParameter();
|
|
|
| gp_Pnt lastPoint = BRep_Tool::Pnt(TopExp::LastVertex(TopoDS::Edge(e)));
|
| double l = GeomAPI_ProjectPointOnCurve(lastPoint, origCurve).LowerDistanceParameter();
|
|
|
| auto adjustPeriodic = [](Handle(Geom_Curve) curve, double &f, double &l) {
|
|
|
| if (curve->IsPeriodic()) {
|
| Standard_Real Udeb = curve->FirstParameter();
|
| Standard_Real Ufin = curve->LastParameter();
|
|
|
|
|
| ElCLib::AdjustPeriodic(Udeb, Ufin,
|
| std::min(std::abs(f-l)/2,Precision::PConfusion()),
|
| f, l);
|
| }
|
| };
|
|
|
|
|
| adjustPeriodic(origCurve, f, l);
|
|
|
|
|
| double m = (l - f) * 0.5 + f;
|
| GeomLProp_CLProps prop(origCurve,m,0,Precision::Confusion());
|
| gp_Pnt midPoint = prop.Value();
|
|
|
|
|
| auto trsf = edge.Location().Transformation();
|
| midPoint.Transform(trsf);
|
| firstPoint.Transform(trsf);
|
| lastPoint.Transform(trsf);
|
|
|
|
|
|
|
| gp_Pnt pm = GeomAPI_ProjectPointOnSurf(midPoint, gPlane).NearestPoint();
|
| gp_Pnt pf = GeomAPI_ProjectPointOnSurf(firstPoint, gPlane).NearestPoint();
|
| gp_Pnt pl = GeomAPI_ProjectPointOnSurf(lastPoint, gPlane).NearestPoint();
|
|
|
|
|
| pm.Transform(mov);
|
| pf.Transform(mov);
|
| pl.Transform(mov);
|
|
|
|
|
| double f2 = GeomAPI_ProjectPointOnCurve(pf, curve).LowerDistanceParameter();
|
| double l2 = GeomAPI_ProjectPointOnCurve(pl, curve).LowerDistanceParameter();
|
| double m2 = GeomAPI_ProjectPointOnCurve(pm, curve).LowerDistanceParameter();
|
|
|
| firstParameter = f2;
|
| lastParameter = l2;
|
|
|
| adjustPeriodic(curve, f2, l2);
|
| adjustPeriodic(curve, f2, m2);
|
|
|
|
|
| if (m2 > l2){
|
| std::swap(firstParameter, lastParameter);
|
| }
|
| }
|
|
|
| void processEdge2(TopoDS_Edge& projEdge, std::vector<std::unique_ptr<Part::Geometry>>& geos)
|
| {
|
| BRepAdaptor_Curve projCurve(projEdge);
|
| if (projCurve.GetType() == GeomAbs_Line) {
|
| gp_Pnt P1 = projCurve.Value(projCurve.FirstParameter());
|
| gp_Pnt P2 = projCurve.Value(projCurve.LastParameter());
|
| Base::Vector3d p1(P1.X(), P1.Y(), P1.Z());
|
| Base::Vector3d p2(P2.X(), P2.Y(), P2.Z());
|
|
|
| if (Base::Distance(p1, p2) < Precision::Confusion()) {
|
| Base::Vector3d p = (p1 + p2) / 2;
|
| auto* point = new Part::GeomPoint(p);
|
| GeometryFacade::setConstruction(point, true);
|
| geos.emplace_back(point);
|
| }
|
| else {
|
| auto* line = new Part::GeomLineSegment();
|
| line->setPoints(p1, p2);
|
| GeometryFacade::setConstruction(line, true);
|
| geos.emplace_back(line);
|
| }
|
| }
|
| else if (projCurve.GetType() == GeomAbs_Circle) {
|
| gp_Circ c = projCurve.Circle();
|
| gp_Pnt p = c.Location();
|
| gp_Pnt P1 = projCurve.Value(projCurve.FirstParameter());
|
| gp_Pnt P2 = projCurve.Value(projCurve.LastParameter());
|
|
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* circle = new Part::GeomCircle();
|
| circle->setRadius(c.Radius());
|
| circle->setCenter(Base::Vector3d(p.X(), p.Y(), p.Z()));
|
|
|
| GeometryFacade::setConstruction(circle, true);
|
| geos.emplace_back(circle);
|
| }
|
| else {
|
| auto* arc = new Part::GeomArcOfCircle();
|
| Handle(Geom_Curve) curve = new Geom_Circle(c);
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(curve,
|
| projCurve.FirstParameter(),
|
| projCurve.LastParameter());
|
| arc->setHandle(tCurve);
|
| GeometryFacade::setConstruction(arc, true);
|
| geos.emplace_back(arc);
|
| }
|
| }
|
| else if (projCurve.GetType() == GeomAbs_BSplineCurve) {
|
|
|
|
|
| GeomConvert_BSplineCurveKnotSplitting bSplineSplitter(projCurve.BSpline(), 2);
|
| auto* bspline = new Part::GeomBSplineCurve(projCurve.BSpline());
|
| GeometryFacade::setConstruction(bspline, true);
|
| geos.emplace_back(bspline);
|
| }
|
| else if (projCurve.GetType() == GeomAbs_Hyperbola) {
|
| gp_Hypr e = projCurve.Hyperbola();
|
| gp_Pnt p = e.Location();
|
| gp_Pnt P1 = projCurve.Value(projCurve.FirstParameter());
|
| gp_Pnt P2 = projCurve.Value(projCurve.LastParameter());
|
|
|
| gp_Dir normal = e.Axis().Direction();
|
| gp_Dir xdir = e.XAxis().Direction();
|
| gp_Ax2 xdirref(p, normal);
|
|
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* hyperbola = new Part::GeomHyperbola();
|
| hyperbola->setMajorRadius(e.MajorRadius());
|
| hyperbola->setMinorRadius(e.MinorRadius());
|
| hyperbola->setCenter(Base::Vector3d(p.X(), p.Y(), p.Z()));
|
| hyperbola->setAngleXU(-xdir.AngleWithRef(xdirref.XDirection(), normal));
|
| GeometryFacade::setConstruction(hyperbola, true);
|
| geos.emplace_back(hyperbola);
|
| }
|
| else {
|
| auto* aoh = new Part::GeomArcOfHyperbola();
|
| Handle(Geom_Curve) curve = new Geom_Hyperbola(e);
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(curve,
|
| projCurve.FirstParameter(),
|
| projCurve.LastParameter());
|
| aoh->setHandle(tCurve);
|
| GeometryFacade::setConstruction(aoh, true);
|
| geos.emplace_back(aoh);
|
| }
|
| }
|
| else if (projCurve.GetType() == GeomAbs_Parabola) {
|
| gp_Parab e = projCurve.Parabola();
|
| gp_Pnt p = e.Location();
|
| gp_Pnt P1 = projCurve.Value(projCurve.FirstParameter());
|
| gp_Pnt P2 = projCurve.Value(projCurve.LastParameter());
|
|
|
| gp_Dir normal = e.Axis().Direction();
|
| gp_Dir xdir = e.XAxis().Direction();
|
| gp_Ax2 xdirref(p, normal);
|
|
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* parabola = new Part::GeomParabola();
|
| parabola->setFocal(e.Focal());
|
| parabola->setCenter(Base::Vector3d(p.X(), p.Y(), p.Z()));
|
| parabola->setAngleXU(-xdir.AngleWithRef(xdirref.XDirection(), normal));
|
| GeometryFacade::setConstruction(parabola, true);
|
| geos.emplace_back(parabola);
|
| }
|
| else {
|
| auto* aop = new Part::GeomArcOfParabola();
|
| Handle(Geom_Curve) curve = new Geom_Parabola(e);
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(curve,
|
| projCurve.FirstParameter(),
|
| projCurve.LastParameter());
|
| aop->setHandle(tCurve);
|
| GeometryFacade::setConstruction(aop, true);
|
| geos.emplace_back(aop);
|
| }
|
| }
|
| else if (projCurve.GetType() == GeomAbs_Ellipse) {
|
| gp_Elips e = projCurve.Ellipse();
|
| gp_Pnt p = e.Location();
|
| gp_Pnt P1 = projCurve.Value(projCurve.FirstParameter());
|
| gp_Pnt P2 = projCurve.Value(projCurve.LastParameter());
|
|
|
| gp_Dir normal = gp_Dir(0, 0, 1);
|
| gp_Ax2 xdirref(p, normal);
|
|
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* ellipse = new Part::GeomEllipse();
|
| Handle(Geom_Ellipse) curve = new Geom_Ellipse(e);
|
| ellipse->setHandle(curve);
|
| GeometryFacade::setConstruction(ellipse, true);
|
| geos.emplace_back(ellipse);
|
| }
|
| else {
|
| auto* aoe = new Part::GeomArcOfEllipse();
|
| Handle(Geom_Curve) curve = new Geom_Ellipse(e);
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(curve,
|
| projCurve.FirstParameter(),
|
| projCurve.LastParameter());
|
| aoe->setHandle(tCurve);
|
| GeometryFacade::setConstruction(aoe, true);
|
| geos.emplace_back(aoe);
|
| }
|
| }
|
| else if (projCurve.GetType() == GeomAbs_BezierCurve) {
|
| Handle(Geom_BSplineCurve) hBSpline = GeomConvert::CurveToBSplineCurve(projCurve.Bezier());
|
| auto* bspline = new Part::GeomBSplineCurve(hBSpline);
|
| GeometryFacade::setConstruction(bspline, true);
|
| geos.emplace_back(bspline);
|
| }
|
| else if (projCurve.GetType() == GeomAbs_OffsetCurve) {
|
| Handle(Geom_BSplineCurve) hBSpline = GeomConvert::CurveToBSplineCurve(projCurve.OffsetCurve());
|
| auto* bspline = new Part::GeomBSplineCurve(hBSpline);
|
| GeometryFacade::setConstruction(bspline, true);
|
| geos.emplace_back(bspline);
|
| }
|
| else {
|
| throw Base::NotImplementedError("Not yet supported geometry for external geometry");
|
| }
|
| }
|
|
|
| void processEdge(const TopoDS_Edge& edge,
|
| std::vector<std::unique_ptr<Part::Geometry>>& geos,
|
| const Handle(Geom_Plane)& gPlane,
|
| const Base::Placement& invPlm,
|
| const gp_Trsf& mov,
|
| const gp_Pln& sketchPlane,
|
| const Base::Rotation& invRot,
|
| gp_Ax3& sketchAx3,
|
| TopoDS_Shape& aProjFace)
|
| {
|
| using std::numbers::pi;
|
|
|
| BRepAdaptor_Curve curve(edge);
|
| if (curve.GetType() == GeomAbs_Line) {
|
| geos.emplace_back(projectLine(curve, gPlane, invPlm));
|
| }
|
| else if (curve.GetType() == GeomAbs_Circle) {
|
| auto isFullCircle = [](const BRepAdaptor_Curve& curve) {
|
| double f = curve.FirstParameter();
|
| double l = curve.LastParameter();
|
| gp_Circ c;
|
| c.SetRadius(1.0);
|
|
|
| double diff = std::abs(l - f - c.Length());
|
| return diff < gp::Resolution();
|
| };
|
|
|
| gp_Dir vec1 = sketchPlane.Axis().Direction();
|
| gp_Dir vec2 = curve.Circle().Axis().Direction();
|
|
|
|
|
| gp_Pnt beg = curve.Value(curve.FirstParameter());
|
|
|
| gp_Pnt end = curve.Value(curve.LastParameter());
|
|
|
| if (vec1.IsParallel(vec2, Precision::Confusion())) {
|
| gp_Circ circle = curve.Circle();
|
| gp_Pnt cnt = circle.Location();
|
|
|
| GeomAPI_ProjectPointOnSurf proj(cnt, gPlane);
|
| cnt = proj.NearestPoint();
|
| circle.SetLocation(cnt);
|
| cnt.Transform(mov);
|
| circle.Transform(mov);
|
|
|
| if (beg.SquareDistance(end) < Precision::Confusion()) {
|
| auto* gCircle = new Part::GeomCircle();
|
| gCircle->setRadius(circle.Radius());
|
| gCircle->setCenter(Base::Vector3d(cnt.X(), cnt.Y(), cnt.Z()));
|
|
|
| GeometryFacade::setConstruction(gCircle, true);
|
| geos.emplace_back(gCircle);
|
| }
|
| else {
|
| auto* gArc = new Part::GeomArcOfCircle();
|
| Handle(Geom_Curve) hCircle = new Geom_Circle(circle);
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(
|
| hCircle, curve.FirstParameter(), curve.LastParameter());
|
| gArc->setHandle(tCurve);
|
| GeometryFacade::setConstruction(gArc, true);
|
| geos.emplace_back(gArc);
|
| }
|
| }
|
| else {
|
|
|
| gp_Circ origCircle = curve.Circle();
|
|
|
| if (vec1.IsNormal(vec2, Precision::Angular())) {
|
|
|
|
|
|
|
| gp_Pnt cnt = origCircle.Location();
|
| GeomAPI_ProjectPointOnSurf proj(cnt, gPlane);
|
| cnt = proj.NearestPoint();
|
|
|
| gp_Dir dirOrientation {vec1 ^ vec2};
|
| gp_Dir dirLine(dirOrientation);
|
|
|
| auto* projectedSegment = new Part::GeomLineSegment();
|
| Geom_Line ligne(cnt, dirLine);
|
| gp_Pnt P1, P2;
|
|
|
| ligne.D0(-origCircle.Radius(), P1);
|
| ligne.D0(origCircle.Radius(), P2);
|
|
|
| if (!curve.IsClosed()) {
|
| double alpha =
|
| dirOrientation.AngleWithRef(curve.Circle().XAxis().Direction(),
|
| curve.Circle().Axis().Direction());
|
|
|
| double baseAngle = curve.FirstParameter();
|
|
|
| int tours = 0;
|
| double startAngle = baseAngle + alpha;
|
|
|
| while (startAngle < -pi / 2.0 && tours < 10) {
|
| startAngle = baseAngle + ++tours * 2.0 * pi + alpha;
|
| }
|
| while (startAngle >= 3.0 * pi / 2.0 && tours > -10) {
|
| startAngle = baseAngle + --tours * 2.0 * pi + alpha;
|
| }
|
|
|
|
|
| double endAngle = curve.LastParameter() + startAngle - baseAngle;
|
|
|
| if (startAngle <= 0.0) {
|
| if (endAngle <= 0.0) {
|
| P1 = ProjPointOnPlane_XYZ(beg, sketchPlane);
|
| P2 = ProjPointOnPlane_XYZ(end, sketchPlane);
|
| }
|
| else {
|
| if (endAngle <= fabs(startAngle)) {
|
|
|
| P1 = ProjPointOnPlane_XYZ(beg, sketchPlane);
|
| }
|
| else if (endAngle < pi) {
|
|
|
| P1 = ProjPointOnPlane_XYZ(end, sketchPlane);
|
| }
|
| else {
|
|
|
|
|
| }
|
| }
|
| }
|
| else if (startAngle < pi) {
|
| if (endAngle < pi) {
|
| P1 = ProjPointOnPlane_XYZ(beg, sketchPlane);
|
| P2 = ProjPointOnPlane_XYZ(end, sketchPlane);
|
| }
|
| else if (endAngle < 2.0 * pi - startAngle) {
|
| P2 = ProjPointOnPlane_XYZ(beg, sketchPlane);
|
|
|
| }
|
| else if (endAngle < 2.0 * pi) {
|
| P2 = ProjPointOnPlane_XYZ(end, sketchPlane);
|
|
|
| }
|
| else {
|
|
|
|
|
| }
|
| }
|
| else {
|
| if (endAngle < 2 * pi) {
|
| P1 = ProjPointOnPlane_XYZ(beg, sketchPlane);
|
| P2 = ProjPointOnPlane_XYZ(end, sketchPlane);
|
| }
|
| else if (endAngle < 4 * pi - startAngle) {
|
| P1 = ProjPointOnPlane_XYZ(beg, sketchPlane);
|
|
|
| }
|
| else if (endAngle < 3 * pi) {
|
|
|
| P2 = ProjPointOnPlane_XYZ(end, sketchPlane);
|
| }
|
| else {
|
|
|
|
|
| }
|
| }
|
| }
|
|
|
| Base::Vector3d p1(P1.X(), P1.Y(), P1.Z());
|
| Base::Vector3d p2(P2.X(), P2.Y(), P2.Z());
|
| invPlm.multVec(p1, p1);
|
| invPlm.multVec(p2, p2);
|
|
|
| projectedSegment->setPoints(p1, p2);
|
| GeometryFacade::setConstruction(projectedSegment, true);
|
| geos.emplace_back(projectedSegment);
|
| }
|
| else {
|
| gp_Pnt cnt = origCircle.Location();
|
| GeomAPI_ProjectPointOnSurf proj(cnt, gPlane);
|
|
|
| cnt = proj.NearestPoint();
|
|
|
| Base::Vector3d p(cnt.X(), cnt.Y(), cnt.Z());
|
|
|
| invPlm.multVec(p, p);
|
|
|
|
|
| gp_Vec vecMajorAxis = vec1 ^ vec2;
|
|
|
| double minorRadius;
|
| double cosTheta;
|
|
|
|
|
| cosTheta = fabs(vec1.Dot(vec2));
|
| minorRadius = origCircle.Radius() * cosTheta;
|
|
|
|
|
| Base::Vector3d vectorMajorAxis(
|
| vecMajorAxis.X(), vecMajorAxis.Y(), vecMajorAxis.Z());
|
|
|
| invRot.multVec(vectorMajorAxis, vectorMajorAxis);
|
|
|
| vecMajorAxis.SetXYZ(
|
| gp_XYZ(vectorMajorAxis[0], vectorMajorAxis[1], vectorMajorAxis[2]));
|
|
|
|
|
| gp_Ax2 refFrameEllipse(
|
| gp_Pnt(gp_XYZ(p[0], p[1], p[2])), gp_Vec(0, 0, 1), vecMajorAxis);
|
|
|
| gp_Elips elipsDest;
|
| elipsDest.SetPosition(refFrameEllipse);
|
| elipsDest.SetMajorRadius(origCircle.Radius());
|
| elipsDest.SetMinorRadius(minorRadius);
|
|
|
| Handle(Geom_Ellipse) projCurve = new Geom_Ellipse(elipsDest);
|
|
|
| if (isFullCircle(curve)) {
|
|
|
| auto* ellipse = new Part::GeomEllipse();
|
| ellipse->setHandle(projCurve);
|
| GeometryFacade::setConstruction(ellipse, true);
|
| geos.emplace_back(ellipse);
|
| }
|
| else {
|
|
|
| auto* aoe = new Part::GeomArcOfEllipse();
|
| double firstParam, lastParam;
|
|
|
| adjustParameterRange(edge, gPlane, mov, projCurve, firstParam, lastParam);
|
|
|
| Handle(Geom_TrimmedCurve) trimmedCurve = new Geom_TrimmedCurve(projCurve, firstParam, lastParam);
|
| aoe->setHandle(trimmedCurve);
|
| GeometryFacade::setConstruction(aoe, true);
|
| geos.emplace_back(aoe);
|
| }
|
| }
|
| }
|
| }
|
| else if (curve.GetType() == GeomAbs_Ellipse) {
|
|
|
| gp_Pnt P1 = curve.Value(curve.FirstParameter());
|
| gp_Pnt P2 = curve.Value(curve.LastParameter());
|
| gp_Elips elipsOrig = curve.Ellipse();
|
| gp_Elips elipsDest;
|
| gp_Pnt origCenter = elipsOrig.Location();
|
| gp_Pnt destCenter = ProjPointOnPlane_UVN(origCenter, sketchPlane).XYZ();
|
|
|
| gp_Dir origAxisMajorDir = elipsOrig.XAxis().Direction();
|
| gp_Vec origAxisMajor = elipsOrig.MajorRadius() * gp_Vec(origAxisMajorDir);
|
| gp_Dir origAxisMinorDir = elipsOrig.YAxis().Direction();
|
| gp_Vec origAxisMinor = elipsOrig.MinorRadius() * gp_Vec(origAxisMinorDir);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| gp_Vec2d PA = ProjVecOnPlane_UV(origAxisMajor, sketchPlane);
|
| gp_Vec2d PB = ProjVecOnPlane_UV(origAxisMinor, sketchPlane);
|
| double t_max = 2.0 * PA.Dot(PB) / (PA.SquareMagnitude() - PB.SquareMagnitude());
|
| t_max = 0.5 * atan(t_max);
|
| double t_min = t_max + 0.5 * pi;
|
|
|
|
|
|
|
| gp_Vec ON_max = origAxisMajor * cos(t_max) + origAxisMinor * sin(t_max);
|
| gp_Vec ON_min = origAxisMajor * cos(t_min) + origAxisMinor * sin(t_min);
|
| gp_Vec destAxisMajor = ProjVecOnPlane_UVN(ON_max, sketchPlane);
|
| gp_Vec destAxisMinor = ProjVecOnPlane_UVN(ON_min, sketchPlane);
|
|
|
| double RDest = destAxisMajor.Magnitude();
|
| double rDest = destAxisMinor.Magnitude();
|
|
|
| if (RDest < rDest) {
|
| double rTmp = rDest;
|
| rDest = RDest;
|
| RDest = rTmp;
|
| gp_Vec axisTmp = destAxisMajor;
|
| destAxisMajor = destAxisMinor;
|
| destAxisMinor = axisTmp;
|
| }
|
|
|
| double sens = sketchAx3.Direction().Dot(elipsOrig.Position().Direction());
|
| int flip = sens > 0.0 ? 1.0 : -1.0;
|
| gp_Ax2 destCurveAx2(destCenter, gp_Dir(0, 0, flip), gp_Dir(destAxisMajor));
|
|
|
|
|
| if ((RDest - rDest) < (double)Precision::Confusion()) {
|
| Handle(Geom_Circle) projCurve = new Geom_Circle(destCurveAx2, 0.5 * (rDest + RDest));
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* circle = new Part::GeomCircle();
|
| circle->setHandle(projCurve);
|
| GeometryFacade::setConstruction(circle, true);
|
| geos.emplace_back(circle);
|
| }
|
| else {
|
| auto* arc = new Part::GeomArcOfCircle();
|
| double firstParam, lastParam;
|
| adjustParameterRange(edge, gPlane, mov, projCurve, firstParam, lastParam);
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(projCurve, firstParam, lastParam);
|
| arc->setHandle(tCurve);
|
| GeometryFacade::setConstruction(arc, true);
|
| geos.emplace_back(arc);
|
| }
|
| }
|
| else {
|
| if (sketchPlane.Position().Direction().IsNormal(
|
| elipsOrig.Position().Direction(), Precision::Angular())) {
|
| gp_Vec start = gp_Vec(destCenter.XYZ()) + destAxisMajor;
|
| gp_Vec end = gp_Vec(destCenter.XYZ()) - destAxisMajor;
|
|
|
| auto* projectedSegment = new Part::GeomLineSegment();
|
| projectedSegment->setPoints(
|
| Base::Vector3d(start.X(), start.Y(), start.Z()),
|
| Base::Vector3d(end.X(), end.Y(), end.Z()));
|
| GeometryFacade::setConstruction(projectedSegment, true);
|
| geos.emplace_back(projectedSegment);
|
| }
|
| else {
|
|
|
| elipsDest.SetPosition(destCurveAx2);
|
| elipsDest.SetMajorRadius(destAxisMajor.Magnitude());
|
| elipsDest.SetMinorRadius(destAxisMinor.Magnitude());
|
|
|
| Handle(Geom_Ellipse) projCurve = new Geom_Ellipse(elipsDest);
|
|
|
| if (P1.SquareDistance(P2) < Precision::Confusion()) {
|
| auto* ellipse = new Part::GeomEllipse();
|
| ellipse->setHandle(projCurve);
|
| GeometryFacade::setConstruction(ellipse, true);
|
| geos.emplace_back(ellipse);
|
| }
|
| else {
|
| auto* aoe = new Part::GeomArcOfEllipse();
|
| double firstParam, lastParam;
|
| adjustParameterRange(edge, gPlane, mov, projCurve, firstParam, lastParam);
|
|
|
| Handle(Geom_TrimmedCurve) tCurve = new Geom_TrimmedCurve(projCurve, firstParam, lastParam);
|
| aoe->setHandle(tCurve);
|
| GeometryFacade::setConstruction(aoe, true);
|
| geos.emplace_back(aoe);
|
| }
|
| }
|
| }
|
| }
|
| else {
|
| gp_Pln plane;
|
| auto shape = Part::TopoShape(edge);
|
| bool planar = shape.findPlane(plane);
|
|
|
|
|
| if (planar && plane.Axis().IsNormal(sketchPlane.Axis(), Precision::Angular())) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| shape.setPlacement(invPlm * shape.getPlacement());
|
|
|
|
|
|
|
|
|
| double angle = plane.Axis().Direction().Angle(sketchPlane.YAxis().Direction());
|
|
|
| gp_Trsf trsf;
|
| if (fabs(angle) > Precision::Angular()) {
|
| trsf.SetRotation(gp_Ax1(gp_Pnt(), gp_Dir(0, 0, 1)), angle);
|
| shape.move(trsf);
|
| }
|
|
|
|
|
| shape = shape.makeElementCopy();
|
|
|
|
|
|
|
| auto bbox = shape.getBoundBoxOptimal();
|
| if (!bbox.IsValid()){
|
| throw Base::CADKernelError("Invalid bounding box");
|
| }
|
|
|
| gp_Pnt p1(bbox.MinX, bbox.MinY, 0);
|
| gp_Pnt p2(bbox.MaxX, bbox.MaxY, 0);
|
| if (fabs(angle) > Precision::Angular()) {
|
| trsf.SetRotation(gp_Ax1(gp_Pnt(), gp_Dir(0, 0, 1)), -angle);
|
| p1.Transform(trsf);
|
| p2.Transform(trsf);
|
| }
|
|
|
| Base::Vector3d P1(p1.X(), p1.Y(), 0);
|
| Base::Vector3d P2(p2.X(), p2.Y(), 0);
|
|
|
|
|
| if (p1.SquareDistance(p2) < Precision::SquareConfusion()) {
|
| auto* point = new Part::GeomPoint((P1 + P2) / 2);
|
| GeometryFacade::setConstruction(point, true);
|
| geos.emplace_back(point);
|
| }
|
| else {
|
| auto* projectedSegment = new Part::GeomLineSegment();
|
| projectedSegment->setPoints(P1, P2);
|
| GeometryFacade::setConstruction(projectedSegment, true);
|
| geos.emplace_back(projectedSegment);
|
| }
|
| }
|
| else {
|
| try {
|
| Part::TopoShape projShape;
|
|
|
|
|
|
|
| if (planar && plane.Axis().Direction().IsParallel(sketchPlane.Axis().Direction(), Precision::Confusion())) {
|
| TopoDS_Edge projEdge = edge;
|
|
|
|
|
| if(curve.GetType() == GeomAbs_BSplineCurve){
|
| double Param1 = curve.FirstParameter();
|
| double Param2 = curve.LastParameter();
|
|
|
| if (Param1 > Param2){
|
| std::swap(Param1, Param2);
|
| }
|
|
|
|
|
| auto bsplineCurve = curve.BSpline();
|
| if(Param2 - Param1 > Precision::Confusion()){
|
| bsplineCurve->Segment(Param1, Param2);
|
| projEdge = BRepBuilderAPI_MakeEdge(bsplineCurve).Edge();
|
| }
|
| }
|
|
|
| projShape.setShape(projEdge);
|
|
|
|
|
|
|
| const gp_Pnt& aP = sketchPlane.Location();
|
| const gp_Pnt& aLoc = plane.Location ();
|
| const gp_Dir& aDir = plane.Axis().Direction();
|
| double d = (aDir.X() * (aP.X() - aLoc.X()) +
|
| aDir.Y() * (aP.Y() - aLoc.Y()) +
|
| aDir.Z() * (aP.Z() - aLoc.Z()));
|
|
|
| gp_Trsf trsf;
|
| trsf.SetTranslation(gp_Vec(aDir) * d);
|
| projShape.transformShape(Part::TopoShape::convert(trsf), false);
|
| } else {
|
|
|
|
|
| BRepOffsetAPI_NormalProjection mkProj(aProjFace);
|
| mkProj.Add(edge);
|
| mkProj.Build();
|
|
|
| projShape.setShape(mkProj.Projection());
|
| }
|
| if (!projShape.isNull() && projShape.hasSubShape(TopAbs_EDGE)) {
|
| for (auto &e : projShape.getSubTopoShapes(TopAbs_EDGE)) {
|
|
|
| e.transformShape(invPlm.toMatrix(), true, true);
|
| TopoDS_Edge projEdge = TopoDS::Edge(e.getShape());
|
| processEdge2(projEdge, geos);
|
| }
|
| }
|
| }
|
| catch (Standard_Failure& e) {
|
| throw Base::CADKernelError(e.GetMessageString());
|
| }
|
| }
|
| }
|
| }
|
|
|
| std::vector<TopoDS_Shape> projectShape(const TopoDS_Shape& inShape, const gp_Ax3& viewAxis)
|
| {
|
| std::vector<TopoDS_Shape> res;
|
| Handle(HLRBRep_Algo) brep_hlr;
|
| try {
|
| brep_hlr = new HLRBRep_Algo();
|
| brep_hlr->Add(inShape);
|
|
|
| gp_Trsf aTrsf;
|
| aTrsf.SetTransformation(viewAxis);
|
| HLRAlgo_Projector projector(aTrsf, false, 1);
|
|
|
| brep_hlr->Projector(projector);
|
| brep_hlr->Update();
|
| brep_hlr->Hide();
|
| }
|
| catch (const Standard_Failure& e) {
|
| Base::Console().error("GO::projectShape - OCC error - %s - while projecting shape\n",
|
| e.GetMessageString());
|
| throw Base::RuntimeError("SketchObject::projectShape - OCC error");
|
| }
|
| catch (...) {
|
| throw Base::RuntimeError("SketchObject::projectShape - unknown error");
|
| }
|
|
|
| try {
|
| HLRBRep_HLRToShape hlrToShape(brep_hlr);
|
| if (!hlrToShape.VCompound().IsNull()) {
|
|
|
| res.push_back(hlrToShape.VCompound());
|
| }
|
|
|
| if (!hlrToShape.Rg1LineVCompound().IsNull()) {
|
| res.push_back(hlrToShape.Rg1LineVCompound());
|
| }
|
|
|
| if (!hlrToShape.OutLineVCompound().IsNull()) {
|
| res.push_back(hlrToShape.OutLineVCompound());
|
| }
|
|
|
| if (!hlrToShape.IsoLineVCompound().IsNull()) {
|
| res.push_back(hlrToShape.IsoLineVCompound());
|
| }
|
|
|
| if (!hlrToShape.HCompound().IsNull()) {
|
| res.push_back(hlrToShape.HCompound());
|
| }
|
|
|
| if (!hlrToShape.Rg1LineHCompound().IsNull()) {
|
| res.push_back(hlrToShape.Rg1LineHCompound());
|
| }
|
|
|
| if (!hlrToShape.OutLineHCompound().IsNull()) {
|
| res.push_back(hlrToShape.OutLineHCompound());
|
| }
|
|
|
| if (!hlrToShape.IsoLineHCompound().IsNull()) {
|
| res.push_back(hlrToShape.IsoLineHCompound());
|
| }
|
| }
|
| catch (const Standard_Failure&) {
|
| throw Base::RuntimeError(
|
| "SketchObject::projectShape - OCC error occurred while extracting edges");
|
| }
|
| catch (...) {
|
| throw Base::RuntimeError(
|
| "SketchObject::projectShape - unknown error occurred while extracting edges");
|
| }
|
|
|
| return res;
|
| }
|
|
|
| void processFace (const Rotation& invRot,
|
| const Placement& invPlm,
|
| const gp_Trsf& mov,
|
| const gp_Pln& sketchPlane,
|
| const Handle(Geom_Plane)& gPlane,
|
| gp_Ax3& sketchAx3,
|
| TopoDS_Shape& aProjFace,
|
| std::vector<std::unique_ptr<Part::Geometry>>& geos,
|
| TopoDS_Shape& refSubShape)
|
| {
|
| const TopoDS_Face& face = TopoDS::Face(refSubShape);
|
| BRepAdaptor_Surface surface(face);
|
| if (surface.GetType() == GeomAbs_Plane) {
|
|
|
| Geom_Plane plane = surface.Plane();
|
| gp_Dir dnormal = plane.Axis().Direction();
|
| gp_Dir snormal = sketchPlane.Axis().Direction();
|
|
|
|
|
| TopExp_Explorer edgeExp;
|
| for (edgeExp.Init(face, TopAbs_EDGE); edgeExp.More(); edgeExp.Next()) {
|
| TopoDS_Edge edge = TopoDS::Edge(edgeExp.Current());
|
|
|
| processEdge(edge, geos, gPlane, invPlm, mov, sketchPlane, invRot, sketchAx3, aProjFace);
|
| }
|
|
|
| if (fabs(dnormal.Angle(snormal) - std::numbers::pi/2) < Precision::Confusion()) {
|
|
|
|
|
|
|
| bool initialized = false;
|
| Vector3d start, end;
|
|
|
| auto updateExtremes = [&](const Vector3d& point) {
|
| if ((point - start).Length() < (point - end).Length()) {
|
|
|
| if ((point - end).Length() > (end - start).Length()) {
|
| start = point;
|
| }
|
| }
|
| else {
|
|
|
| if ((point - start).Length() > (end - start).Length()) {
|
| end = point;
|
| }
|
| }
|
| };
|
| for (auto& geo : geos) {
|
| auto* line = dynamic_cast<Part::GeomLineSegment*>(geo.get());
|
| if (!line) {
|
|
|
|
|
|
|
| continue;
|
| }
|
| if (!initialized) {
|
| start = line->getStartPoint();
|
| end = line->getEndPoint();
|
| initialized = true;
|
| continue;
|
| }
|
|
|
| updateExtremes(line->getStartPoint());
|
| updateExtremes(line->getEndPoint());
|
| }
|
| if (initialized) {
|
| auto* unifiedLine = new Part::GeomLineSegment();
|
| unifiedLine->setPoints(start, end);
|
| geos.clear();
|
| geos.emplace_back(unifiedLine);
|
| }
|
| else {
|
|
|
|
|
|
|
|
|
|
|
| gp_Dir lnormal = dnormal.Crossed(snormal);
|
| BRepBuilderAPI_MakeEdge builder(gp_Lin(plane.Location(), lnormal));
|
| builder.Build();
|
| if (builder.IsDone()) {
|
| const TopoDS_Edge& edge = TopoDS::Edge(builder.Shape());
|
| BRepAdaptor_Curve curve(edge);
|
| if (curve.GetType() == GeomAbs_Line) {
|
| geos.emplace_back(projectLine(curve, gPlane, invPlm));
|
| }
|
| }
|
| }
|
| }
|
| }
|
| else {
|
| std::vector<TopoDS_Shape> res = projectShape(face, sketchAx3);
|
| for (auto& resShape : res) {
|
| TopExp_Explorer explorer(resShape, TopAbs_EDGE);
|
| while (explorer.More()) {
|
| TopoDS_Edge projEdge = TopoDS::Edge(explorer.Current());
|
| processEdge2(projEdge, geos);
|
| explorer.Next();
|
| }
|
| }
|
| }
|
| }
|
|
|
| }
|
|
|
| void SketchObject::rebuildExternalGeometry(std::optional<ExternalToAdd> extToAdd)
|
| {
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
|
|
|
|
| std::map<std::string, bool> linkIsDefiningMap;
|
| for (const auto& geo : ExternalGeo.getValues()) {
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if (!egf->getRef().empty()) {
|
| bool isDefining = egf->testFlag(ExternalGeometryExtension::Defining);
|
| if (linkIsDefiningMap.find(egf->getRef()) == linkIsDefiningMap.end()) {
|
| linkIsDefiningMap[egf->getRef()] = isDefining;
|
| }
|
| else {
|
| linkIsDefiningMap[egf->getRef()] = linkIsDefiningMap[egf->getRef()] && isDefining;
|
| }
|
| }
|
| }
|
|
|
|
|
| auto Types = ExternalTypes.getValues();
|
| auto Objects = ExternalGeometry.getValues();
|
| auto SubElements = ExternalGeometry.getSubValues();
|
| assert(externalGeoRef.size() == Objects.size());
|
| auto keys = externalGeoRef;
|
|
|
|
|
|
|
|
|
| for(auto &geo : ExternalGeo.getValues()) {
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if(egf->getRef().size() && egf->testFlag(ExternalGeometryExtension::Missing)) {
|
| const std::string &ref = egf->getRef();
|
| auto pos = ref.find('.');
|
| if(pos == std::string::npos)
|
| continue;
|
| std::string objName = ref.substr(0,pos);
|
| auto obj = getDocument()->getObject(objName.c_str());
|
| if(!obj)
|
| continue;
|
| App::ElementNamePair elementName;
|
| App::GeoFeature::resolveElement(obj,ref.c_str()+pos+1,elementName);
|
| if(elementName.oldName.size()
|
| && !App::GeoFeature::hasMissingElement(elementName.oldName.c_str()))
|
| {
|
| Objects.push_back(obj);
|
| SubElements.push_back(elementName.oldName);
|
| keys.push_back(ref);
|
| }
|
| }
|
| }
|
|
|
| Base::Placement Plm = Placement.getValue();
|
| Base::Vector3d Pos = Plm.getPosition();
|
| Base::Rotation Rot = Plm.getRotation();
|
| Base::Rotation invRot = Rot.inverse();
|
| Base::Vector3d dN(0, 0, 1);
|
| Rot.multVec(dN, dN);
|
| Base::Vector3d dX(1, 0, 0);
|
| Rot.multVec(dX, dX);
|
|
|
| Base::Placement invPlm = Plm.inverse();
|
| Base::Matrix4D invMat = invPlm.toMatrix();
|
| gp_Trsf mov;
|
| mov.SetValues(invMat[0][0],
|
| invMat[0][1],
|
| invMat[0][2],
|
| invMat[0][3],
|
| invMat[1][0],
|
| invMat[1][1],
|
| invMat[1][2],
|
| invMat[1][3],
|
| invMat[2][0],
|
| invMat[2][1],
|
| invMat[2][2],
|
| invMat[2][3]);
|
|
|
| gp_Ax3 sketchAx3(
|
| gp_Pnt(Pos.x, Pos.y, Pos.z), gp_Dir(dN.x, dN.y, dN.z), gp_Dir(dX.x, dX.y, dX.z));
|
| gp_Pln sketchPlane(sketchAx3);
|
|
|
| Handle(Geom_Plane) gPlane = new Geom_Plane(sketchPlane);
|
| BRepBuilderAPI_MakeFace mkFace(sketchPlane);
|
| TopoDS_Shape aProjFace = mkFace.Shape();
|
|
|
| Types.resize(Objects.size(), static_cast<long>(ExtType::Projection));
|
|
|
| std::set<std::string> refSet;
|
|
|
| std::vector<std::vector<std::unique_ptr<Part::Geometry> > > newGeos;
|
| newGeos.reserve(Objects.size());
|
| for (int i=0; i < int(Objects.size()); i++) {
|
| const App::DocumentObject *Obj=Objects[i];
|
| const std::string &SubElement=SubElements[i];
|
| const std::string &key = keys[i];
|
|
|
| bool beingCreated = false;
|
| if (extToAdd) {
|
| beingCreated = extToAdd->obj == Obj && extToAdd->subname == SubElement;
|
| }
|
|
|
| bool projection = Types[i] == (int)ExtType::Projection || Types[i] == (int)ExtType::Both;
|
| bool intersection = Types[i] == (int)ExtType::Intersection || Types[i] == (int)ExtType::Both;
|
|
|
|
|
| bool frozen = false;
|
| bool sync = false;
|
| for(auto id : externalGeoRefMap[key]) {
|
| auto it = externalGeoMap.find(id);
|
| if(it != externalGeoMap.end()) {
|
| auto egf = ExternalGeometryFacade::getFacade(ExternalGeo[it->second]);
|
| if(egf->testFlag(ExternalGeometryExtension::Frozen)) {
|
| frozen = true;
|
| }
|
| if (egf->testFlag(ExternalGeometryExtension::Sync)) {
|
| sync = true;
|
| }
|
| }
|
| }
|
| if(frozen && !sync) {
|
| refSet.insert(std::move(key));
|
| continue;
|
| }
|
| if (!Obj || !Obj->getNameInDocument()) {
|
| continue;
|
| }
|
|
|
| std::vector<std::unique_ptr<Part::Geometry> > geos;
|
|
|
| auto importVertex = [&](const TopoDS_Shape& refSubShape) {
|
| gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(refSubShape));
|
| GeomAPI_ProjectPointOnSurf proj(P, gPlane);
|
| P = proj.NearestPoint();
|
| Base::Vector3d p(P.X(), P.Y(), P.Z());
|
| invPlm.multVec(p, p);
|
|
|
| auto* point = new Part::GeomPoint(p);
|
| GeometryFacade::setConstruction(point, true);
|
| geos.emplace_back(point);
|
| };
|
|
|
| try {
|
| TopoDS_Shape refSubShape;
|
|
|
| if (Obj->isDerivedFrom<Part::Datum>()) {
|
| auto* datum = static_cast<const Part::Datum*>(Obj);
|
| refSubShape = datum->getShape();
|
| }
|
| else if (Obj->isDerivedFrom<Part::Feature>()) {
|
| auto* refObj = static_cast<const Part::Feature*>(Obj);
|
| const Part::TopoShape& refShape = refObj->Shape.getShape();
|
| refSubShape = refShape.getSubShape(SubElement.c_str());
|
| }
|
| else if (Obj->isDerivedFrom<App::Plane>()) {
|
| auto* pl = static_cast<const App::Plane*>(Obj);
|
| Base::Placement plm = pl->Placement.getValue();
|
| Base::Vector3d base = plm.getPosition();
|
| Base::Rotation rot = plm.getRotation();
|
| Base::Vector3d normal(0, 0, 1);
|
| rot.multVec(normal, normal);
|
| gp_Pln plane(gp_Pnt(base.x, base.y, base.z), gp_Dir(normal.x, normal.y, normal.z));
|
| BRepBuilderAPI_MakeFace fBuilder(plane);
|
| if (!fBuilder.IsDone())
|
| throw Base::RuntimeError(
|
| "Sketcher: addExternal(): Failed to build face from App::Plane");
|
|
|
| TopoDS_Face f = TopoDS::Face(fBuilder.Shape());
|
| refSubShape = f;
|
| }
|
| else if (Obj->isDerivedFrom<Part::DatumLine>()) {
|
| auto* line = static_cast<const Part::DatumLine*>(Obj);
|
| Base::Placement plm = line->Placement.getValue();
|
| Base::Vector3d base = plm.getPosition();
|
| Base::Vector3d dir = line->getDirection();
|
| gp_Lin l(gp_Pnt(base.x, base.y, base.z), gp_Dir(dir.x, dir.y, dir.z));
|
| BRepBuilderAPI_MakeEdge eBuilder(l);
|
| if (!eBuilder.IsDone()) {
|
| throw Base::RuntimeError(
|
| "Sketcher: addExternal(): Failed to build edge from Part::DatumLine");
|
| }
|
|
|
| TopoDS_Edge e = TopoDS::Edge(eBuilder.Shape());
|
| refSubShape = e;
|
| }
|
| else if (Obj->isDerivedFrom<Part::DatumPoint>()) {
|
| auto* point = static_cast<const Part::DatumPoint*>(Obj);
|
| Base::Placement plm = point->Placement.getValue();
|
| Base::Vector3d base = plm.getPosition();
|
| gp_Pnt p(base.x, base.y, base.z);
|
| BRepBuilderAPI_MakeVertex eBuilder(p);
|
| if (!eBuilder.IsDone()) {
|
| throw Base::RuntimeError(
|
| "Sketcher: addExternal(): Failed to build vertex from Part::DatumPoint");
|
| }
|
|
|
| TopoDS_Vertex v = TopoDS::Vertex(eBuilder.Shape());
|
| refSubShape = v;
|
| }
|
| else {
|
| throw Base::TypeError(
|
| "Datum feature type is not yet supported as external geometry for a sketch");
|
| }
|
|
|
| if (projection && !refSubShape.IsNull()) {
|
| switch (refSubShape.ShapeType()) {
|
| case TopAbs_FACE: {
|
| processFace(invRot, invPlm, mov, sketchPlane, gPlane, sketchAx3, aProjFace, geos, refSubShape);
|
| } break;
|
| case TopAbs_EDGE: {
|
| const TopoDS_Edge& edge = TopoDS::Edge(refSubShape);
|
| processEdge(edge, geos, gPlane, invPlm, mov, sketchPlane, invRot, sketchAx3, aProjFace);
|
| } break;
|
| case TopAbs_VERTEX: {
|
| importVertex(refSubShape);
|
| } break;
|
| default:
|
| throw Base::TypeError("Unknown type of geometry");
|
| break;
|
| }
|
| if (beingCreated && !extToAdd->intersection) {
|
|
|
| for (auto& geo : geos) {
|
| auto egf = ExternalGeometryFacade::getFacade(geo.get());
|
| egf->setFlag(ExternalGeometryExtension::Defining, extToAdd->defining);
|
| }
|
| }
|
| }
|
| int projSize = geos.size();
|
|
|
| if (intersection && !refSubShape.IsNull()) {
|
| FCBRepAlgoAPI_Section maker(refSubShape, sketchPlane);
|
| maker.Approximation(Standard_True);
|
| if (!maker.IsDone())
|
| FC_THROWM(Base::CADKernelError, "Failed to get intersection");
|
| Part::TopoShape intersectionShape(maker.Shape());
|
| auto edges = intersectionShape.getSubTopoShapes(TopAbs_EDGE);
|
| for (const auto& s : edges) {
|
| TopoDS_Edge edge = TopoDS::Edge(s.getShape());
|
| processEdge(edge, geos, gPlane, invPlm, mov, sketchPlane, invRot, sketchAx3, aProjFace);
|
| }
|
|
|
|
|
|
|
| if (refSubShape.ShapeType() == TopAbs_FACE && geos.size() > 1) {
|
| auto wires = Part::TopoShape().makeElementWires(edges);
|
| if (wires.countSubShapes(TopAbs_WIRE) == 1) {
|
| TopoDS_Vertex firstVertex, lastVertex;
|
| BRepTools_WireExplorer exp(TopoDS::Wire(wires.getSubShape(TopAbs_WIRE, 1)));
|
| firstVertex = exp.CurrentVertex();
|
| while (!exp.More())
|
| exp.Next();
|
| lastVertex = exp.CurrentVertex();
|
| gp_Pnt P1 = BRep_Tool::Pnt(firstVertex);
|
| gp_Pnt P2 = BRep_Tool::Pnt(lastVertex);
|
| if (auto geo = fitArcs(geos, P1, P2, ArcFitTolerance.getValue())) {
|
| geos.clear();
|
| geos.emplace_back(geo);
|
| }
|
| }
|
| }
|
| for (const auto& s : intersectionShape.getSubShapes(TopAbs_VERTEX, TopAbs_EDGE)) {
|
| importVertex(s);
|
| }
|
|
|
| if (beingCreated && extToAdd->intersection) {
|
|
|
| for (size_t i = projSize; i < geos.size(); ++i) {
|
| auto egf = ExternalGeometryFacade::getFacade(geos[i].get());
|
| egf->setFlag(ExternalGeometryExtension::Defining, extToAdd->defining);
|
| }
|
| }
|
| }
|
|
|
| } catch (Base::Exception &e) {
|
| FC_ERR("Failed to project external geometry in "
|
| << getFullName() << ": " << key << std::endl << e.what());
|
| continue;
|
| } catch (Standard_Failure &e) {
|
| FC_ERR("Failed to project external geometry in "
|
| << getFullName() << ": " << key << std::endl << e.GetMessageString());
|
| continue;
|
| } catch (std::exception &e) {
|
| FC_ERR("Failed to project external geometry in "
|
| << getFullName() << ": " << key << std::endl << e.what());
|
| continue;
|
| } catch (...) {
|
| FC_ERR("Failed to project external geometry in "
|
| << getFullName() << ": " << key << std::endl << "Unknown exception");
|
| continue;
|
| }
|
| if (geos.empty()) {
|
| continue;
|
| }
|
|
|
| if(!refSet.emplace(key).second) {
|
| FC_WARN("Duplicated external reference in " << getFullName() << ": " << key);
|
| continue;
|
| }
|
|
|
| for (auto& geo : geos) {
|
| ExternalGeometryFacade::getFacade(geo.get())->setRef(key);
|
| }
|
| newGeos.push_back(std::move(geos));
|
| }
|
|
|
|
|
| for(auto &geos : newGeos) {
|
| auto egf = ExternalGeometryFacade::getFacade(geos.front().get());
|
| auto &refs = externalGeoRefMap[egf->getRef()];
|
| while(refs.size() < geos.size())
|
| refs.push_back(++geoLastId);
|
|
|
|
|
| std::set<long> geoIds;
|
| geoIds.insert(refs.begin()+geos.size(),refs.end());
|
|
|
|
|
| int i = 0;
|
| for(auto &geo : geos)
|
| GeometryFacade::setId(geo.get(), refs[i++]);
|
|
|
| delExternalPrivate(geoIds,false);
|
| }
|
|
|
| auto geoms = ExternalGeo.getValues();
|
|
|
|
|
| for(auto &geos : newGeos) {
|
| if (geos.empty()) {
|
| continue;
|
| }
|
|
|
|
|
| const std::string& key = ExternalGeometryFacade::getFacade(geos.front().get())->getRef();
|
| auto itKey = linkIsDefiningMap.find(key);
|
| bool hasLinkState = itKey != linkIsDefiningMap.end();
|
| bool isLinkDefining = hasLinkState ? itKey->second : false;
|
|
|
| for(auto &geo : geos) {
|
| auto it = externalGeoMap.find(GeometryFacade::getId(geo.get()));
|
| if(it == externalGeoMap.end()) {
|
|
|
|
|
| if (hasLinkState) {
|
| ExternalGeometryFacade::getFacade(geo.get())->setFlag(ExternalGeometryExtension::Defining, isLinkDefining);
|
| }
|
| geoms.push_back(geo.release());
|
| continue;
|
| }
|
|
|
| ExternalGeometryFacade::copyFlags(geoms[it->second], geo.get());
|
| geoms[it->second] = geo.release();
|
| }
|
| }
|
|
|
|
|
| bool hasError = false;
|
| for(auto geo : geoms) {
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| egf->setFlag(ExternalGeometryExtension::Sync,false);
|
| if(egf->getRef().empty())
|
| continue;
|
| if(!refSet.count(egf->getRef())) {
|
| FC_ERR( "External geometry " << getFullName() << ".e" << egf->getId()
|
| << " missing reference: " << egf->getRef());
|
| hasError = true;
|
| egf->setFlag(ExternalGeometryExtension::Missing,true);
|
| } else {
|
| egf->setFlag(ExternalGeometryExtension::Missing,false);
|
| }
|
| }
|
|
|
| ExternalGeo.setValues(std::move(geoms));
|
| rebuildVertexIndex();
|
|
|
|
|
| if(refSet.size() != (size_t)ExternalGeometry.getSize()) {
|
| if(refSet.size() < keys.size()) {
|
| auto itObj = Objects.begin();
|
| auto itSub = SubElements.begin();
|
| for(auto &ref : keys) {
|
| if(!refSet.count(ref)) {
|
| itObj = Objects.erase(itObj);
|
| itSub = SubElements.erase(itSub);
|
| }else {
|
| ++itObj;
|
| ++itSub;
|
| }
|
| }
|
| }
|
| ExternalGeometry.setValues(Objects,SubElements);
|
| }
|
|
|
| solverNeedsUpdate=true;
|
| Constraints.acceptGeometry(getCompleteGeometry());
|
|
|
| if (hasError && this->isRecomputing()) {
|
| throw Base::RuntimeError("Missing external geometry reference");
|
| }
|
| }
|
|
|
| void SketchObject::fixExternalGeometry(const std::vector<int> &geoIds) {
|
| std::set<int> idSet(geoIds.begin(),geoIds.end());
|
| auto geos = ExternalGeo.getValues();
|
| auto objs = ExternalGeometry.getValues();
|
| auto subs = ExternalGeometry.getSubValues();
|
| bool touched = false;
|
| for(int i=2;i<(int)geos.size();++i) {
|
| auto &geo = geos[i];
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| int GeoId = -i-1;
|
| if(egf->getRef().empty()
|
| || !egf->testFlag(ExternalGeometryExtension::Missing)
|
| || (idSet.size() && !idSet.count(GeoId)))
|
| continue;
|
| std::string ref = egf->getRef();
|
| auto pos = ref.find('.');
|
| if(pos == std::string::npos) {
|
| FC_ERR("Invalid geometry reference " << ref);
|
| continue;
|
| }
|
| std::string objName = ref.substr(0,pos);
|
| auto obj = getDocument()->getObject(objName.c_str());
|
| if(!obj) {
|
| FC_ERR("Cannot find object in reference " << ref);
|
| continue;
|
| }
|
|
|
| auto elements = Part::Feature::getRelatedElements(obj,ref.c_str()+pos+1);
|
| if(!elements.size()) {
|
| FC_ERR("No related reference found for " << ref);
|
| continue;
|
| }
|
|
|
| geo = geo->clone();
|
| egf->setGeometry(geo);
|
| egf->setFlag(ExternalGeometryExtension::Missing,false);
|
| ref = objName + "." + Data::ComplexGeoData::elementMapPrefix();
|
| elements.front().name.appendToBuffer(ref);
|
| egf->setRef(ref);
|
| objs.push_back(obj);
|
| subs.emplace_back();
|
| elements.front().index.appendToStringBuffer(subs.back());
|
| touched = true;
|
| }
|
|
|
| if(touched) {
|
| ExternalGeo.setValues(geos);
|
| ExternalGeometry.setValues(objs,subs);
|
| rebuildExternalGeometry();
|
| }
|
| }
|
|
|
| std::vector<Part::Geometry*> SketchObject::getCompleteGeometry() const
|
| {
|
| std::vector<Part::Geometry*> vals = getInternalGeometry();
|
| const auto &geos = getExternalGeometry();
|
| vals.insert(vals.end(), geos.rbegin(), geos.rend());
|
| return vals;
|
| }
|
|
|
| GeoListFacade SketchObject::getGeoListFacade() const
|
| {
|
| std::vector<GeometryFacadeUniquePtr> facade;
|
| facade.reserve(Geometry.getSize() + ExternalGeo.getSize());
|
|
|
| for (auto geo : Geometry.getValues())
|
| facade.push_back(GeometryFacade::getFacade(geo));
|
|
|
| const auto &externalGeos = ExternalGeo.getValues();
|
| for(auto rit = externalGeos.rbegin(); rit != externalGeos.rend(); rit++)
|
| facade.push_back(GeometryFacade::getFacade(*rit));
|
|
|
| return GeoListFacade::getGeoListModel(std::move(facade), Geometry.getSize());
|
| }
|
|
|
| void SketchObject::rebuildVertexIndex()
|
| {
|
| VertexId2GeoId.resize(0);
|
| VertexId2PosId.resize(0);
|
| int imax = getHighestCurveIndex();
|
| int i = 0;
|
| const std::vector<Part::Geometry*> geometry = getCompleteGeometry();
|
| if (geometry.size() <= 2)
|
| return;
|
| for (auto it = geometry.cbegin(); it != geometry.cend() - 2; ++it, ++i) {
|
| if (i > imax)
|
| i = -getExternalGeometryCount();
|
| if ((*it)->is<Part::GeomPoint>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| }
|
| else if ((*it)->is<Part::GeomLineSegment>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::end);
|
| }
|
| else if ((*it)->is<Part::GeomCircle>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::mid);
|
| }
|
| else if ((*it)->is<Part::GeomEllipse>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::mid);
|
| }
|
| else if ((*it)->is<Part::GeomArcOfCircle>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::end);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::mid);
|
| }
|
| else if ((*it)->is<Part::GeomArcOfEllipse>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::end);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::mid);
|
| }
|
| else if ((*it)->is<Part::GeomArcOfHyperbola>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::end);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::mid);
|
| }
|
| else if ((*it)->is<Part::GeomArcOfParabola>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::end);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::mid);
|
| }
|
| else if ((*it)->is<Part::GeomBSplineCurve>()) {
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::start);
|
| VertexId2GeoId.push_back(i);
|
| VertexId2PosId.push_back(PointPos::end);
|
| }
|
| }
|
| }
|
|
|
| const std::vector<std::map<int, Sketcher::PointPos>> SketchObject::getCoincidenceGroups()
|
| {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| const std::vector<Sketcher::Constraint*>& vals = Constraints.getValues();
|
|
|
| std::vector<std::map<int, Sketcher::PointPos>> coincidenttree;
|
|
|
| for (const auto& constr : vals) {
|
| if (constr->Type != Sketcher::Coincident) {
|
| continue;
|
| }
|
|
|
| int firstpresentin = -1;
|
| int secondpresentin = -1;
|
|
|
| int i = 0;
|
|
|
| for (auto iti = coincidenttree.begin(); iti != coincidenttree.end(); ++iti, ++i) {
|
|
|
| std::map<int, Sketcher::PointPos>::const_iterator filiterator;
|
| filiterator = (*iti).find(constr->First);
|
| if (filiterator != (*iti).end() && constr->FirstPos == (*filiterator).second) {
|
| firstpresentin = i;
|
| }
|
|
|
| filiterator = (*iti).find(constr->Second);
|
| if (filiterator != (*iti).end() && constr->SecondPos == (*filiterator).second) {
|
| secondpresentin = i;
|
| }
|
| }
|
|
|
| if (firstpresentin != -1 && secondpresentin != -1) {
|
|
|
| coincidenttree[firstpresentin].insert(coincidenttree[secondpresentin].begin(),
|
| coincidenttree[secondpresentin].end());
|
| coincidenttree.erase(coincidenttree.begin() + secondpresentin);
|
| }
|
| else if (firstpresentin == -1 && secondpresentin == -1) {
|
|
|
| std::map<int, Sketcher::PointPos> tmp;
|
| tmp.insert(std::pair<int, Sketcher::PointPos>(constr->First, constr->FirstPos));
|
| tmp.insert(std::pair<int, Sketcher::PointPos>(constr->Second, constr->SecondPos));
|
| coincidenttree.push_back(std::move(tmp));
|
| }
|
| else if (firstpresentin != -1) {
|
|
|
| coincidenttree[firstpresentin].insert(
|
| std::pair<int, Sketcher::PointPos>(constr->Second, constr->SecondPos));
|
| }
|
| else {
|
|
|
| coincidenttree[secondpresentin].insert(
|
| std::pair<int, Sketcher::PointPos>(constr->First, constr->FirstPos));
|
| }
|
| }
|
|
|
| return coincidenttree;
|
| }
|
|
|
| void SketchObject::isCoincidentWithExternalGeometry(int GeoId, bool& start_external,
|
| bool& mid_external, bool& end_external)
|
| {
|
| start_external = false;
|
| mid_external = false;
|
| end_external = false;
|
|
|
| const std::vector<std::map<int, Sketcher::PointPos>> coincidenttree = getCoincidenceGroups();
|
|
|
| for (const auto& cGroup : coincidenttree) {
|
| const auto& geoId1iterator = cGroup.find(GeoId);
|
| if (geoId1iterator == cGroup.end()) {
|
| continue;
|
| }
|
|
|
| if (cGroup.begin()->first >= 0) {
|
| continue;
|
| }
|
|
|
|
|
| if (geoId1iterator->second == Sketcher::PointPos::start)
|
| start_external = true;
|
| else if (geoId1iterator->second == Sketcher::PointPos::mid)
|
| mid_external = true;
|
| else if (geoId1iterator->second == Sketcher::PointPos::end)
|
| end_external = true;
|
| }
|
| }
|
|
|
| const std::map<int, Sketcher::PointPos> SketchObject::getAllCoincidentPoints(int GeoId,
|
| PointPos PosId)
|
| {
|
| const std::vector<std::map<int, Sketcher::PointPos>> coincidenttree = getCoincidenceGroups();
|
|
|
| for (const auto& cGroup : coincidenttree) {
|
| std::map<int, Sketcher::PointPos>::const_iterator geoId1iterator;
|
|
|
| geoId1iterator = cGroup.find(GeoId);
|
|
|
| if (geoId1iterator != cGroup.end()) {
|
|
|
|
|
| if (geoId1iterator->second == PosId)
|
| return cGroup;
|
| }
|
| }
|
|
|
| std::map<int, Sketcher::PointPos> empty;
|
|
|
| return empty;
|
| }
|
|
|
|
|
| void SketchObject::getDirectlyCoincidentPoints(int GeoId, PointPos PosId,
|
| std::vector<int>& GeoIdList,
|
| std::vector<PointPos>& PosIdList) const
|
| {
|
| const std::vector<Constraint*>& constraints = this->Constraints.getValues();
|
|
|
| GeoIdList.clear();
|
| PosIdList.clear();
|
| GeoIdList.push_back(GeoId);
|
| PosIdList.push_back(PosId);
|
| for (const auto& constr : constraints) {
|
| if (constr->Type == Sketcher::Coincident) {
|
| if (constr->First == GeoId && constr->FirstPos == PosId) {
|
| GeoIdList.push_back(constr->Second);
|
| PosIdList.push_back(constr->SecondPos);
|
| }
|
| else if (constr->Second == GeoId && constr->SecondPos == PosId) {
|
| GeoIdList.push_back(constr->First);
|
| PosIdList.push_back(constr->FirstPos);
|
| }
|
| }
|
| if (constr->Type == Sketcher::Tangent) {
|
| if (constr->First == GeoId && constr->FirstPos == PosId &&
|
| (constr->SecondPos == Sketcher::PointPos::start ||
|
| constr->SecondPos == Sketcher::PointPos::end)) {
|
| GeoIdList.push_back(constr->Second);
|
| PosIdList.push_back(constr->SecondPos);
|
| }
|
| if (constr->Second == GeoId && constr->SecondPos == PosId &&
|
| (constr->FirstPos == Sketcher::PointPos::start ||
|
| constr->FirstPos == Sketcher::PointPos::end)) {
|
| GeoIdList.push_back(constr->First);
|
| PosIdList.push_back(constr->FirstPos);
|
| }
|
| }
|
| }
|
| if (GeoIdList.size() == 1) {
|
| GeoIdList.clear();
|
| PosIdList.clear();
|
| }
|
| }
|
|
|
| void SketchObject::getDirectlyCoincidentPoints(int VertexId, std::vector<int>& GeoIdList,
|
| std::vector<PointPos>& PosIdList) const
|
| {
|
| int GeoId;
|
| PointPos PosId;
|
| getGeoVertexIndex(VertexId, GeoId, PosId);
|
| getDirectlyCoincidentPoints(GeoId, PosId, GeoIdList, PosIdList);
|
| }
|
|
|
| bool SketchObject::arePointsCoincident(int GeoId1, PointPos PosId1, int GeoId2, PointPos PosId2)
|
| {
|
| if (GeoId1 == GeoId2 && PosId1 == PosId2)
|
| return true;
|
|
|
| const std::vector<std::map<int, Sketcher::PointPos>> coincidenttree = getCoincidenceGroups();
|
|
|
| for (const auto& cGroup : coincidenttree) {
|
| const auto& geoId1iterator = cGroup.find(GeoId1);
|
|
|
| if (geoId1iterator != cGroup.end()) {
|
|
|
| const auto& geoId2iterator = cGroup.find(GeoId2);
|
|
|
| if (geoId2iterator != cGroup.end()) {
|
|
|
| if (geoId1iterator->second == PosId1 && geoId2iterator->second == PosId2)
|
| return true;
|
| }
|
| }
|
| }
|
|
|
| return false;
|
| }
|
| bool SketchObject::hasBlockConstraint() const
|
| {
|
| return std::ranges::any_of(Constraints.getValues(), [](auto& c) {
|
| return c->Type == Block;
|
| });
|
| }
|
|
|
| void SketchObject::getConstraintIndices(int GeoId, std::vector<int>& constraintList)
|
| {
|
| const std::vector<Constraint*>& constraints = this->Constraints.getValues();
|
| int i = 0;
|
|
|
| for (const auto& constr : constraints) {
|
| if (constr->involvesGeoId(GeoId)) {
|
| constraintList.push_back(i);
|
| }
|
| ++i;
|
| }
|
| }
|
|
|
| void SketchObject::appendConflictMsg(const std::vector<int>& conflicting, std::string& msg)
|
| {
|
| appendConstraintsMsg(conflicting,
|
| "Remove the following conflicting constraint:",
|
| "Remove at least one of the following conflicting constraints:",
|
| msg);
|
| }
|
|
|
| void SketchObject::appendRedundantMsg(const std::vector<int>& redundant, std::string& msg)
|
| {
|
| appendConstraintsMsg(redundant,
|
| "Remove the following redundant constraint:",
|
| "Remove the following redundant constraints:",
|
| msg);
|
| }
|
|
|
| void SketchObject::appendMalformedConstraintsMsg(const std::vector<int>& malformed,
|
| std::string& msg)
|
| {
|
| appendConstraintsMsg(malformed,
|
| "Remove the following malformed constraint:",
|
| "Remove the following malformed constraints:",
|
| msg);
|
| }
|
|
|
| void SketchObject::appendConstraintsMsg(const std::vector<int>& vector,
|
| const std::string& singularmsg,
|
| const std::string& pluralmsg, std::string& msg)
|
| {
|
| std::stringstream ss;
|
| if (msg.length() > 0)
|
| ss << msg;
|
| if (!vector.empty()) {
|
| if (vector.size() == 1)
|
| ss << singularmsg << std::endl;
|
| else
|
| ss << pluralmsg;
|
| ss << vector[0] << std::endl;
|
| for (unsigned int i = 1; i < vector.size(); i++)
|
| ss << ", " << vector[i];
|
| ss << "\n";
|
| }
|
| msg = ss.str();
|
| }
|
|
|
|
|
| void SketchObject::getGeometryWithDependentParameters(
|
| std::vector<std::pair<int, PointPos>>& geometrymap)
|
| {
|
| auto geos = getInternalGeometry();
|
|
|
| int geoid = -1;
|
|
|
| for (auto geo : geos) {
|
| ++geoid;
|
|
|
| if (!geo) {
|
| continue;
|
| }
|
|
|
| if (!geo->hasExtension(Sketcher::SolverGeometryExtension::getClassTypeId())) {
|
| continue;
|
| }
|
|
|
| auto solvext = std::static_pointer_cast<const Sketcher::SolverGeometryExtension>(
|
| geo->getExtension(Sketcher::SolverGeometryExtension::getClassTypeId()).lock());
|
|
|
| if (solvext->getGeometry()
|
| != Sketcher::SolverGeometryExtension::NotFullyConstraint) {
|
| continue;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (solvext->getEdge() == SolverGeometryExtension::Dependent)
|
| geometrymap.emplace_back(geoid, Sketcher::PointPos::none);
|
| if (solvext->getStart() == SolverGeometryExtension::Dependent)
|
| geometrymap.emplace_back(geoid, Sketcher::PointPos::start);
|
| if (solvext->getEnd() == SolverGeometryExtension::Dependent)
|
| geometrymap.emplace_back(geoid, Sketcher::PointPos::start);
|
| if (solvext->getMid() == SolverGeometryExtension::Dependent)
|
| geometrymap.emplace_back(geoid, Sketcher::PointPos::start);
|
| }
|
| }
|
|
|
| bool SketchObject::evaluateConstraint(const Constraint* constraint) const
|
| {
|
|
|
|
|
|
|
|
|
| bool requireSecond = false;
|
| bool requireThird = false;
|
|
|
| switch (constraint->Type) {
|
| case Radius:
|
| case Diameter:
|
| case Weight:
|
| case Horizontal:
|
| case Vertical:
|
| case Distance:
|
| case DistanceX:
|
| case DistanceY:
|
| case Coincident:
|
| case Perpendicular:
|
| case Parallel:
|
| case Equal:
|
| case PointOnObject:
|
| case Angle:
|
| break;
|
| case Tangent:
|
| requireSecond = true;
|
| break;
|
| case Symmetric:
|
| case SnellsLaw:
|
| requireSecond = true;
|
| requireThird = true;
|
| break;
|
| default:
|
| break;
|
| }
|
|
|
| int intGeoCount = getHighestCurveIndex() + 1;
|
| int extGeoCount = getExternalGeometryCount();
|
|
|
|
|
| bool ret = true;
|
| int geoId;
|
|
|
|
|
| geoId = constraint->First;
|
| ret = ret && (geoId >= -extGeoCount && geoId < intGeoCount);
|
|
|
| geoId = constraint->Second;
|
| ret = ret
|
| && ((geoId == GeoEnum::GeoUndef && !requireSecond)
|
| || (geoId >= -extGeoCount && geoId < intGeoCount));
|
|
|
| geoId = constraint->Third;
|
| ret = ret
|
| && ((geoId == GeoEnum::GeoUndef && !requireThird)
|
| || (geoId >= -extGeoCount && geoId < intGeoCount));
|
|
|
| return ret;
|
| }
|
|
|
| bool SketchObject::evaluateConstraints() const
|
| {
|
| int intGeoCount = getHighestCurveIndex() + 1;
|
| int extGeoCount = getExternalGeometryCount();
|
|
|
| std::vector<Part::Geometry*> geometry = getCompleteGeometry();
|
| const std::vector<Sketcher::Constraint*>& constraints = Constraints.getValuesForce();
|
| if (static_cast<int>(geometry.size()) != extGeoCount + intGeoCount) {
|
| return false;
|
| }
|
| if (geometry.size() < 2) {
|
| return false;
|
| }
|
|
|
| for (auto it : constraints) {
|
| if (!evaluateConstraint(it)) {
|
| return false;
|
| }
|
| }
|
|
|
| if (!constraints.empty()) {
|
| if (!Constraints.scanGeometry(geometry)) {
|
| return false;
|
| }
|
| }
|
|
|
| return true;
|
| }
|
|
|
| void SketchObject::validateConstraints()
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| std::vector<Part::Geometry*> geometry = getCompleteGeometry();
|
| const std::vector<Sketcher::Constraint*>& constraints = Constraints.getValuesForce();
|
|
|
| std::vector<Sketcher::Constraint*> newConstraints;
|
| newConstraints.reserve(constraints.size());
|
| std::vector<Sketcher::Constraint*>::const_iterator it;
|
| for (it = constraints.begin(); it != constraints.end(); ++it) {
|
| bool valid = evaluateConstraint(*it);
|
| if (valid) {
|
| newConstraints.push_back(*it);
|
| }
|
| }
|
|
|
| if (newConstraints.size() != constraints.size()) {
|
| Constraints.setValues(std::move(newConstraints));
|
| acceptGeometry();
|
| }
|
| else if (!Constraints.scanGeometry(geometry)) {
|
| Constraints.acceptGeometry(geometry);
|
| }
|
| }
|
|
|
| std::string SketchObject::validateExpression(const App::ObjectIdentifier& path,
|
| std::shared_ptr<const App::Expression> expr)
|
| {
|
| const App::Property* prop = path.getProperty();
|
|
|
| assert(expr);
|
|
|
| if (!prop)
|
| return "Property not found";
|
|
|
| if (prop == &Constraints) {
|
| const Constraint* constraint = Constraints.getConstraint(path);
|
|
|
| if (!constraint->isDriving)
|
| return "Reference constraints cannot be set!";
|
| }
|
|
|
| auto deps = expr->getDeps();
|
| auto it = deps.find(this);
|
| if (it == deps.end()) {
|
| return "";
|
| }
|
|
|
| auto it2 = it->second.find("Constraints");
|
| if (it2 != it->second.end()) {
|
| for (auto& oid : it2->second) {
|
| const Constraint* constraint = Constraints.getConstraint(oid);
|
|
|
| if (!constraint->isDriving)
|
| return "Reference constraint from this sketch cannot be used in this "
|
| "expression.";
|
| }
|
| }
|
|
|
| geoMap.clear();
|
| const auto &vals = getInternalGeometry();
|
| for(long i=0; i<(long)vals.size(); ++i) {
|
| auto geo = vals[i];
|
| auto gf = GeometryFacade::getFacade(geo);
|
| if(!gf->getId()) {
|
| gf->setId(++geoLastId);
|
| }
|
| else if(gf->getId() > geoLastId) {
|
| geoLastId = gf->getId();
|
| }
|
| while(!geoMap.insert(std::make_pair(gf->getId(),i)).second) {
|
| FC_WARN("duplicate geometry id " << gf->getId() << " -> " << geoLastId+1);
|
| gf->setId(++geoLastId);
|
| }
|
| }
|
| updateGeoHistory();
|
|
|
| return "";
|
| }
|
|
|
|
|
|
|
|
|
| double SketchObject::calculateAngleViaPoint(int GeoId1, int GeoId2, double px, double py)
|
| {
|
|
|
| Sketcher::Sketch sk;
|
|
|
| const auto* p1 = dynamic_cast<const Part::GeomCurve*>(this->getGeometry(GeoId1));
|
| const auto* p2 = dynamic_cast<const Part::GeomCurve*>(this->getGeometry(GeoId2));
|
|
|
| if (p1 && p2) {
|
|
|
| int i1 = sk.addGeometry(this->getGeometry(GeoId1));
|
| int i2 = sk.addGeometry(this->getGeometry(GeoId2));
|
|
|
| if (p1->is<Part::GeomBSplineCurve>() ||
|
| p2->is<Part::GeomBSplineCurve>()) {
|
| double p1ClosestParam, p2ClosestParam;
|
| Base::Vector3d pt(px, py, 0);
|
| p1->closestParameter(pt, p1ClosestParam);
|
| p2->closestParameter(pt, p2ClosestParam);
|
|
|
| return sk.calculateAngleViaParams(i1, i2, p1ClosestParam, p2ClosestParam);
|
| }
|
|
|
| return sk.calculateAngleViaPoint(i1, i2, px, py);
|
| }
|
| else
|
| throw Base::ValueError("Null geometry in calculateAngleViaPoint");
|
| }
|
|
|
| void SketchObject::constraintsRenamed(
|
| const std::map<App::ObjectIdentifier, App::ObjectIdentifier>& renamed)
|
| {
|
| ExpressionEngine.renameExpressions(renamed);
|
|
|
| for (auto doc : App::GetApplication().getDocuments())
|
| doc->renameObjectIdentifiers(renamed);
|
| }
|
|
|
| void SketchObject::constraintsRemoved(const std::set<App::ObjectIdentifier>& removed)
|
| {
|
| auto i = removed.begin();
|
|
|
| while (i != removed.end()) {
|
| ExpressionEngine.setValue(*i, std::shared_ptr<App::Expression>());
|
| ++i;
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| bool SketchObject::isPointOnCurve(int geoIdCurve, double px, double py)
|
| {
|
|
|
| Sketcher::Sketch sk;
|
| int icrv = sk.addGeometry(this->getGeometry(geoIdCurve));
|
| Base::Vector3d pp;
|
| pp.x = px;
|
| pp.y = py;
|
| Part::GeomPoint p(pp);
|
| int ipnt = sk.addPoint(p);
|
| int icstr = sk.addPointOnObjectConstraint(ipnt, Sketcher::PointPos::start, icrv);
|
| double err = sk.calculateConstraintError(icstr);
|
| return err * err < 10.0 * sk.getSolverPrecision();
|
| }
|
|
|
|
|
| double SketchObject::calculateConstraintError(int ConstrId)
|
| {
|
| Sketcher::Sketch sk;
|
| const std::vector<Constraint*>& clist = this->Constraints.getValues();
|
| if (ConstrId < 0 || ConstrId >= int(clist.size()))
|
| return std::numeric_limits<double>::quiet_NaN();
|
|
|
| Constraint* cstr = clist[ConstrId]->clone();
|
| double result = 0.0;
|
| try {
|
| std::vector<int> GeoIdList;
|
| int g;
|
| GeoIdList.push_back(cstr->First);
|
| GeoIdList.push_back(cstr->Second);
|
| GeoIdList.push_back(cstr->Third);
|
|
|
|
|
| for (std::size_t i = 0; i < GeoIdList.size(); i++) {
|
| g = GeoIdList[i];
|
| if (g != GeoEnum::GeoUndef) {
|
| GeoIdList[i] = sk.addGeometry(this->getGeometry(g));
|
| }
|
| }
|
|
|
| cstr->First = GeoIdList[0];
|
| cstr->Second = GeoIdList[1];
|
| cstr->Third = GeoIdList[2];
|
| int icstr = sk.addConstraint(cstr);
|
| result = sk.calculateConstraintError(icstr);
|
| }
|
| catch (...) {
|
| delete cstr;
|
| throw;
|
| }
|
| delete cstr;
|
| return result;
|
| }
|
|
|
| PyObject* SketchObject::getPyObject()
|
| {
|
| if (PythonObject.is(Py::_None())) {
|
|
|
| PythonObject = Py::Object(new SketchObjectPy(this), true);
|
| }
|
| return Py::new_reference_to(PythonObject);
|
| }
|
|
|
| unsigned int SketchObject::getMemSize() const
|
| {
|
| return 0;
|
| }
|
|
|
| void SketchObject::Save(Writer& writer) const
|
| {
|
| int index = -1;
|
| auto &geos = const_cast<Part::PropertyGeometryList&>(ExternalGeo).getValues();
|
| for(auto geo : geos)
|
| ExternalGeometryFacade::getFacade(geo)->setRefIndex(-1);
|
|
|
| if(isExporting()) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| for(auto &key : externalGeoRef) {
|
| ++index;
|
| auto iter = externalGeoRefMap.find(key);
|
| if(iter == externalGeoRefMap.end())
|
| continue;
|
| for(auto id : iter->second) {
|
| auto it = externalGeoMap.find(id);
|
| if(it != externalGeoMap.end())
|
| ExternalGeometryFacade::getFacade(geos[it->second])->setRefIndex(index);
|
| }
|
| }
|
| }
|
|
|
|
|
| Part::Part2DObject::Save(writer);
|
| }
|
|
|
| void SketchObject::Restore(XMLReader& reader)
|
| {
|
|
|
| Part::Part2DObject::Restore(reader);
|
| }
|
|
|
| void SketchObject::handleChangedPropertyType(Base::XMLReader &reader,
|
| const char *TypeName, App::Property *prop)
|
| {
|
| if (prop == &Exports) {
|
| if(strcmp(TypeName, "App::PropertyLinkList") == 0)
|
| Exports.Restore(reader);
|
| }
|
| }
|
|
|
| static inline bool checkMigration(Part::PropertyGeometryList &prop)
|
| {
|
| for (auto g : prop.getValues()) {
|
| if(g->hasExtension(Part::GeometryMigrationExtension::getClassTypeId())
|
| || !g->hasExtension(SketchGeometryExtension::getClassTypeId()))
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| void SketchObject::onChanged(const App::Property* prop)
|
| {
|
| if (prop == &Geometry) {
|
| onGeometryChanged();
|
| }
|
| else if (prop == &Constraints) {
|
| onConstraintsChanged();
|
| }
|
| else if (prop == &ExternalGeo && !prop->testStatus(App::Property::User3)) {
|
| onExternalGeoChanged();
|
| }
|
| else if (prop == &ExternalGeometry) {
|
| onExternalGeometryChanged();
|
| }
|
| else if (prop == &Placement) {
|
| onPlacementChanged();
|
| }
|
| else if (prop == &ExpressionEngine) {
|
| onExpressionEngineChanged();
|
| }
|
| #if 0
|
|
|
|
|
| else if (prop == &AttachmentSupport) {
|
| onAttachmentSupportChanged();
|
| }
|
| #endif
|
| Part::Part2DObject::onChanged(prop);
|
| }
|
|
|
| void SketchObject::onGeometryChanged()
|
| {
|
| if (isRestoring() && checkMigration(Geometry)) {
|
|
|
| for (auto geometryValue : Geometry.getValues()) {
|
| if (!geometryValue->hasExtension(
|
| Part::GeometryMigrationExtension::getClassTypeId())) {
|
| continue;
|
| }
|
|
|
| auto ext = std::static_pointer_cast<Part::GeometryMigrationExtension>(
|
| geometryValue
|
| ->getExtension(Part::GeometryMigrationExtension::getClassTypeId())
|
| .lock());
|
|
|
|
|
| auto gf = GeometryFacade::getFacade(geometryValue);
|
|
|
| if (ext->testMigrationType(Part::GeometryMigrationExtension::Construction)) {
|
| bool oldconstr = ext->getConstruction()
|
| || (geometryValue->is<Part::GeomPoint>() && !gf->isInternalAligned());
|
| gf->setConstruction(oldconstr);
|
| }
|
| if (ext->testMigrationType(Part::GeometryMigrationExtension::GeometryId)) {
|
| gf->setId(ext->getId());
|
| }
|
| }
|
| }
|
| geoMap.clear();
|
| const auto &vals = getInternalGeometry();
|
| for (long i = 0; i < (long)vals.size(); ++i) {
|
| auto geo = vals[i];
|
| auto gf = GeometryFacade::getFacade(geo);
|
| if (gf->getId() == 0) {
|
| gf->setId(++geoLastId);
|
| }
|
| else if (gf->getId() > geoLastId) {
|
| geoLastId = gf->getId();
|
| }
|
| while (!geoMap.insert(std::make_pair(gf->getId(), i)).second) {
|
| FC_WARN("duplicate geometry id " << gf->getId() << " -> "
|
| << geoLastId + 1);
|
| gf->setId(++geoLastId);
|
| }
|
| }
|
| updateGeoHistory();
|
|
|
| auto doc = getDocument();
|
|
|
| if (doc && doc->isPerformingTransaction()) {
|
|
|
| setStatus(App::PendingTransactionUpdate, true);
|
| return;
|
| }
|
|
|
| if (internaltransaction) {
|
| return;
|
| }
|
|
|
|
|
|
|
|
|
| if (managedoperation || isRestoring()) {
|
|
|
| acceptGeometry();
|
| return;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| bool invalidinput = Constraints.checkConstraintIndices(
|
| getHighestCurveIndex(), -getExternalGeometryCount());
|
|
|
| if (!invalidinput) {
|
| acceptGeometry();
|
| }
|
| else {
|
| Base::Console().error(
|
| this->getFullLabel() + " SketchObject::onChanged ",
|
| QT_TRANSLATE_NOOP("Notifications", "Unmanaged change of Constraint "
|
| "Property results in invalid constraint indices") "\n");
|
| }
|
| Base::StateLocker lock(internaltransaction, true);
|
| setUpSketch();
|
| }
|
|
|
| void SketchObject::onConstraintsChanged()
|
| {
|
| auto doc = getDocument();
|
|
|
| if (doc && doc->isPerformingTransaction()) {
|
|
|
| setStatus(App::PendingTransactionUpdate, true);
|
| return;
|
| }
|
|
|
| if (internaltransaction) {
|
| return;
|
| }
|
|
|
| if (managedoperation || isRestoring()) {
|
| Constraints.checkGeometry(getCompleteGeometry());
|
| return;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| bool invalidinput = Constraints.checkConstraintIndices(
|
| getHighestCurveIndex(), -getExternalGeometryCount());
|
|
|
| if (!invalidinput) {
|
| if (Constraints.checkGeometry(getCompleteGeometry())) {
|
|
|
|
|
| acceptGeometry();
|
| }
|
| }
|
| else {
|
| Base::Console().error(
|
| this->getFullLabel() + " SketchObject::onChanged ",
|
| QT_TRANSLATE_NOOP("Notifications", "Unmanaged change of Constraint "
|
| "Property results in invalid constraint indices") "\n");
|
| }
|
| Base::StateLocker lock(internaltransaction, true);
|
| setUpSketch();
|
| }
|
|
|
|
|
| void SketchObject::onExternalGeoChanged()
|
| {
|
| if (ExternalGeo.testStatus(App::Property::User3)) {
|
| return;
|
| }
|
|
|
| auto doc = getDocument();
|
|
|
| if (doc && doc->isPerformingTransaction()) {
|
| setStatus(App::PendingTransactionUpdate, true);
|
| }
|
|
|
| if (isRestoring() && checkMigration(ExternalGeo)) {
|
| for (auto geometryValue : ExternalGeo.getValues()) {
|
| if (!geometryValue->hasExtension(
|
| Part::GeometryMigrationExtension::getClassTypeId())) {
|
| continue;
|
| }
|
|
|
| auto ext = std::static_pointer_cast<Part::GeometryMigrationExtension>(
|
| geometryValue
|
| ->getExtension(Part::GeometryMigrationExtension::getClassTypeId())
|
| .lock());
|
| std::unique_ptr<ExternalGeometryFacade> egf;
|
| if (ext->testMigrationType(Part::GeometryMigrationExtension::GeometryId)) {
|
| egf = ExternalGeometryFacade::getFacade(geometryValue);
|
| egf->setId(ext->getId());
|
| }
|
|
|
| if (!ext->testMigrationType(Part::GeometryMigrationExtension::ExternalReference)) {
|
| continue;
|
| }
|
|
|
| if (!egf) {
|
| egf = ExternalGeometryFacade::getFacade(geometryValue);
|
| }
|
| egf->setRef(ext->getRef());
|
| egf->setRefIndex(ext->getRefIndex());
|
| egf->setFlags(ext->getFlags());
|
| }
|
| }
|
| externalGeoRefMap.clear();
|
| externalGeoMap.clear();
|
| std::set<std::string> detached;
|
| for(int i=0; i<ExternalGeo.getSize(); ++i) {
|
| auto geo = ExternalGeo[i];
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if (egf->testFlag(ExternalGeometryExtension::Detached)) {
|
| if (!egf->getRef().empty()) {
|
| detached.insert(egf->getRef());
|
| egf->setRef(std::string());
|
| }
|
| egf->setFlag(ExternalGeometryExtension::Detached,false);
|
| egf->setFlag(ExternalGeometryExtension::Missing,false);
|
| }
|
| if (egf->getId() > geoLastId) {
|
| geoLastId = egf->getId();
|
| }
|
| if (!externalGeoMap.emplace(egf->getId(), i).second) {
|
| FC_WARN("duplicate geometry id " << egf->getId() << " -> "
|
| << geoLastId + 1);
|
| egf->setId(++geoLastId);
|
| externalGeoMap[egf->getId()] = i;
|
| }
|
| if (!egf->getRef().empty()) {
|
| externalGeoRefMap[egf->getRef()].push_back(egf->getId());
|
| }
|
| }
|
| if (detached.empty()) {
|
| signalElementsChanged();
|
| return;
|
| }
|
|
|
| auto objs = ExternalGeometry.getValues();
|
| assert(externalGeoRef.size() == objs.size());
|
| auto itObj = objs.begin();
|
| auto subs = ExternalGeometry.getSubValues();
|
| auto itSub = subs.begin();
|
| for (const auto& i : externalGeoRef) {
|
| if (detached.count(i) == 0U) {
|
| ++itObj;
|
| ++itSub;
|
| continue;
|
| }
|
|
|
| itObj = objs.erase(itObj);
|
| itSub = subs.erase(itSub);
|
| auto& refs = externalGeoRefMap[i];
|
| for (long id : refs) {
|
| auto it = externalGeoMap.find(id);
|
| if (it!=externalGeoMap.end()) {
|
| auto geo = ExternalGeo[it->second];
|
| ExternalGeometryFacade::getFacade(geo)->setRef(std::string());
|
| }
|
| }
|
| refs.clear();
|
| }
|
| ExternalGeometry.setValues(objs, subs);
|
| }
|
|
|
| void SketchObject::onExternalGeometryChanged()
|
| {
|
| auto doc = getDocument();
|
|
|
| if (doc && doc->isPerformingTransaction()) {
|
| setStatus(App::PendingTransactionUpdate, true);
|
| }
|
|
|
| if(!isRestoring()) {
|
|
|
|
|
| updateGeometryRefs();
|
| signalElementsChanged();
|
| }
|
| }
|
|
|
| void SketchObject::onPlacementChanged()
|
| {
|
| if (ExternalGeometry.getSize() > 0) {
|
| touch();
|
| }
|
| }
|
|
|
| void SketchObject::onExpressionEngineChanged()
|
| {
|
| auto doc = getDocument();
|
|
|
| if (!isRestoring() && doc && !doc->isPerformingTransaction() && noRecomputes
|
| && !managedoperation) {
|
|
|
|
|
| try {
|
| auto res = ExpressionEngine.execute();
|
| if (res) {
|
| FC_ERR("Failed to recompute " << ExpressionEngine.getFullName() << ": "
|
| << res->Why);
|
| delete res;
|
| }
|
| } catch (Base::Exception &e) {
|
| e.reportException();
|
| FC_ERR("Failed to recompute " << ExpressionEngine.getFullName() << ": "
|
| << e.what());
|
| }
|
| solve();
|
| }
|
| }
|
|
|
| void SketchObject::onAttachmentSupportChanged()
|
| {
|
|
|
| if (isRestoring()) {
|
| return;
|
| }
|
|
|
|
|
| delConstraintsToExternal();
|
| for (int i=0; i < getExternalGeometryCount(); i++) {
|
| delExternal(0);
|
| }
|
| rebuildExternalGeometry();
|
| }
|
|
|
| void SketchObject::onUpdateElementReference(const App::Property *prop)
|
| {
|
| if(prop == &ExternalGeometry) {
|
| updateGeoRef = true;
|
|
|
|
|
|
|
|
|
| updateGeometryRefs();
|
| signalElementsChanged();
|
| }
|
| }
|
|
|
| void SketchObject::updateGeometryRefs()
|
| {
|
| const auto &objs = ExternalGeometry.getValues();
|
| const auto &subs = ExternalGeometry.getSubValues();
|
| const auto &shadows = ExternalGeometry.getShadowSubs();
|
| assert(subs.size() == shadows.size());
|
| std::vector<std::string> originalRefs;
|
| std::map<std::string,std::string> refMap;
|
| if (updateGeoRef) {
|
| assert(externalGeoRef.size() == objs.size());
|
| updateGeoRef = false;
|
| originalRefs = std::move(externalGeoRef);
|
| }
|
| externalGeoRef.clear();
|
| std::unordered_map<std::string, int> legacyMap;
|
| for (int i=0;i<(int)objs.size();++i) {
|
| auto obj = objs[i];
|
| const std::string& sub = shadows[i].newName.empty() ? subs[i] : shadows[i].newName;
|
| externalGeoRef.emplace_back(obj->getNameInDocument());
|
| auto &key = externalGeoRef.back();
|
| key += '.';
|
|
|
| legacyMap[key + Data::oldElementName(sub.c_str())] = i;
|
|
|
| if (!obj->isDerivedFrom<Part::Datum>()) {
|
| key += Data::newElementName(sub.c_str());
|
| }
|
| if (!originalRefs.empty() && originalRefs[i] != key) {
|
| refMap[originalRefs[i]] = key;
|
| }
|
| }
|
| bool touched = false;
|
| auto geos = ExternalGeo.getValues();
|
| if (!refMap.empty()) {
|
| for(auto &v : refMap) {
|
| auto it = externalGeoRefMap.find(v.first);
|
| if (it == externalGeoRefMap.end()) {
|
| continue;
|
| }
|
| for (long id : it->second) {
|
| auto iter = externalGeoMap.find(id);
|
| if (iter != externalGeoMap.end()) {
|
| auto &geo = geos[iter->second];
|
| geo = geo->clone();
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
|
|
| FC_LOG(getFullName() << " ref change on ExternalEdge" << iter->second - 1 << ' '
|
| << egf->getRef() << " -> " << v.second);
|
| egf->setRef(v.second);
|
| touched = true;
|
| }
|
| }
|
| }
|
|
|
| if (touched) {
|
| ExternalGeo.setValues(std::move(geos));
|
| }
|
| return;
|
| }
|
|
|
|
|
|
|
| for (auto geo : geos) {
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if (egf->getRefIndex() >= 0) {
|
| if (egf->getRefIndex() < (int)externalGeoRef.size()
|
| && egf->getRef() != externalGeoRef[egf->getRefIndex()]) {
|
| touched = true;
|
| egf->setRef(externalGeoRef[egf->getRefIndex()]);
|
| }
|
| egf->setRefIndex(-1);
|
| continue;
|
| }
|
|
|
| if (egf->getId() < 0 && !egf->getRef().empty()) {
|
|
|
| FC_ERR("External geometry reference corrupted in " << getFullName()
|
| << " Please check.");
|
|
|
|
|
|
|
|
|
|
|
| initExternalGeo();
|
| return;
|
| }
|
|
|
| auto it = legacyMap.find(egf->getRef());
|
| if (it == legacyMap.end() || egf->getRef() == externalGeoRef[it->second]) {
|
| continue;
|
| }
|
|
|
| if (getDocument() && !getDocument()->isPerformingTransaction()) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| FC_WARN("Update legacy external reference "
|
| << egf->getRef() << " -> " << externalGeoRef[it->second] << " in "
|
| << getFullName());
|
| }
|
| else {
|
|
|
| FC_LOG("Update undo/redo external reference "
|
| << egf->getRef() << " -> " << externalGeoRef[it->second] << " in "
|
| << getFullName());
|
| }
|
| touched = true;
|
| egf->setRef(externalGeoRef[it->second]);
|
| }
|
|
|
| if (touched) {
|
| ExternalGeo.setValues(std::move(geos));
|
| }
|
| }
|
|
|
| void SketchObject::onUndoRedoFinished()
|
| {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Constraints.checkConstraintIndices(getHighestCurveIndex(), -getExternalGeometryCount());
|
| acceptGeometry();
|
| synchroniseGeometryState();
|
| solve();
|
| }
|
|
|
| void SketchObject::synchroniseGeometryState()
|
| {
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| for (size_t i = 0; i < vals.size(); i++) {
|
| auto gf = GeometryFacade::getFacade(vals[i]);
|
|
|
| auto facadeInternalAlignment = gf->getInternalType();
|
| auto facadeBlockedState = gf->getBlocked();
|
|
|
| Sketcher::InternalType::InternalType constraintInternalAlignment = InternalType::None;
|
| bool constraintBlockedState = false;
|
|
|
| for (auto cstr : Constraints.getValues()) {
|
| if (cstr->First == int(i)) {
|
| getInternalTypeState(cstr, constraintInternalAlignment);
|
| getBlockedState(cstr, constraintBlockedState);
|
| }
|
| }
|
|
|
| if (constraintInternalAlignment != facadeInternalAlignment)
|
| gf->setInternalType(constraintInternalAlignment);
|
|
|
| if (constraintBlockedState != facadeBlockedState)
|
| gf->setBlocked(constraintBlockedState);
|
| }
|
| }
|
|
|
| bool SketchObject::getInternalTypeState(
|
| const Constraint* cstr, Sketcher::InternalType::InternalType& internaltypestate) const
|
| {
|
| if (cstr->Type == InternalAlignment) {
|
|
|
| switch (cstr->AlignmentType) {
|
| case Undef:
|
| case NumInternalAlignmentType:
|
| internaltypestate = InternalType::None;
|
| break;
|
| case EllipseMajorDiameter:
|
| internaltypestate = InternalType::EllipseMajorDiameter;
|
| break;
|
| case EllipseMinorDiameter:
|
| internaltypestate = InternalType::EllipseMinorDiameter;
|
| break;
|
| case EllipseFocus1:
|
| internaltypestate = InternalType::EllipseFocus1;
|
| break;
|
| case EllipseFocus2:
|
| internaltypestate = InternalType::EllipseFocus2;
|
| break;
|
| case HyperbolaMajor:
|
| internaltypestate = InternalType::HyperbolaMajor;
|
| break;
|
| case HyperbolaMinor:
|
| internaltypestate = InternalType::HyperbolaMinor;
|
| break;
|
| case HyperbolaFocus:
|
| internaltypestate = InternalType::HyperbolaFocus;
|
| break;
|
| case ParabolaFocus:
|
| internaltypestate = InternalType::ParabolaFocus;
|
| break;
|
| case BSplineControlPoint:
|
| internaltypestate = InternalType::BSplineControlPoint;
|
| break;
|
| case BSplineKnotPoint:
|
| internaltypestate = InternalType::BSplineKnotPoint;
|
| break;
|
| case ParabolaFocalAxis:
|
| internaltypestate = InternalType::ParabolaFocalAxis;
|
| break;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| return false;
|
| }
|
|
|
| bool SketchObject::getBlockedState(const Constraint* cstr, bool& blockedstate) const
|
| {
|
| if (cstr->Type == Block) {
|
| blockedstate = true;
|
| return true;
|
| }
|
|
|
| return false;
|
| }
|
|
|
| void SketchObject::onDocumentRestored()
|
| {
|
| try {
|
| onSketchRestore();
|
| Part::Part2DObject::onDocumentRestored();
|
| }
|
| catch (...) {
|
| }
|
| }
|
|
|
| void SketchObject::restoreFinished()
|
| {
|
| App::DocumentObject::restoreFinished();
|
| onSketchRestore();
|
| }
|
|
|
| void SketchObject::onSketchRestore()
|
| {
|
| try {
|
| migrateSketch();
|
|
|
| updateGeometryRefs();
|
| if(ExternalGeo.getSize()<=2) {
|
| if (ExternalGeo.getSize() < 2)
|
| initExternalGeo();
|
| for(auto &key : externalGeoRef) {
|
| long id = getDocument()->getStringHasher()->getID(key.c_str()).value();
|
| if(geoLastId < id)
|
| geoLastId = id;
|
| externalGeoRefMap[key].push_back(id);
|
| }
|
| rebuildExternalGeometry();
|
| if(ExternalGeometry.getSize()+2!=ExternalGeo.getSize())
|
| FC_WARN("Failed to restore some external geometry in " << getFullName());
|
| }else
|
| acceptGeometry();
|
|
|
| synchroniseGeometryState();
|
|
|
|
|
| if (Shape.getValue().IsNull() && hasConflicts() == 0) {
|
| if (this->solve(true) == 0)
|
| Shape.setValue(solvedSketch.toShape());
|
| }
|
|
|
|
|
|
|
|
|
|
|
| for (auto &v : ExpressionEngine.getExpressions()) {
|
| if (v.first.getProperty() != &Constraints)
|
| continue;
|
| const Constraint * cstr = nullptr;
|
| try {
|
| cstr = Constraints.getConstraint(v.first);
|
| } catch (Base::Exception &) {
|
| }
|
| if (!cstr || !cstr->isDimensional()) {
|
| FC_WARN((cstr ? "Invalid" : "Orphan")
|
| << " constraint expression in "
|
| << getFullName() << "."
|
| << v.first.toString()
|
| << ": " << v.second->toString());
|
| ExpressionEngine.setValue(v.first, nullptr);
|
| }
|
| }
|
| } catch (Base::Exception &e) {
|
| e.reportException();
|
| FC_ERR("Error while restoring " << getFullName());
|
| } catch (...) {
|
| }
|
| }
|
|
|
|
|
| void SketchObject::migrateSketch()
|
| {
|
|
|
| const auto& allGeoms = getInternalGeometry();
|
| bool noextensions = std::ranges::any_of(allGeoms, [](const auto& geo) {
|
| return !geo->hasExtension(SketchGeometryExtension::getClassTypeId());
|
| });
|
|
|
| if (noextensions) {
|
| for (const auto& c : Constraints.getValues()) {
|
| addGeometryState(c);
|
|
|
|
|
| if (c->Type != InternalAlignment || c->AlignmentType != BSplineControlPoint) {
|
| continue;
|
| }
|
|
|
| int circleGeoId = c->First;
|
| int bSplineGeoId = c->Second;
|
|
|
| auto bsp = static_cast<const Part::GeomBSplineCurve*>(getGeometry(bSplineGeoId));
|
|
|
| std::vector<double> weights = bsp->getWeights();
|
|
|
| if (!(c->InternalAlignmentIndex < int(weights.size()))) {
|
| continue;
|
| }
|
|
|
| for (auto& ccp : Constraints.getValues()) {
|
| if ((ccp->Type == Radius || ccp->Type == Diameter) && ccp->First == circleGeoId) {
|
| ccp->Type = Weight;
|
| ccp->setValue(weights[c->InternalAlignmentIndex]);
|
| }
|
| }
|
| }
|
|
|
|
|
| for (auto& g : Geometry.getValues()) {
|
| if (!g->hasExtension(Part::GeometryMigrationExtension::getClassTypeId())) {
|
| continue;
|
| }
|
|
|
| auto ext = std::static_pointer_cast<Part::GeometryMigrationExtension>(
|
| g->getExtension(Part::GeometryMigrationExtension::getClassTypeId()).lock()
|
| );
|
|
|
| if (!ext->testMigrationType(Part::GeometryMigrationExtension::Construction)) {
|
| continue;
|
| }
|
|
|
| auto gf = GeometryFacade::getFacade(g);
|
|
|
| bool oldConstr = ext->getConstruction()
|
| || (g->is<Part::GeomPoint>() && !gf->isInternalAligned());
|
|
|
| GeometryFacade::setConstruction(g, oldConstr);
|
|
|
| g->deleteExtension(Part::GeometryMigrationExtension::getClassTypeId());
|
| }
|
| }
|
|
|
|
|
| auto constraints = Constraints.getValues();
|
| auto geometries = getInternalGeometry();
|
|
|
| bool parabolaFound = std::ranges::any_of(geometries, &Part::Geometry::is<Part::GeomArcOfParabola>);
|
|
|
| if (!parabolaFound) {
|
| return;
|
| }
|
|
|
| auto focalAxisFound = std::ranges::any_of(constraints, [](auto c) {
|
| return c->Type == InternalAlignment && c->AlignmentType == ParabolaFocalAxis;
|
| });
|
|
|
| if (focalAxisFound) {
|
| return;
|
| }
|
|
|
|
|
|
|
|
|
|
|
| std::map<int, int> parabolaGeoId2FocusGeoId;
|
|
|
|
|
| for (const auto& c : constraints) {
|
| if (c->Type == InternalAlignment && c->AlignmentType == ParabolaFocus) {
|
| parabolaGeoId2FocusGeoId[c->Second] = {c->First};
|
| }
|
| }
|
|
|
|
|
| std::map<int, int> axisGeoId2ParabolaGeoId;
|
|
|
|
|
| for (const auto& [parabolaGeoId, focusGeoId] : parabolaGeoId2FocusGeoId) {
|
|
|
| std::vector<int> focusGeoIdListGeoIdList;
|
| std::vector<PointPos> focusPosIdList;
|
| getDirectlyCoincidentPoints(
|
| focusGeoId,
|
| Sketcher::PointPos::start,
|
| focusGeoIdListGeoIdList,
|
| focusPosIdList
|
| );
|
|
|
| std::vector<int> parabGeoIdListGeoIdList;
|
| std::vector<PointPos> parabposidlist;
|
| getDirectlyCoincidentPoints(
|
| parabolaGeoId,
|
| Sketcher::PointPos::mid,
|
| parabGeoIdListGeoIdList,
|
| parabposidlist
|
| );
|
|
|
| for (const auto& parabGeoIdListGeoId : parabGeoIdListGeoIdList) {
|
| auto iterParabolaGeoId = std::ranges::find(focusGeoIdListGeoIdList, parabGeoIdListGeoId);
|
| if (iterParabolaGeoId != focusGeoIdListGeoIdList.end()) {
|
| axisGeoId2ParabolaGeoId[*iterParabolaGeoId] = parabolaGeoId;
|
| }
|
| }
|
| }
|
|
|
| std::vector<Constraint*> newConstraints;
|
| newConstraints.reserve(constraints.size());
|
|
|
| for (const auto& c : constraints) {
|
| if (c->Type != Coincident) {
|
| newConstraints.push_back(c);
|
| continue;
|
| }
|
|
|
| auto axisMajorCoincidentFound
|
| = std::ranges::any_of(axisGeoId2ParabolaGeoId, [&](const auto& pair) {
|
| auto parabolaGeoId = pair.second;
|
| auto axisgeoid = pair.first;
|
| return (c->First == axisgeoid && c->Second == parabolaGeoId
|
| && c->SecondPos == PointPos::mid)
|
| || (c->Second == axisgeoid && c->First == parabolaGeoId
|
| && c->FirstPos == PointPos::mid);
|
| });
|
|
|
| if (axisMajorCoincidentFound) {
|
|
|
|
|
| continue;
|
| }
|
|
|
| auto focusCoincidentFound = std::ranges::find_if(axisGeoId2ParabolaGeoId, [&](const auto& pair) {
|
| auto parabolaGeoId = pair.second;
|
| auto axisgeoid = pair.first;
|
| auto focusGeoId = parabolaGeoId2FocusGeoId[parabolaGeoId];
|
| return (c->First == axisgeoid && c->Second == focusGeoId
|
| && c->SecondPos == PointPos::start)
|
| || (c->Second == axisgeoid && c->First == focusGeoId
|
| && c->FirstPos == PointPos::start);
|
| });
|
|
|
| if (focusCoincidentFound != axisGeoId2ParabolaGeoId.end()) {
|
| auto* newConstr = new Sketcher::Constraint();
|
| newConstr->Type = Sketcher::InternalAlignment;
|
| newConstr->AlignmentType = Sketcher::ParabolaFocalAxis;
|
| newConstr->First = focusCoincidentFound->first;
|
| newConstr->FirstPos = Sketcher::PointPos::none;
|
| newConstr->Second = focusCoincidentFound->second;
|
| newConstr->SecondPos = Sketcher::PointPos::none;
|
| newConstraints.push_back(newConstr);
|
|
|
| addGeometryState(newConstr);
|
|
|
|
|
|
|
| continue;
|
| }
|
|
|
| newConstraints.push_back(c);
|
| }
|
|
|
| Constraints.setValues(std::move(newConstraints));
|
|
|
| Base::Console().critical(
|
| this->getFullName(),
|
| QT_TRANSLATE_NOOP(
|
| "Notifications",
|
| "Parabolas were migrated. Migrated files won't open in previous "
|
| "versions of FreeCAD!!\n"
|
| )
|
| );
|
| }
|
|
|
|
|
| void SketchObject::getGeoVertexIndex(int VertexId, int& GeoId, PointPos& PosId) const
|
| {
|
| if (VertexId < 0 || VertexId >= int(VertexId2GeoId.size())) {
|
| GeoId = GeoEnum::GeoUndef;
|
| PosId = PointPos::none;
|
| return;
|
| }
|
| GeoId = VertexId2GeoId[VertexId];
|
| PosId = VertexId2PosId[VertexId];
|
| }
|
|
|
| int SketchObject::getVertexIndexGeoPos(int GeoId, PointPos PosId) const
|
| {
|
| for (std::size_t i = 0; i < VertexId2GeoId.size(); i++) {
|
| if (VertexId2GeoId[i] == GeoId && VertexId2PosId[i] == PosId)
|
| return i;
|
| }
|
|
|
| return -1;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| int SketchObject::changeConstraintsLocking(bool bLock)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| int cntSuccess = 0;
|
| int cntToBeAffected = 0;
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| for (size_t i = 0; i < newVals.size(); i++) {
|
| if (newVals[i]->Type == Tangent || newVals[i]->Type == Perpendicular) {
|
|
|
| cntToBeAffected++;
|
| Constraint* constNew = newVals[i]->clone();
|
| bool ret = AutoLockTangencyAndPerpty(newVals[i], true, bLock);
|
|
|
| if (ret)
|
| cntSuccess++;
|
|
|
| newVals[i] = constNew;
|
| Base::Console().log("Constraint%i will be affected\n", i + 1);
|
| }
|
| }
|
|
|
| this->Constraints.setValues(std::move(newVals));
|
|
|
| Base::Console().log("ChangeConstraintsLocking: affected %i of %i tangent/perp constraints\n",
|
| cntSuccess,
|
| cntToBeAffected);
|
|
|
| return cntSuccess;
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| int SketchObject::port_reversedExternalArcs(bool justAnalyze)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| int cntToBeAffected = 0;
|
| const std::vector<Constraint*>& vals = this->Constraints.getValues();
|
|
|
| std::vector<Constraint*> newVals(vals);
|
|
|
| for (std::size_t ic = 0; ic < newVals.size(); ic++) {
|
| bool affected = false;
|
| Constraint* constNew = nullptr;
|
| for (int ig = 1; ig <= 3; ig++) {
|
|
|
| int geoId = 0;
|
| Sketcher::PointPos posId = PointPos::none;
|
| switch (ig) {
|
| case 1:
|
| geoId = newVals[ic]->First;
|
| posId = newVals[ic]->FirstPos;
|
| break;
|
| case 2:
|
| geoId = newVals[ic]->Second;
|
| posId = newVals[ic]->SecondPos;
|
| break;
|
| case 3:
|
| geoId = newVals[ic]->Third;
|
| posId = newVals[ic]->ThirdPos;
|
| break;
|
| }
|
|
|
| if (geoId <= GeoEnum::RefExt
|
| && (posId == Sketcher::PointPos::start || posId == Sketcher::PointPos::end)) {
|
|
|
| Part::Geometry* g = this->ExternalGeo[-geoId - 1];
|
| if (g->is<Part::GeomArcOfCircle>()) {
|
| const auto* segm = static_cast<const Part::GeomArcOfCircle*>(g);
|
| if (segm->isReversed()) {
|
|
|
|
|
| if (!affected)
|
| constNew = newVals[ic]->clone();
|
| affected = true;
|
|
|
| if (posId == Sketcher::PointPos::start)
|
| posId = Sketcher::PointPos::end;
|
| else if (posId == Sketcher::PointPos::end)
|
| posId = Sketcher::PointPos::start;
|
| }
|
| }
|
| }
|
| if (!affected)
|
| continue;
|
|
|
| switch (ig) {
|
| case 1:
|
| constNew->First = geoId;
|
| constNew->FirstPos = posId;
|
| break;
|
| case 2:
|
| constNew->Second = geoId;
|
| constNew->SecondPos = posId;
|
| break;
|
| case 3:
|
| constNew->Third = geoId;
|
| constNew->ThirdPos = posId;
|
| break;
|
| }
|
| }
|
| if (affected) {
|
| cntToBeAffected++;
|
| newVals[ic] = constNew;
|
| Base::Console().log("Constraint%i will be affected\n", ic + 1);
|
| };
|
| }
|
|
|
| if (!justAnalyze) {
|
| this->Constraints.setValues(std::move(newVals));
|
| Base::Console().log("Swapped start/end of reversed external arcs in %i constraints\n",
|
| cntToBeAffected);
|
| }
|
|
|
| return cntToBeAffected;
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| bool SketchObject::AutoLockTangencyAndPerpty(Constraint* cstr, bool bForce, bool bLock)
|
| {
|
| using std::numbers::pi;
|
|
|
| try {
|
|
|
| if (cstr->getValue() != 0.0 && !bForce)
|
| return true;
|
| if (!bLock) {
|
| cstr->setValue(0.0);
|
| }
|
| else {
|
|
|
|
|
| int geoId1, geoId2, geoIdPt;
|
| PointPos posPt;
|
| geoId1 = cstr->First;
|
| geoId2 = cstr->Second;
|
| geoIdPt = cstr->Third;
|
| posPt = cstr->ThirdPos;
|
| if (geoIdPt == GeoEnum::GeoUndef) {
|
|
|
|
|
|
|
|
|
|
|
| auto geof = getGeometryFacade(cstr->First);
|
| if (geof->isInternalType(InternalType::BSplineKnotPoint)) {
|
|
|
|
|
| return false;
|
| }
|
|
|
| geoIdPt = cstr->First;
|
| posPt = cstr->FirstPos;
|
| }
|
| if (posPt == PointPos::none) {
|
|
|
|
|
| return false;
|
| }
|
|
|
| Base::Vector3d p = getPoint(geoIdPt, posPt);
|
|
|
|
|
|
|
|
|
|
|
| double angleOffset = 0.0;
|
|
|
| double angleDesire = 0.0;
|
| if (cstr->Type == Tangent) {
|
| angleOffset = -pi / 2;
|
| angleDesire = 0.0;
|
| }
|
| if (cstr->Type == Perpendicular) {
|
| angleOffset = 0;
|
| angleDesire = pi / 2;
|
| }
|
|
|
| double angleErr = calculateAngleViaPoint(geoId1, geoId2, p.x, p.y) - angleDesire;
|
|
|
|
|
| if (angleErr > pi)
|
| angleErr -= pi * 2;
|
| if (angleErr < -pi)
|
| angleErr += pi * 2;
|
|
|
|
|
| if (fabs(angleErr) > pi / 2)
|
| angleDesire += pi;
|
|
|
|
|
|
|
| cstr->setValue(angleDesire + angleOffset);
|
| }
|
| }
|
| catch (Base::Exception& e) {
|
|
|
| Base::Console().warning("Error in AutoLockTangency. %s \n", e.what());
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
| App::DocumentObject *SketchObject::getSubObject(
|
| const char *subname, PyObject **pyObj,
|
| Base::Matrix4D *pmat, bool transform, int depth) const
|
| {
|
| while(subname && *subname=='.') ++subname;
|
| std::string sub;
|
| const char *mapped = Data::isMappedElement(subname);
|
| if(!subname || !subname[0]) {
|
| return Part2DObject::getSubObject(subname,pyObj,pmat,transform,depth);
|
| }
|
| const char *element = Data::findElementName(subname);
|
| if(element != subname) {
|
| const char *dot = strchr(subname,'.');
|
| if(!dot)
|
| return 0;
|
| std::string name(subname,dot-subname);
|
| auto child = Exports.find(name.c_str());
|
| if(!child)
|
| return 0;
|
| return child->getSubObject(dot+1,pyObj,pmat,true,depth+1);
|
| }
|
|
|
| Data::IndexedName indexedName = checkSubName(subname);
|
| int index = indexedName.getIndex();
|
| const char * shapetype = indexedName.getType();
|
| const Part::Geometry *geo = 0;
|
| Part::TopoShape subshape;
|
| Base::Vector3d point;
|
|
|
| if (auto realType = convertInternalName(indexedName.getType())) {
|
| if (realType[0] == '\0')
|
| subshape = InternalShape.getShape();
|
| else {
|
| auto shapeType = Part::TopoShape::shapeType(realType, true);
|
| if (shapeType != TopAbs_SHAPE)
|
| subshape = InternalShape.getShape().getSubTopoShape(shapeType, indexedName.getIndex(), true);
|
| }
|
| if (subshape.isNull())
|
| return nullptr;
|
| }
|
| else if (!pyObj || !mapped) {
|
| if (!pyObj
|
| || (index > 0
|
| && !boost::algorithm::contains(subname, "edge")
|
| && !boost::algorithm::contains(subname, "vertex")))
|
| return Part2DObject::getSubObject(subname,pyObj,pmat,transform,depth);
|
| }
|
| else {
|
| subshape = Shape.getShape().getSubTopoShape(subname, true);
|
| if (!subshape.isNull())
|
| return Part2DObject::getSubObject(subname,pyObj,pmat,transform,depth);
|
| }
|
|
|
| if (subshape.isNull()) {
|
| if (boost::equals(shapetype,"Edge") ||
|
| boost::equals(shapetype,"edge")) {
|
| geo = getGeometry(index - 1);
|
| if (!geo)
|
| return nullptr;
|
| }
|
| else if (boost::equals(shapetype,"ExternalEdge")) {
|
| int GeoId = index - 1;
|
| GeoId = -GeoId - 3;
|
| geo = getGeometry(GeoId);
|
| if(!geo)
|
| return nullptr;
|
| }
|
| else if (boost::equals(shapetype,"Vertex") ||
|
| boost::equals(shapetype,"vertex")) {
|
| int VtId = index- 1;
|
| int GeoId;
|
| PointPos PosId;
|
| getGeoVertexIndex(VtId,GeoId,PosId);
|
| if (PosId==PointPos::none)
|
| return nullptr;
|
| point = getPoint(GeoId,PosId);
|
| }
|
| else if (boost::equals(shapetype,"RootPoint"))
|
| point = getPoint(Sketcher::GeoEnum::RtPnt,PointPos::start);
|
| else if (boost::equals(shapetype,"H_Axis"))
|
| geo = getGeometry(Sketcher::GeoEnum::HAxis);
|
| else if (boost::equals(shapetype,"V_Axis"))
|
| geo = getGeometry(Sketcher::GeoEnum::VAxis);
|
| else if (boost::equals(shapetype,"Constraint")) {
|
| int ConstrId = PropertyConstraintList::getIndexFromConstraintName(shapetype);
|
| const std::vector< Constraint * > &vals = this->Constraints.getValues();
|
| if (ConstrId < 0 || ConstrId >= int(vals.size()))
|
| return nullptr;
|
| if(pyObj)
|
| *pyObj = vals[ConstrId]->getPyObject();
|
| return const_cast<SketchObject*>(this);
|
| }
|
| else {
|
| return nullptr;
|
| }
|
| }
|
|
|
| if (pmat && transform)
|
| *pmat *= Placement.getValue().toMatrix();
|
|
|
| if (!pyObj) {
|
| return const_cast<SketchObject*>(this);
|
| }
|
|
|
|
|
| Part::TopoShape shape;
|
| std::string name = convertSubName(indexedName,false);
|
| if (geo) {
|
| shape = getEdge(geo,name.c_str());
|
| if(pmat && !shape.isNull()) {
|
| shape.transformShape(*pmat,false,true);
|
| }
|
| }
|
| else if (!subshape.isNull()) {
|
| shape = subshape;
|
| if (pmat) {
|
| shape.transformShape(*pmat,false,true);
|
| }
|
| }
|
| else {
|
| if(pmat) {
|
| point = (*pmat)*point;
|
| }
|
| shape = BRepBuilderAPI_MakeVertex(gp_Pnt(point.x,point.y,point.z)).Vertex();
|
|
|
|
|
|
|
| if (!shape.hasElementMap()) {
|
| shape.resetElementMap(std::make_shared<Data::ElementMap>());
|
| }
|
| shape.setElementName(Data::IndexedName::fromConst("Vertex", 1),
|
| Data::MappedName::fromRawData(name.c_str()),0);
|
| }
|
| shape.Tag = getID();
|
| *pyObj = Py::new_reference_to(Part::shape2pyshape(shape));
|
|
|
| return const_cast<SketchObject*>(this);
|
| }
|
|
|
| std::vector<Data::IndexedName>
|
| SketchObject::getHigherElements(const char *element, bool silent) const
|
| {
|
| std::vector<Data::IndexedName> res;
|
| if (boost::istarts_with(element, "vertex")) {
|
| int n = 0;
|
| int index = atoi(element+6);
|
| for (auto cstr : Constraints.getValues()) {
|
| ++n;
|
| if (cstr->Type != Sketcher::Coincident)
|
| continue;
|
| if(cstr->First >= 0 && index == getSolvedSketch().getPointId(cstr->First, cstr->FirstPos) + 1)
|
| res.push_back(Data::IndexedName::fromConst("Constraint", n));
|
| if(cstr->Second >= 0 && index == getSolvedSketch().getPointId(cstr->Second, cstr->SecondPos) + 1)
|
| res.push_back(Data::IndexedName::fromConst("Constraint", n));
|
| }
|
| }
|
| return res;
|
|
|
| auto getNames = [this, &silent, &res](const char *element) {
|
| bool internal = boost::starts_with(element, internalPrefix());
|
| const auto &shape = internal ? InternalShape.getShape() : Shape.getShape();
|
| for (const auto &indexedName : shape.getHigherElements(element+(internal?internalPrefix().size() : 0), silent)) {
|
| if (!internal) {
|
| res.push_back(indexedName);
|
| }
|
| else if (boost::equals(indexedName.getType(), "Face")
|
| || boost::equals(indexedName.getType(), "Edge")
|
| || boost::equals(indexedName.getType(), "Wire")) {
|
| res.emplace_back((internalPrefix() + indexedName.getType()).c_str(), indexedName.getIndex());
|
| }
|
| }
|
| };
|
| getNames(element);
|
| const auto &elementMap = getInternalElementMap();
|
| auto it = elementMap.find(element);
|
| if (it != elementMap.end()) {
|
| res.emplace_back(it->second.c_str());
|
| getNames(it->second.c_str());
|
| }
|
| return res;
|
| }
|
|
|
| std::vector<const char *> SketchObject::getElementTypes(bool all) const
|
| {
|
| if (!all)
|
| return Part::Part2DObject::getElementTypes();
|
| static std::vector<const char *> res { Part::TopoShape::shapeName(TopAbs_VERTEX).c_str(),
|
| Part::TopoShape::shapeName(TopAbs_EDGE).c_str(),
|
| "ExternalEdge",
|
| "Constraint",
|
| "InternalEdge",
|
| "InternalFace",
|
| "InternalVertex",
|
| };
|
| return res;
|
| }
|
|
|
| void SketchObject::setExpression(const App::ObjectIdentifier& path,
|
| std::shared_ptr<App::Expression> expr)
|
| {
|
| DocumentObject::setExpression(path, std::move(expr));
|
|
|
| if (noRecomputes) {
|
|
|
|
|
| try {
|
| auto res = ExpressionEngine.execute();
|
| if (res) {
|
| FC_ERR("Failed to recompute " << ExpressionEngine.getFullName() << ": "
|
| << res->Why);
|
| delete res;
|
| }
|
| }
|
| catch (Base::Exception& e) {
|
| e.reportException();
|
| FC_ERR("Failed to recompute " << ExpressionEngine.getFullName() << ": " << e.what());
|
| }
|
| solve();
|
| }
|
| }
|
|
|
| const std::string &SketchObject::internalPrefix()
|
| {
|
| static std::string _prefix("Internal");
|
| return _prefix;
|
| }
|
|
|
| const char *SketchObject::convertInternalName(const char *name)
|
| {
|
| if (name && boost::starts_with(name, internalPrefix()))
|
| return name + internalPrefix().size();
|
| return nullptr;
|
| }
|
|
|
| App::ElementNamePair SketchObject::getElementName(
|
| const char *name, ElementNameType type) const
|
| {
|
| App::ElementNamePair ret;
|
| if(!name) return ret;
|
|
|
| if(hasSketchMarker(name))
|
| return Part2DObject::getElementName(name,type);
|
|
|
| const char *mapped = Data::isMappedElement(name);
|
| Data::IndexedName index = checkSubName(name);
|
| index.appendToStringBuffer(ret.oldName);
|
| if (auto realName = convertInternalName(ret.oldName.c_str())) {
|
| Data::MappedElement mappedElement;
|
| if (mapped)
|
| mappedElement = InternalShape.getShape().getElementName(name);
|
| else if (type == ElementNameType::Export)
|
| ret.newName = getExportElementName(InternalShape.getShape(), realName).newName;
|
| else
|
| mappedElement = InternalShape.getShape().getElementName(realName);
|
|
|
| if (mapped || type != ElementNameType::Export) {
|
| if (mappedElement.index) {
|
| ret.oldName = internalPrefix();
|
| mappedElement.index.appendToStringBuffer(ret.oldName);
|
| }
|
| if (mappedElement.name) {
|
| ret.newName = Data::ComplexGeoData::elementMapPrefix();
|
| mappedElement.name.appendToBuffer(ret.newName);
|
| }
|
| else if (mapped)
|
| ret.newName = name;
|
| }
|
|
|
| if (ret.newName.size()) {
|
| if (auto dot = strrchr(ret.newName.c_str(), '.'))
|
| ret.newName.resize(dot+1-ret.newName.c_str());
|
| else
|
| ret.newName += ".";
|
| ret.newName += ret.oldName;
|
| }
|
| if (mapped && (!mappedElement.index || !mappedElement.name))
|
| ret.oldName.insert(0, Data::MISSING_PREFIX);
|
| return ret;
|
| }
|
|
|
| if(!mapped) {
|
| auto occindex = Part::TopoShape::shapeTypeAndIndex(name);
|
| if (occindex.second)
|
| return Part2DObject::getElementName(name,type);
|
| }
|
| if(index && type==ElementNameType::Export) {
|
| if(boost::starts_with(ret.oldName,"Vertex"))
|
| ret.oldName[0] = 'v';
|
| else if(boost::starts_with(ret.oldName,"Edge"))
|
| ret.oldName[0] = 'e';
|
| }
|
| ret.newName = convertSubName(index, true);
|
| if(!Data::isMappedElement(ret.newName.c_str()))
|
| ret.newName.clear();
|
| return ret;
|
| }
|
|
|
| Part::TopoShape SketchObject::getEdge(const Part::Geometry *geo, const char *name) const
|
| {
|
| Part::TopoShape shape(geo->toShape());
|
|
|
|
|
|
|
| if ( !shape.hasElementMap() ) {
|
| shape.resetElementMap(std::make_shared<Data::ElementMap>());
|
| }
|
| shape.setElementName(Data::IndexedName::fromConst("Edge", 1),
|
| Data::MappedName::fromRawData(name),0L);
|
| TopTools_IndexedMapOfShape vmap;
|
| TopExp::MapShapes(shape.getShape(), TopAbs_VERTEX, vmap);
|
| std::ostringstream ss;
|
| for(int i=1;i<=vmap.Extent();++i) {
|
| auto gpt = BRep_Tool::Pnt(TopoDS::Vertex(vmap(i)));
|
| Base::Vector3d pt(gpt.X(),gpt.Y(),gpt.Z());
|
| PointPos pos[] = {PointPos::start,PointPos::end};
|
| for(size_t j=0;j<sizeof(pos)/sizeof(pos[0]);++j) {
|
| if(getPoint(geo,pos[j]) == pt) {
|
| ss.str("");
|
| ss << name << 'v' << static_cast<int>(pos[j]);
|
| shape.setElementName(Data::IndexedName::fromConst("Vertex", i),
|
| Data::MappedName::fromRawData(ss.str().c_str()),0L);
|
| break;
|
| }
|
| }
|
| }
|
| return shape;
|
| }
|
|
|
| Data::IndexedName SketchObject::checkSubName(const char *subname) const
|
| {
|
| static std::vector<const char *> types = {
|
| "Edge",
|
| "Vertex",
|
| "edge",
|
| "vertex",
|
| "ExternalEdge",
|
| "RootPoint",
|
| "H_Axis",
|
| "V_Axis",
|
| "Constraint",
|
|
|
|
|
| "InternalEdge",
|
| "InternalFace",
|
| "InternalVertex",
|
| };
|
|
|
| if(!subname) return Data::IndexedName();
|
| const char *mappedSubname = Data::isMappedElement(subname);
|
|
|
|
|
| if(!mappedSubname) {
|
| Data::IndexedName result(subname, types, true);
|
| if (boost::equals(result.getType(), "edge"))
|
| return Data::IndexedName("Edge", result.getIndex());
|
| if (boost::equals(result.getType(), "vertex"))
|
| return Data::IndexedName("Vertex", result.getIndex());
|
| return result;
|
| }
|
|
|
| bio::stream<bio::array_source> iss(mappedSubname+1, std::strlen(mappedSubname+1));
|
| int id = -1;
|
| bool valid = false;
|
| switch (mappedSubname[0]) {
|
| case '\0':
|
| break;
|
|
|
| case 'g':
|
| case 'e':
|
| if (iss >> id) {
|
| valid = true;
|
| }
|
| break;
|
|
|
|
|
| default: {
|
| const char* dot = strchr(mappedSubname, '.');
|
| if (dot) {
|
| mappedSubname = dot + 1;
|
| }
|
| return Data::IndexedName(mappedSubname, types, false);
|
| }
|
| }
|
|
|
| if (!valid) {
|
| FC_ERR("invalid subname " << subname);
|
| return Data::IndexedName();
|
| }
|
|
|
| int geoId;
|
| const Part::Geometry* geo = 0;
|
| switch (mappedSubname[0]) {
|
| case 'g': {
|
| auto it = geoMap.find(id);
|
| if (it != geoMap.end()) {
|
| geoId = it->second;
|
| geo = getGeometry(geoId);
|
| }
|
| break;
|
| }
|
| case 'e': {
|
| auto it = externalGeoMap.find(id);
|
| if (it != externalGeoMap.end()) {
|
| geoId = -it->second - 1;
|
| geo = getGeometry(geoId);
|
| }
|
| break;
|
| }
|
| }
|
| if (geo && GeometryFacade::getId(geo) == id) {
|
| char sep;
|
| int posId = static_cast<int>(PointPos::none);
|
| if ((iss >> sep >> posId) && sep == 'v') {
|
| int idx = getVertexIndexGeoPos(geoId, static_cast<PointPos>(posId));
|
|
|
|
|
|
|
|
|
|
|
| if (idx < 0 && (static_cast<PointPos>(posId) == PointPos::start || static_cast<PointPos>(posId) == PointPos::end)) {
|
| if (geo->is<Part::GeomCircle>() || geo->is<Part::GeomEllipse>()) {
|
| idx = getVertexIndexGeoPos(geoId, PointPos::mid);
|
| }
|
| }
|
|
|
| if (idx < 0) {
|
| FC_ERR("invalid subname " << subname);
|
| return Data::IndexedName();
|
| }
|
| return Data::IndexedName::fromConst("Vertex", idx + 1);
|
| }
|
| else if (geoId >= 0) {
|
| return Data::IndexedName::fromConst("Edge", geoId + 1);
|
| }
|
| else {
|
| return Data::IndexedName::fromConst("ExternalEdge", -geoId - 2);
|
| }
|
| }
|
| FC_ERR("cannot find subname " << subname);
|
|
|
| return Data::IndexedName();
|
| }
|
|
|
| Data::IndexedName SketchObject::shapeTypeFromGeoId(int geoId, PointPos posId) const
|
| {
|
| if (geoId == GeoEnum::HAxis) {
|
| if (posId == PointPos::start) {
|
| return Data::IndexedName::fromConst("RootPoint", 0);
|
| }
|
| return Data::IndexedName::fromConst("H_Axis", 0);
|
| }
|
| if (geoId == GeoEnum::VAxis) {
|
| return Data::IndexedName::fromConst("V_Axis", 0);
|
| }
|
|
|
| if (posId == PointPos::none) {
|
| auto geo = getGeometry(geoId);
|
| if (geo && geo->isDerivedFrom<Part::GeomPoint>()) {
|
| posId = PointPos::start;
|
| }
|
| }
|
| if(posId != PointPos::none) {
|
| int idx = getVertexIndexGeoPos(geoId, posId);
|
| if (idx < 0) {
|
| return Data::IndexedName();
|
| }
|
| return Data::IndexedName::fromConst("Vertex", idx + 1);
|
| }
|
| if (geoId >= 0) {
|
| return Data::IndexedName::fromConst("Edge", geoId + 1);
|
| }
|
| return Data::IndexedName::fromConst("ExternalEdge", -geoId - 2);
|
| }
|
|
|
| bool SketchObject::geoIdFromShapeType(const Data::IndexedName & indexedName,
|
| int &geoId,
|
| PointPos &posId) const
|
| {
|
| posId = PointPos::none;
|
| geoId = Sketcher::GeoEnum::GeoUndef;
|
| if (!indexedName)
|
| return false;
|
| const char *shapetype = indexedName.getType();
|
| if (boost::equals(shapetype,"Edge") ||
|
| boost::equals(shapetype,"edge")) {
|
| geoId = indexedName.getIndex() - 1;
|
| } else if (boost::equals(shapetype,"ExternalEdge")) {
|
| geoId = indexedName.getIndex() - 1;
|
| geoId = Sketcher::GeoEnum::RefExt - geoId;
|
| } else if (boost::equals(shapetype,"Vertex") ||
|
| boost::equals(shapetype,"vertex")) {
|
| int VtId = indexedName.getIndex() - 1;
|
| getGeoVertexIndex(VtId,geoId,posId);
|
| if (posId==PointPos::none) return false;
|
| } else if (boost::equals(shapetype,"H_Axis")) {
|
| geoId = Sketcher::GeoEnum::HAxis;
|
| } else if (boost::equals(shapetype,"V_Axis")) {
|
| geoId = Sketcher::GeoEnum::VAxis;
|
| } else if (boost::equals(shapetype,"RootPoint")) {
|
| geoId = Sketcher::GeoEnum::RtPnt;
|
| posId = PointPos::start;
|
| } else
|
| return false;
|
| return true;
|
| }
|
|
|
| std::string SketchObject::convertSubName(const char *subname, bool postfix) const {
|
| return convertSubName(checkSubName(subname), postfix);
|
| }
|
|
|
| std::string SketchObject::convertSubName(const Data::IndexedName &indexedName, bool postfix) const {
|
| std::ostringstream ss;
|
| if (auto realType = convertInternalName(indexedName.getType())) {
|
| auto mapped = InternalShape.getShape().getMappedName(
|
| Data::IndexedName::fromConst(realType, indexedName.getIndex()));
|
| if (!mapped) {
|
| if (postfix)
|
| ss << indexedName;
|
| } else if (postfix)
|
| ss << Data::ComplexGeoData::elementMapPrefix() << mapped << '.' << indexedName;
|
| else
|
| ss << mapped;
|
| return ss.str();
|
| }
|
| int geoId;
|
| PointPos posId;
|
| if (!geoIdFromShapeType(indexedName, geoId, posId)) {
|
| ss << indexedName;
|
| return ss.str();
|
| }
|
| if (geoId == Sketcher::GeoEnum::HAxis ||
|
| geoId == Sketcher::GeoEnum::VAxis ||
|
| geoId == Sketcher::GeoEnum::RtPnt) {
|
| if (postfix)
|
| ss << Data::ELEMENT_MAP_PREFIX;
|
| ss << indexedName;
|
| if (postfix)
|
| ss << '.' << indexedName;
|
| return ss.str();
|
| }
|
|
|
| auto geo = getGeometry(geoId);
|
| if (!geo) {
|
| std::string res = indexedName.toString();
|
| return res;
|
| }
|
| if (postfix)
|
| ss << Data::ELEMENT_MAP_PREFIX;
|
| ss << (geoId >= 0 ? 'g' : 'e') << GeometryFacade::getFacade(geo)->getId();
|
| if (posId != PointPos::none)
|
| ss << 'v' << static_cast<int>(posId);
|
| if (postfix) {
|
|
|
|
|
| if (indexedName.getIndex() <= 0)
|
| ss << '.' << indexedName;
|
| else if (boost::starts_with(indexedName.getType(), "Edge"))
|
| ss << ".e" << (indexedName.getType() + 1) << indexedName.getIndex();
|
| else if (boost::starts_with(indexedName.getType(), "Vertex"))
|
| ss << ".v" << (indexedName.getType() + 1) << indexedName.getIndex();
|
| else
|
| ss << '.' << indexedName;
|
| }
|
| return ss.str();
|
| }
|
|
|
| std::string SketchObject::getGeometryReference(int GeoId) const {
|
| auto geo = getGeometry(GeoId);
|
| if (!geo) {
|
| return {};
|
| }
|
| auto egf = ExternalGeometryFacade::getFacade(geo);
|
| if (egf->getRef().empty()) {
|
| return {};
|
| }
|
|
|
| const std::string &ref = egf->getRef();
|
|
|
| if (egf->testFlag(ExternalGeometryExtension::Missing)) {
|
| return std::string("? ") + ref;
|
| }
|
|
|
| auto pos = ref.find('.');
|
| if (pos == std::string::npos) {
|
| return ref;
|
| }
|
| std::string objName = ref.substr(0, pos);
|
| auto obj = getDocument()->getObject(objName.c_str());
|
| if (!obj) {
|
| return ref;
|
| }
|
|
|
| App::ElementNamePair elementName;
|
| App::GeoFeature::resolveElement(obj, ref.c_str() + pos + 1, elementName);
|
| if (!elementName.oldName.empty()) {
|
| return objName + "." + elementName.oldName;
|
| }
|
| return ref;
|
| }
|
|
|
| int SketchObject::autoConstraint(double precision, double angleprecision, bool includeconstruction)
|
| {
|
| return analyser->autoconstraint(precision, angleprecision, includeconstruction);
|
| }
|
|
|
| int SketchObject::detectMissingPointOnPointConstraints(double precision, bool includeconstruction)
|
| {
|
| return analyser->detectMissingPointOnPointConstraints(precision, includeconstruction);
|
| }
|
|
|
| void SketchObject::analyseMissingPointOnPointCoincident(double angleprecision)
|
| {
|
| analyser->analyseMissingPointOnPointCoincident(angleprecision);
|
| }
|
|
|
| int SketchObject::detectMissingVerticalHorizontalConstraints(double angleprecision)
|
| {
|
| return analyser->detectMissingVerticalHorizontalConstraints(angleprecision);
|
| }
|
|
|
| int SketchObject::detectMissingEqualityConstraints(double precision)
|
| {
|
| return analyser->detectMissingEqualityConstraints(precision);
|
| }
|
|
|
| std::vector<ConstraintIds>& SketchObject::getMissingPointOnPointConstraints()
|
| {
|
| return analyser->getMissingPointOnPointConstraints();
|
| }
|
|
|
| std::vector<ConstraintIds>& SketchObject::getMissingVerticalHorizontalConstraints()
|
| {
|
| return analyser->getMissingVerticalHorizontalConstraints();
|
| }
|
|
|
| std::vector<ConstraintIds>& SketchObject::getMissingLineEqualityConstraints()
|
| {
|
| return analyser->getMissingLineEqualityConstraints();
|
| }
|
|
|
| std::vector<ConstraintIds>& SketchObject::getMissingRadiusConstraints()
|
| {
|
| return analyser->getMissingRadiusConstraints();
|
| }
|
|
|
| void SketchObject::setMissingRadiusConstraints(std::vector<ConstraintIds>& cl)
|
| {
|
| if (analyser)
|
| analyser->setMissingRadiusConstraints(cl);
|
| }
|
|
|
| void SketchObject::setMissingLineEqualityConstraints(std::vector<ConstraintIds>& cl)
|
| {
|
| if (analyser)
|
| analyser->setMissingLineEqualityConstraints(cl);
|
| }
|
|
|
| void SketchObject::setMissingVerticalHorizontalConstraints(std::vector<ConstraintIds>& cl)
|
| {
|
| if (analyser)
|
| analyser->setMissingVerticalHorizontalConstraints(cl);
|
| }
|
|
|
| void SketchObject::setMissingPointOnPointConstraints(std::vector<ConstraintIds>& cl)
|
| {
|
| if (analyser)
|
| analyser->setMissingPointOnPointConstraints(cl);
|
| }
|
|
|
| void SketchObject::makeMissingPointOnPointCoincident(bool onebyone)
|
| {
|
| if (analyser) {
|
| onebyone ? analyser->makeMissingPointOnPointCoincidentOneByOne()
|
| : analyser->makeMissingPointOnPointCoincident();
|
| }
|
| }
|
|
|
| void SketchObject::makeMissingVerticalHorizontal(bool onebyone)
|
| {
|
| if (analyser) {
|
| onebyone ? analyser->makeMissingVerticalHorizontalOneByOne()
|
| : analyser->makeMissingVerticalHorizontal();
|
| }
|
| }
|
|
|
| void SketchObject::makeMissingEquality(bool onebyone)
|
| {
|
| if (analyser) {
|
| onebyone ? analyser->makeMissingEqualityOneByOne()
|
| : analyser->makeMissingEquality();
|
| }
|
| }
|
|
|
| int SketchObject::detectDegeneratedGeometries(double tolerance)
|
| {
|
| return analyser->detectDegeneratedGeometries(tolerance);
|
| }
|
|
|
| int SketchObject::removeDegeneratedGeometries(double tolerance)
|
| {
|
| return analyser->removeDegeneratedGeometries(tolerance);
|
| }
|
|
|
| int SketchObject::autoRemoveRedundants(DeleteOptions options)
|
| {
|
| auto redundants = getLastRedundant();
|
|
|
| if (redundants.empty()) {
|
| return 0;
|
| }
|
|
|
|
|
| for (size_t i = 0; i < redundants.size(); i++)
|
| redundants[i]--;
|
|
|
| delConstraints(redundants, options);
|
|
|
| return redundants.size();
|
| }
|
|
|
| int SketchObject::renameConstraint(int GeoId, std::string name)
|
| {
|
|
|
| const Constraint* item = Constraints[GeoId];
|
|
|
| if (item->Name != name) {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| Constraint* copy = item->clone();
|
| copy->Name = std::move(name);
|
|
|
| Constraints.set1Value(GeoId, copy);
|
| delete copy;
|
|
|
|
|
|
|
| solverNeedsUpdate = true;
|
|
|
| return 0;
|
| }
|
| return -1;
|
| }
|
|
|
| std::vector<Base::Vector3d> SketchObject::getOpenVertices() const
|
| {
|
| std::vector<Base::Vector3d> points;
|
|
|
| if (analyser)
|
| points = analyser->getOpenVertices();
|
|
|
| return points;
|
| }
|
|
|
|
|
|
|
| size_t setGeometryIdHelper(int GeoId, long id, std::vector<Part::Geometry*>& newVals, size_t searchOffset = 0, bool returnOnMatch = false)
|
| {
|
|
|
| for (size_t i = searchOffset; i < newVals.size(); i++) {
|
| newVals[i] = newVals[i]->clone();
|
|
|
| if ((int)i == GeoId) {
|
| auto gf = GeometryFacade::getFacade(newVals[i]);
|
|
|
| gf->setId(id);
|
|
|
| if (returnOnMatch) {
|
| return i;
|
| }
|
| }
|
| }
|
| return 0;
|
| }
|
| int SketchObject::setGeometryId(int GeoId, long id)
|
| {
|
|
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| if (GeoId < 0 || GeoId >= int(Geometry.getValues().size()))
|
| return -1;
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
| setGeometryIdHelper(GeoId, id, newVals);
|
|
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| this->Geometry.setValues(std::move(newVals));
|
| }
|
|
|
| return 0;
|
| }
|
| int SketchObject::setGeometryIds(std::vector<std::pair<int, long>> GeoIdsToIds)
|
| {
|
| Base::StateLocker lock(managedoperation, true);
|
|
|
| std::sort(GeoIdsToIds.begin(), GeoIdsToIds.end());
|
|
|
| size_t searchOffset = 0;
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| std::vector<Part::Geometry*> newVals(vals);
|
|
|
| for (size_t i = 0; i < GeoIdsToIds.size(); ++i) {
|
| int GeoId = GeoIdsToIds[i].first;
|
| long id = GeoIdsToIds[i].second;
|
| searchOffset = setGeometryIdHelper(GeoId, id, newVals, searchOffset, i != GeoIdsToIds.size()-1);
|
| }
|
|
|
|
|
|
|
| {
|
| Base::StateLocker preventUpdate(internaltransaction, true);
|
| this->Geometry.setValues(std::move(newVals));
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int SketchObject::getGeometryId(int GeoId, long& id) const
|
| {
|
| if (GeoId < 0 || GeoId >= int(Geometry.getValues().size()))
|
| return -1;
|
|
|
| const std::vector<Part::Geometry*>& vals = getInternalGeometry();
|
|
|
| auto gf = GeometryFacade::getFacade(vals[GeoId]);
|
|
|
| id = gf->getId();
|
|
|
| return 0;
|
| }
|
|
|
|
|
|
|
| namespace App
|
| {
|
|
|
| PROPERTY_SOURCE_TEMPLATE(Sketcher::SketchObjectPython, Sketcher::SketchObject)
|
| template<>
|
| const char* Sketcher::SketchObjectPython::getViewProviderName() const
|
| {
|
| return "SketcherGui::ViewProviderPython";
|
| }
|
| template<>
|
| PyObject* Sketcher::SketchObjectPython::getPyObject()
|
| {
|
| if (PythonObject.is(Py::_None())) {
|
|
|
| PythonObject = Py::Object(new FeaturePythonPyT<SketchObjectPy>(this), true);
|
| }
|
| return Py::new_reference_to(PythonObject);
|
| }
|
|
|
|
|
|
|
| template class SketcherExport FeaturePythonT<Sketcher::SketchObject>;
|
| }
|
|
|
|
|
|
|
