// SPDX-License-Identifier: LGPL-2.1-or-later /*************************************************************************** * Copyright (c) 2008 Werner Mayer * * * * This file is part of the FreeCAD CAx development system. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Library General Public * * License as published by the Free Software Foundation; either * * version 2 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU Library General Public License for more details. * * * * You should have received a copy of the GNU Library General Public * * License along with this library; see the file COPYING.LIB. If not, * * write to the Free Software Foundation, Inc., 59 Temple Place, * * Suite 330, Boston, MA 02111-1307, USA * * * ***************************************************************************/ #ifndef PART_GEOMETRY_H #define PART_GEOMETRY_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "GeometryExtension.h" namespace Part { enum KeepTag { NewTag, // Assign a new tag CopyTag // Keep the existing tag }; class PartExport Geometry: public Base::Persistence { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: ~Geometry() override; static std::unique_ptr fromShape(const TopoDS_Shape& s, bool silent = false); virtual TopoDS_Shape toShape() const = 0; virtual const Handle(Geom_Geometry) & handle() const = 0; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; /// returns a copy of this object having a new randomly generated tag. If you also want to copy /// the tag, you may use clone() instead. For creation of geometry with other handles, with or /// without the same tag, you may use the constructors and the sethandle functions. The tag of a /// geometry can be copied to another geometry using the assignTag function. virtual Geometry* copy() const = 0; /// returns a cloned object. A cloned object has the same tag (see getTag) as the original /// object. if you want a copy not having the same tag, you can use copy() instead. If you want /// a clone with another geometry handle, it is possible to clone an object and then assign /// another handle or to create an object via constructor and use assignTag to assign the tag of /// the other geometry. If you do not desire to have the same tag, then a copy can be performed /// by using a constructor (which will generate another tag) and then, if necessary (e.g. if the /// constructor did not take a handle as a parameter), set a new handle. Geometry* clone() const; /// returns the tag of the geometry object boost::uuids::uuid getTag() const; virtual bool isSame(const Geometry& other, double tol, double atol) const = 0; bool hasSameExtensions(const Geometry& other) const; std::vector> getExtensions() const; bool hasExtension(const Base::Type& type) const; bool hasExtension(const std::string& name) const; std::weak_ptr getExtension(const Base::Type& type) const; std::weak_ptr getExtension(const std::string& name) const; std::weak_ptr getExtension(const Base::Type& type); std::weak_ptr getExtension(const std::string& name); void setExtension(std::unique_ptr&& geo); void deleteExtension(const Base::Type& type); void deleteExtension(const std::string& name); void mirror(const Base::Vector3d& point) const; void mirror(const Base::Vector3d& point, const Base::Vector3d& dir) const; void rotate(const Base::Placement& plm) const; void scale(const Base::Vector3d& vec, double scale) const; void transform(const Base::Matrix4D& mat) const; void translate(const Base::Vector3d& vec) const; virtual bool reverseIfReversed() { return false; }; protected: /// create a new tag for the geometry object void createNewTag(); /// copies the tag from the geometry passed as a parameter to this object void assignTag(const Part::Geometry*); void copyNonTag(const Part::Geometry*); protected: Geometry(); protected: boost::uuids::uuid tag; std::vector> extensions; public: Geometry(const Geometry&) = delete; Geometry& operator=(const Geometry&) = delete; }; class PartExport GeomPoint: public Geometry { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomPoint(); explicit GeomPoint(const Handle(Geom_CartesianPoint) &); explicit GeomPoint(const Base::Vector3d&); ~GeomPoint() override; Geometry* copy() const override; TopoDS_Shape toShape() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; /** * Compare this point to another one. * @param other Other geometry point. Can pass in Other geometry types but will not match * @param tol Points meed to be within tol^2 to match. * @param atol Angle tolerance is not used for points. * @return True if a match is found. */ bool isSame(const Geometry& other, double tol, double atol) const override; const Handle(Geom_Geometry) & handle() const override; void setHandle(const Handle(Geom_CartesianPoint) &); Base::Vector3d getPoint() const; void setPoint(const Base::Vector3d&); private: Handle(Geom_CartesianPoint) myPoint; }; class GeomBSplineCurve; class GeomLine; class GeomLineSegment; class PartExport GeomCurve: public Geometry { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomCurve(); ~GeomCurve() override; static bool isLinear( const Handle(Geom_Curve) & c, Base::Vector3d* dir = nullptr, Base::Vector3d* base = nullptr ); bool isLinear(Base::Vector3d* dir = nullptr, Base::Vector3d* base = nullptr) const; TopoDS_Shape toShape() const override; /*! * \brief toBSpline Converts the curve to a B-spline * \param This is the start parameter of the curve * \param This is the end parameter of the curve * \return a B-spline curve */ GeomBSplineCurve* toBSpline(double first, double last) const; /*! The default implementation does the same as \ref toBSpline. In sub-classes this can be reimplemented to create a real NURBS curve and not just an approximation. */ virtual GeomBSplineCurve* toNurbs(double first, double last) const; /*! * \brief createArc Generates a curve that is an arc of this curve between given parameters * \param first Parameter at start of arc * \param last Parameter at end of arc. This may be < `first` for periodic curves. * \return the new curve */ virtual GeomCurve* createArc(double first, double last) const; bool tangent(double u, gp_Dir&) const; bool tangent(double u, Base::Vector3d& dir) const; Base::Vector3d pointAtParameter(double u) const; Base::Vector3d firstDerivativeAtParameter(double u) const; Base::Vector3d secondDerivativeAtParameter(double u) const; bool closestParameter(const Base::Vector3d& point, double& u) const; bool closestParameterToBasisCurve(const Base::Vector3d& point, double& u) const; double getFirstParameter() const; double getLastParameter() const; double curvatureAt(double u) const; double length(double u, double v) const; bool normalAt(double u, Base::Vector3d& dir) const; bool normalAt(const Base::Vector3d& curvepoint, Base::Vector3d& dir) const; bool intersect( const GeomCurve* c, std::vector>& points, double tol = Precision::Confusion() ) const; void reverse(); Base::Vector3d value(double u) const; GeomLine* toLine(KeepTag clone = CopyTag) const; GeomLineSegment* toLineSegment(KeepTag clone = CopyTag) const; protected: static bool intersect( const Handle(Geom_Curve) & c, const Handle(Geom_Curve) & c2, std::vector>& points, double tol = Precision::Confusion() ); }; class PartExport GeomBoundedCurve: public GeomCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomBoundedCurve(); ~GeomBoundedCurve() override; // Geometry helper virtual Base::Vector3d getStartPoint() const; virtual Base::Vector3d getEndPoint() const; }; class PartExport GeomBezierCurve: public GeomBoundedCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomBezierCurve(); explicit GeomBezierCurve(const Handle(Geom_BezierCurve) &); GeomBezierCurve(const std::vector&, const std::vector&); ~GeomBezierCurve() override; Geometry* copy() const override; std::vector getPoles() const; std::vector getWeights() const; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject(void) override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_BezierCurve) &); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_BezierCurve) myCurve; }; class PartExport GeomBSplineCurve: public GeomBoundedCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomBSplineCurve(); explicit GeomBSplineCurve(const Handle(Geom_BSplineCurve) &); GeomBSplineCurve( const std::vector& poles, const std::vector& weights, const std::vector& knots, const std::vector& multiplicities, int degree, bool periodic = false, bool checkrational = true ); ~GeomBSplineCurve() override; Geometry* copy() const override; GeomCurve* createArc(double first, double last) const override; /*! * Interpolate a spline passing through the given points without tangency. */ void interpolate(const std::vector&, Standard_Boolean = Standard_False); /*! * Set the poles and tangents for the cubic Hermite spline */ void interpolate(const std::vector&, const std::vector&); /*! * Compute the tangents for a Cardinal spline using the * the cubic Hermite spline. It uses the method for Cardinal splines. */ void getCardinalSplineTangents( const std::vector&, const std::vector&, std::vector& ) const; /*! * Compute the tangents for a Cardinal spline using the * the cubic Hermite spline. It uses the method for Cardinal splines. * It uses the same parameter for each tangent. */ void getCardinalSplineTangents(const std::vector&, double, std::vector&) const; int countPoles() const; int countKnots() const; void setPole(int index, const Base::Vector3d&, double weight = -1); void setPoles(const std::vector& poles, const std::vector& weights); void setPoles(const std::vector& poles); void setWeights(const std::vector& weights); void setKnot(int index, const double val, int mult = -1); void setKnots(const std::vector& knots); void setKnots(const std::vector& knots, const std::vector& multiplicities); std::vector getPoles() const; std::vector getWeights() const; std::vector getKnots() const; std::vector getMultiplicities() const; int getMultiplicity(int index) const; int getDegree() const; bool isPeriodic() const; void setPeriodic() const; bool isRational() const; bool join(const Handle(Geom_BoundedCurve) &); void makeC1Continuous(double, double); std::list toBiArcs(double tolerance) const; void increaseDegree(int degree); void approximate(double tol3d, int maxSegments, int maxDegree, GeomAbs_Shape continuity); void approximate( const std::vector& pnts, int minDegree = 3, int maxDegree = 8, GeomAbs_Shape continuity = GeomAbs_C2, double tol3d = 1.0e-3 ); void approximate( const std::vector& pnts, Approx_ParametrizationType parType, int minDegree = 3, int maxDegree = 8, GeomAbs_Shape continuity = GeomAbs_C2, double tol3d = 1.0e-3 ); void approximate( const std::vector& pnts, double weight1, double weight2, double weight3, int maxDegree = 8, GeomAbs_Shape continuity = GeomAbs_C2, double tol3d = 1.0e-3 ); void increaseMultiplicity(int index, int multiplicity); void insertKnot(double param, int multiplicity); bool removeKnot(int index, int multiplicity, double tolerance = Precision::PConfusion()); void Trim(double u, double v); void scaleKnotsToBounds(double u0, double u1); // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_BSplineCurve) &); const Handle(Geom_Geometry) & handle() const override; private: // If during assignment of weights (during the for loop iteratively setting the poles) all // weights become (temporarily) equal even though weights does not have equal values OCCT will // convert all the weights (the already assigned and those not yet assigned) to 1.0 (nonrational // b-splines have 1.0 weights). This may lead to the assignment of wrong of weight values. // // The work-around is to temporarily set the last weight to be assigned to a value different // from the current value and the to-be-assigned value for the weight at position // last-to-be-assign but one. void workAroundOCCTBug(const std::vector& weights); private: Handle(Geom_BSplineCurve) myCurve; }; class PartExport GeomConic: public GeomCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); protected: GeomConic(); public: ~GeomConic() override; Geometry* copy() const override = 0; /*! * \deprecated use getLocation * \brief getCenter */ Base::Vector3d getCenter() const; Base::Vector3d getLocation() const; std::optional getRotation() const; void setLocation(const Base::Vector3d& Center); /*! * \deprecated use setLocation * \brief setCenter */ void setCenter(const Base::Vector3d& Center); double getAngleXU() const; void setAngleXU(double angle); bool isReversed() const; bool reverseIfReversed() override; Base::Vector3d getAxisDirection() const; unsigned int getMemSize() const override = 0; PyObject* getPyObject() override = 0; GeomBSplineCurve* toNurbs(double first, double last) const override; bool isSame(const Geometry& other, double tol, double atol) const override; const Handle(Geom_Geometry) & handle() const override = 0; }; class PartExport GeomTrimmedCurve: public GeomBoundedCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomTrimmedCurve(); explicit GeomTrimmedCurve(const Handle(Geom_TrimmedCurve) &); ~GeomTrimmedCurve() override; Geometry* copy() const override; GeomCurve* createArc(double first, double last) const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject(void) override; bool isSame(const Geometry& other, double tol, double atol) const override; virtual void setHandle(const Handle(Geom_TrimmedCurve) &); const Handle(Geom_Geometry) & handle() const override; bool intersectBasisCurves( const GeomTrimmedCurve* c, std::vector>& points, double tol = Precision::Confusion() ) const; virtual void getRange(double& u, double& v) const; virtual void setRange(double u, double v); protected: Handle(Geom_TrimmedCurve) myCurve; }; class PartExport GeomArcOfConic: public GeomTrimmedCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); protected: GeomArcOfConic(); public: ~GeomArcOfConic() override; Geometry* copy() const override = 0; Base::Vector3d getStartPoint(bool emulateCCWXY) const; Base::Vector3d getEndPoint(bool emulateCCWXY) const; inline Base::Vector3d getStartPoint() const override { return getStartPoint(false); } inline Base::Vector3d getEndPoint() const override { return getEndPoint(false); } /*! * \deprecated use getLocation * \brief getCenter */ Base::Vector3d getCenter() const; Base::Vector3d getLocation() const; void setLocation(const Base::Vector3d& Center); /*! * \deprecated use setLocation * \brief setCenter */ void setCenter(const Base::Vector3d& Center); Base::Vector3d getAxisDirection() const; virtual void getRange(double& u, double& v, bool emulateCCWXY) const = 0; virtual void setRange(double u, double v, bool emulateCCWXY) = 0; inline void getRange(double& u, double& v) const override { getRange(u, v, false); } inline void setRange(double u, double v) override { setRange(u, v, false); } bool isReversed() const; bool reverseIfReversed() override; double getAngleXU() const; void setAngleXU(double angle); Base::Vector3d getXAxisDir() const; void setXAxisDir(const Base::Vector3d& newdir); unsigned int getMemSize() const override = 0; PyObject* getPyObject() override = 0; const Handle(Geom_Geometry) & handle() const override = 0; }; class PartExport GeomCircle: public GeomConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomCircle(); explicit GeomCircle(const Handle(Geom_Circle) &); ~GeomCircle() override; Geometry* copy() const override; GeomCurve* createArc(double first, double last) const override; double getRadius() const; void setRadius(double Radius); // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; bool isSame(const Geometry& other, double tol, double atol) const override; const Handle(Geom_Geometry) & handle() const override; void setHandle(const Handle(Geom_Circle) &); private: Handle(Geom_Circle) myCurve; }; class PartExport GeomArcOfCircle: public GeomArcOfConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomArcOfCircle(); explicit GeomArcOfCircle(const Handle(Geom_Circle) &); ~GeomArcOfCircle() override; Geometry* copy() const override; double getRadius() const; void setRadius(double Radius); double getAngle(bool emulateCCWXY) const; void getRange(double& u, double& v, bool emulateCCWXY) const override; void setRange(double u, double v, bool emulateCCWXY) override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; void setHandle(const Handle(Geom_TrimmedCurve) &) override; void setHandle(const Handle(Geom_Circle) &); const Handle(Geom_Geometry) & handle() const override; }; class PartExport GeomEllipse: public GeomConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomEllipse(); explicit GeomEllipse(const Handle(Geom_Ellipse) &); ~GeomEllipse() override; Geometry* copy() const override; GeomCurve* createArc(double first, double last) const override; double getMajorRadius() const; void setMajorRadius(double Radius); double getMinorRadius() const; void setMinorRadius(double Radius); Base::Vector3d getMajorAxisDir() const; void setMajorAxisDir(Base::Vector3d newdir); Base::Vector3d getMinorAxisDir() const; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_Ellipse) & e); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_Ellipse) myCurve; }; class PartExport GeomArcOfEllipse: public GeomArcOfConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomArcOfEllipse(); explicit GeomArcOfEllipse(const Handle(Geom_Ellipse) &); ~GeomArcOfEllipse() override; Geometry* copy() const override; double getMajorRadius() const; void setMajorRadius(double Radius); double getMinorRadius() const; void setMinorRadius(double Radius); Base::Vector3d getMajorAxisDir() const; void setMajorAxisDir(Base::Vector3d newdir); Base::Vector3d getMinorAxisDir() const; void getRange(double& u, double& v, bool emulateCCWXY) const override; void setRange(double u, double v, bool emulateCCWXY) override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; void setHandle(const Handle(Geom_TrimmedCurve) &) override; void setHandle(const Handle(Geom_Ellipse) &); const Handle(Geom_Geometry) & handle() const override; }; class PartExport GeomHyperbola: public GeomConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomHyperbola(); explicit GeomHyperbola(const Handle(Geom_Hyperbola) &); ~GeomHyperbola() override; Geometry* copy() const override; GeomCurve* createArc(double first, double last) const override; double getMajorRadius() const; void setMajorRadius(double Radius); double getMinorRadius() const; void setMinorRadius(double Radius); // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; bool isSame(const Geometry& other, double tol, double atol) const override; const Handle(Geom_Geometry) & handle() const override; void setHandle(const Handle(Geom_Hyperbola) &); private: Handle(Geom_Hyperbola) myCurve; }; class PartExport GeomArcOfHyperbola: public GeomArcOfConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomArcOfHyperbola(); explicit GeomArcOfHyperbola(const Handle(Geom_Hyperbola) &); ~GeomArcOfHyperbola() override; Geometry* copy() const override; double getMajorRadius() const; void setMajorRadius(double Radius); double getMinorRadius() const; void setMinorRadius(double Radius); Base::Vector3d getMajorAxisDir() const; void setMajorAxisDir(Base::Vector3d newdir); Base::Vector3d getMinorAxisDir() const; void getRange(double& u, double& v, bool emulateCCWXY) const override; void setRange(double u, double v, bool emulateCCWXY) override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; void setHandle(const Handle(Geom_TrimmedCurve) &) override; void setHandle(const Handle(Geom_Hyperbola) &); const Handle(Geom_Geometry) & handle() const override; }; class PartExport GeomParabola: public GeomConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomParabola(); explicit GeomParabola(const Handle(Geom_Parabola) &); ~GeomParabola() override; Geometry* copy() const override; GeomCurve* createArc(double first, double last) const override; double getFocal() const; void setFocal(double length); // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; bool isSame(const Geometry& other, double tol, double atol) const override; const Handle(Geom_Geometry) & handle() const override; void setHandle(const Handle(Geom_Parabola) &); private: Handle(Geom_Parabola) myCurve; }; class PartExport GeomArcOfParabola: public GeomArcOfConic { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomArcOfParabola(); explicit GeomArcOfParabola(const Handle(Geom_Parabola) &); ~GeomArcOfParabola() override; Geometry* copy() const override; double getFocal() const; void setFocal(double length); Base::Vector3d getFocus() const; void getRange(double& u, double& v, bool emulateCCWXY) const override; void setRange(double u, double v, bool emulateCCWXY) override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; GeomBSplineCurve* toNurbs(double first, double last) const override; void setHandle(const Handle(Geom_TrimmedCurve) &) override; void setHandle(const Handle(Geom_Parabola) &); const Handle(Geom_Geometry) & handle() const override; }; class PartExport GeomLine: public GeomCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomLine(); explicit GeomLine(const Handle(Geom_Line) &); GeomLine(const Base::Vector3d& Pos, const Base::Vector3d& Dir); ~GeomLine() override; Geometry* copy() const override; void setLine(const Base::Vector3d& Pos, const Base::Vector3d& Dir); Base::Vector3d getPos() const; Base::Vector3d getDir() const; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; const Handle(Geom_Geometry) & handle() const override; void setHandle(const Handle(Geom_Line) &); private: Handle(Geom_Line) myCurve; }; class PartExport GeomLineSegment: public GeomTrimmedCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomLineSegment(); explicit GeomLineSegment(const Handle(Geom_Line) & l); ~GeomLineSegment() override; Geometry* copy() const override; Base::Vector3d getStartPoint() const override; Base::Vector3d getEndPoint() const override; void setPoints(const Base::Vector3d& p1, const Base::Vector3d& p2); // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; void setHandle(const Handle(Geom_TrimmedCurve) &) override; void setHandle(const Handle(Geom_Line) &); const Handle(Geom_Geometry) & handle() const override; }; class PartExport GeomOffsetCurve: public GeomCurve { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomOffsetCurve(); GeomOffsetCurve(const Handle(Geom_Curve) &, double, const gp_Dir&); GeomOffsetCurve(const Handle(Geom_Curve) &, double, Base::Vector3d&); explicit GeomOffsetCurve(const Handle(Geom_OffsetCurve) &); ~GeomOffsetCurve() override; Geometry* copy() const override; Base::Vector3d getDir() const; double getOffset() const; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_OffsetCurve) & c); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_OffsetCurve) myCurve; }; class GeomPlane; class PartExport GeomSurface: public Geometry { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: enum Curvature { Maximum, Minimum, Mean, Gaussian }; GeomSurface(); ~GeomSurface() override; static bool isPlanar(const Handle(Geom_Surface) & s, gp_Pln* pln = nullptr, double tol = 1e-7); bool isPlanar(gp_Pln* pln = nullptr, double tol = 1e-7) const; TopoDS_Shape toShape() const override; GeomPlane* toPlane(bool clone = true, double tol = 1e-7) const; virtual std::optional getRotation() const; bool tangentU(double u, double v, gp_Dir& dirU) const; bool tangentV(double u, double v, gp_Dir& dirV) const; bool normal(double u, double v, gp_Dir& dir) const; std::optional point(double u, double v) const; /*! Computes the derivative of order Nu in the direction U and Nv in the direction V at the point P(U, V). */ virtual gp_Vec getDN(double u, double v, int Nu, int Nv) const; /** @name Curvature information */ //@{ bool isUmbillic(double u, double v) const; double curvature(double u, double v, Curvature) const; void curvatureDirections(double u, double v, gp_Dir& maxD, gp_Dir& minD) const; //@} }; class PartExport GeomBezierSurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomBezierSurface(); explicit GeomBezierSurface(const Handle(Geom_BezierSurface) &); ~GeomBezierSurface() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_BezierSurface) & b); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_BezierSurface) mySurface; }; class PartExport GeomBSplineSurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomBSplineSurface(); explicit GeomBSplineSurface(const Handle(Geom_BSplineSurface) &); ~GeomBSplineSurface() override; Geometry* copy() const override; void scaleKnotsToBounds(double u0, double u1, double v0, double v1); // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_BSplineSurface) &); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_BSplineSurface) mySurface; }; class PartExport GeomElementarySurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); protected: GeomElementarySurface(); public: ~GeomElementarySurface() override; Base::Vector3d getLocation() const; Base::Vector3d getDir() const; Base::Vector3d getXDir() const; Base::Vector3d getYDir() const; bool isSame(const Geometry& other, double tol, double atol) const override; }; class PartExport GeomCylinder: public GeomElementarySurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomCylinder(); explicit GeomCylinder(const Handle(Geom_CylindricalSurface) &); ~GeomCylinder() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; double getRadius() const; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_CylindricalSurface) &); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_CylindricalSurface) mySurface; }; class PartExport GeomCone: public GeomElementarySurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomCone(); explicit GeomCone(const Handle(Geom_ConicalSurface) &); ~GeomCone() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; double getRadius() const; double getSemiAngle() const; Base::Vector3d getApex() const; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_ConicalSurface) &); const Handle(Geom_Geometry) & handle() const override; // Overloaded for Geom_ConicalSurface because of an OCC bug gp_Vec getDN(double u, double v, int Nu, int Nv) const override; private: Handle(Geom_ConicalSurface) mySurface; }; class PartExport GeomSphere: public GeomElementarySurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomSphere(); explicit GeomSphere(const Handle(Geom_SphericalSurface) &); ~GeomSphere() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; double getRadius(void) const; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_SphericalSurface) &); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_SphericalSurface) mySurface; }; class PartExport GeomToroid: public GeomElementarySurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomToroid(); explicit GeomToroid(const Handle(Geom_ToroidalSurface) &); ~GeomToroid() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; double getMajorRadius() const; double getMinorRadius() const; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_ToroidalSurface) &); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_ToroidalSurface) mySurface; }; class PartExport GeomPlane: public GeomElementarySurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomPlane(); explicit GeomPlane(const Handle(Geom_Plane) &); explicit GeomPlane(const gp_Pln& pln); ~GeomPlane() override; Geometry* copy() const override; std::optional getRotation() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_Plane) &); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_Plane) mySurface; }; class PartExport GeomOffsetSurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomOffsetSurface(); GeomOffsetSurface(const Handle(Geom_Surface) &, double); explicit GeomOffsetSurface(const Handle(Geom_OffsetSurface) &); ~GeomOffsetSurface() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; double getOffset() const; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_OffsetSurface) & s); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_OffsetSurface) mySurface; }; class PartExport GeomPlateSurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomPlateSurface(); GeomPlateSurface(const Handle(Geom_Surface) &, const Plate_Plate&); explicit GeomPlateSurface(const GeomPlate_BuildPlateSurface&); explicit GeomPlateSurface(const Handle(GeomPlate_Surface) &); ~GeomPlateSurface() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(GeomPlate_Surface) & s); const Handle(Geom_Geometry) & handle() const override; private: Handle(GeomPlate_Surface) mySurface; }; class PartExport GeomTrimmedSurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomTrimmedSurface(); explicit GeomTrimmedSurface(const Handle(Geom_RectangularTrimmedSurface) &); ~GeomTrimmedSurface() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; bool isSame(const Geometry& other, double tol, double atol) const override; void setHandle(const Handle(Geom_RectangularTrimmedSurface) & s); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_RectangularTrimmedSurface) mySurface; }; class PartExport GeomSweptSurface: public GeomSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); protected: GeomSweptSurface(); public: ~GeomSweptSurface() override; Base::Vector3d getDir() const; bool isSame(const Geometry& other, double tol, double atol) const override; }; class PartExport GeomSurfaceOfRevolution: public GeomSweptSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomSurfaceOfRevolution(); GeomSurfaceOfRevolution(const Handle(Geom_Curve) &, const gp_Ax1&); explicit GeomSurfaceOfRevolution(const Handle(Geom_SurfaceOfRevolution) &); ~GeomSurfaceOfRevolution() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; void setHandle(const Handle(Geom_SurfaceOfRevolution) & c); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_SurfaceOfRevolution) mySurface; }; class PartExport GeomSurfaceOfExtrusion: public GeomSweptSurface { TYPESYSTEM_HEADER_WITH_OVERRIDE(); public: GeomSurfaceOfExtrusion(); GeomSurfaceOfExtrusion(const Handle(Geom_Curve) &, const gp_Dir&); explicit GeomSurfaceOfExtrusion(const Handle(Geom_SurfaceOfLinearExtrusion) &); ~GeomSurfaceOfExtrusion() override; Geometry* copy() const override; // Persistence implementer --------------------- unsigned int getMemSize() const override; void Save(Base::Writer& /*writer*/) const override; void Restore(Base::XMLReader& /*reader*/) override; // Base implementer ---------------------------- PyObject* getPyObject() override; void setHandle(const Handle(Geom_SurfaceOfLinearExtrusion) & c); const Handle(Geom_Geometry) & handle() const override; private: Handle(Geom_SurfaceOfLinearExtrusion) mySurface; }; // Helper functions for fillet tools PartExport bool find2DLinesIntersection( const Base::Vector3d& orig1, const Base::Vector3d& dir1, const Base::Vector3d& orig2, const Base::Vector3d& dir2, Base::Vector3d& point ); PartExport bool find2DLinesIntersection( const GeomLineSegment* lineSeg1, const GeomLineSegment* lineSeg2, Base::Vector3d& point ); PartExport bool findFilletCenter( const GeomLineSegment* lineSeg1, const GeomLineSegment* lineSeg2, double radius, Base::Vector3d& center ); PartExport bool findFilletCenter( const GeomLineSegment* lineSeg1, const GeomLineSegment* lineSeg2, double radius, const Base::Vector3d& refPnt1, const Base::Vector3d& refPnt2, Base::Vector3d& center ); PartExport double suggestFilletRadius( const GeomLineSegment* lineSeg1, const GeomLineSegment* lineSeg2, const Base::Vector3d& refPnt1, const Base::Vector3d& refPnt2 ); PartExport GeomArcOfCircle* create2LinesFilletGeometry( const GeomLineSegment* lineSeg1, const GeomLineSegment* lineSeg2, const Base::Vector3d& center, double radius ); PartExport GeomArcOfCircle* createFilletGeometry( const Geometry* geo1, const Geometry* geo2, const Base::Vector3d& refPnt1, const Base::Vector3d& refPnt2, double radius, int& pos1, int& pos2, bool& reverse ); PartExport std::unique_ptr makeFromSurface( const Handle(Geom_Surface) &, bool silent = false ); PartExport std::unique_ptr makeFromSurfaceAdaptor( const BRepAdaptor_Surface&, bool silent = false ); PartExport std::unique_ptr makeFromCurve(const Handle(Geom_Curve) &, bool silent = false); PartExport std::unique_ptr makeFromTrimmedCurve( const Handle(Geom_Curve) &, double f, double l, bool silent = false ); PartExport std::unique_ptr makeFromCurveAdaptor(const Adaptor3d_Curve&, bool silent = false); } // namespace Part #endif // PART_GEOMETRY_H