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

+ add method trim() to Part.Curve

Browse Source
This commit is contained in:
wmayer
2017-07-26 22:59:39 +02:00
parent 6628b48012
commit ff4d613acb
3 changed files with 142 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/Mod/Part/App/GeometryCurvePy.xml
View File

@@ -148,6 +148,14 @@ of the nearest orthogonal projection of the point.</UserDocu>
</UserDocu>
</Documentation>
</Methode>
<Methode Name="trim">
<Documentation>
<UserDocu>
Returns a trimmed curve defined in the given parameter range
trim([Float=First, Float=Last]) -> trimmed curve
</UserDocu>
</Documentation>
</Methode>
<Methode Name="approximateBSpline">
<Documentation>
<UserDocu>

25
src/Mod/Part/App/GeometryCurvePyImp.cpp
View File

@@ -74,6 +74,7 @@
namespace Part {
extern const Py::Object makeGeometryCurvePy(const Handle(Geom_Curve)& c);
extern const Py::Object makeTrimmedCurvePy(const Handle(Geom_Curve)& c, double f,double l);
}
using namespace Part;
@@ -633,6 +634,30 @@ PyObject* GeometryCurvePy::toNurbs(PyObject * args)
return 0;
}
PyObject* GeometryCurvePy::trim(PyObject * args)
{
Handle(Geom_Geometry) g = getGeometryPtr()->handle();
Handle(Geom_Curve) c = Handle(Geom_Curve)::DownCast(g);
try {
if (!c.IsNull()) {
double u,v;
u=c->FirstParameter();
v=c->LastParameter();
if (!PyArg_ParseTuple(args, "|dd", &u,&v))
return 0;
return Py::new_reference_to(makeTrimmedCurvePy(c,u,v));
}
}
catch (Standard_Failure) {
Handle(Standard_Failure) e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return 0;
}
PyErr_SetString(PartExceptionOCCError, "Geometry is not a curve");
return 0;
}
PyObject* GeometryCurvePy::approximateBSpline(PyObject *args)
{
double tolerance;

109
src/Mod/Part/App/GeometrySurfacePyImp.cpp
View File

@@ -49,12 +49,17 @@
#include <Mod/Part/App/BSplineSurfacePy.h>
#include <Mod/Part/App/LinePy.h>
#include <Mod/Part/App/LineSegmentPy.h>
#include <Mod/Part/App/BezierCurvePy.h>
#include <Mod/Part/App/BSplineCurvePy.h>
#include <Mod/Part/App/CirclePy.h>
#include <Mod/Part/App/ArcOfCirclePy.h>
#include <Mod/Part/App/EllipsePy.h>
#include <Mod/Part/App/ArcOfEllipsePy.h>
#include <Mod/Part/App/HyperbolaPy.h>
#include <Mod/Part/App/ArcOfHyperbolaPy.h>
#include <Mod/Part/App/ParabolaPy.h>
#include <Mod/Part/App/ArcOfParabolaPy.h>
#include <Mod/Part/App/OffsetCurvePy.h>
#include <Mod/Part/App/TopoShape.h>
@@ -110,6 +115,110 @@ const Py::Object makeGeometryCurvePy(const Handle(Geom_Curve)& c)
throw Py::TypeError(err);
}
const Py::Object makeTrimmedCurvePy(const Handle(Geom_Curve)& c, double f,double l)
{
if (c->IsKind(STANDARD_TYPE(Geom_Circle))) {
Handle(Geom_Circle) circ = Handle(Geom_Circle)::DownCast(c);
GeomArcOfCircle* arc = new GeomArcOfCircle();
Handle(Geom_TrimmedCurve) this_arc = Handle(Geom_TrimmedCurve)::DownCast
(arc->handle());
Handle(Geom_Circle) this_circ = Handle(Geom_Circle)::DownCast
(this_arc->BasisCurve());
this_circ->SetCirc(circ->Circ());
this_arc->SetTrim(f, l);
return Py::Object(new ArcOfCirclePy(arc),true);
}
else if (c->IsKind(STANDARD_TYPE(Geom_Ellipse))) {
Handle(Geom_Ellipse) ellp = Handle(Geom_Ellipse)::DownCast(c);
GeomArcOfEllipse* arc = new GeomArcOfEllipse();
Handle(Geom_TrimmedCurve) this_arc = Handle(Geom_TrimmedCurve)::DownCast
(arc->handle());
Handle(Geom_Ellipse) this_ellp = Handle(Geom_Ellipse)::DownCast
(this_arc->BasisCurve());
this_ellp->SetElips(ellp->Elips());
this_arc->SetTrim(f, l);
return Py::Object(new ArcOfEllipsePy(arc),true);
}
else if (c->IsKind(STANDARD_TYPE(Geom_Hyperbola))) {
Handle(Geom_Hyperbola) hypr = Handle(Geom_Hyperbola)::DownCast(c);
GeomArcOfHyperbola* arc = new GeomArcOfHyperbola();
Handle(Geom_TrimmedCurve) this_arc = Handle(Geom_TrimmedCurve)::DownCast
(arc->handle());
Handle(Geom_Hyperbola) this_hypr = Handle(Geom_Hyperbola)::DownCast
(this_arc->BasisCurve());
this_hypr->SetHypr(hypr->Hypr());
this_arc->SetTrim(f, l);
return Py::Object(new ArcOfHyperbolaPy(arc),true);
}
else if (c->IsKind(STANDARD_TYPE(Geom_Line))) {
Handle(Geom_Line) line = Handle(Geom_Line)::DownCast(c);
GeomLineSegment* segm = new GeomLineSegment();
Handle(Geom_TrimmedCurve) this_segm = Handle(Geom_TrimmedCurve)::DownCast
(segm->handle());
Handle(Geom_Line) this_line = Handle(Geom_Line)::DownCast
(this_segm->BasisCurve());
this_line->SetLin(line->Lin());
this_segm->SetTrim(f, l);
return Py::Object(new LineSegmentPy(segm),true);
}
else if (c->IsKind(STANDARD_TYPE(Geom_Parabola))) {
Handle(Geom_Parabola) para = Handle(Geom_Parabola)::DownCast(c);
GeomArcOfParabola* arc = new GeomArcOfParabola();
Handle(Geom_TrimmedCurve) this_arc = Handle(Geom_TrimmedCurve)::DownCast
(arc->handle());
Handle(Geom_Parabola) this_para = Handle(Geom_Parabola)::DownCast
(this_arc->BasisCurve());
this_para->SetParab(para->Parab());
this_arc->SetTrim(f, l);
return Py::Object(new ArcOfParabolaPy(arc),true);
}
else if (c->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
Handle(Geom_BezierCurve) bezier = Handle(Geom_BezierCurve)::DownCast(c->Copy());
bezier->Segment(f, l);
return Py::asObject(new BezierCurvePy(new GeomBezierCurve(bezier)));
}
else if (c->IsKind(STANDARD_TYPE(Geom_BSplineCurve))) {
Handle(Geom_BSplineCurve) bspline = Handle(Geom_BSplineCurve)::DownCast(c->Copy());
bspline->Segment(f, l);
return Py::asObject(new BSplineCurvePy(new GeomBSplineCurve(bspline)));
}
else if (c->IsKind(STANDARD_TYPE(Geom_OffsetCurve))) {
Handle(Geom_OffsetCurve) oc = Handle(Geom_OffsetCurve)::DownCast(c);
double v = oc->Offset();
gp_Dir dir = oc->Direction();
Py::Object off(makeTrimmedCurvePy(oc->BasisCurve(), f, l));
Py::Tuple args(3);
args.setItem(0, off);
args.setItem(1, Py::Float(v));
Py::Module baseModule("__FreeCADBase__");
Py::Callable method(baseModule.getAttr("Vector"));
Py::Tuple coords(3);
coords.setItem(0, Py::Float(dir.X()));
coords.setItem(1, Py::Float(dir.Y()));
coords.setItem(2, Py::Float(dir.Z()));
args.setItem(2, method.apply(coords));
Py::Module partModule(PyImport_ImportModule("Part"), true);
Py::Callable call(partModule.getAttr("OffsetCurve"));
return call.apply(args);
}
else if (c->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
Handle(Geom_TrimmedCurve) trc = Handle(Geom_TrimmedCurve)::DownCast(c);
return makeTrimmedCurvePy(trc->BasisCurve(), f, l);
}
/*else if (c->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
Handle(Geom_BoundedCurve) bc = Handle(Geom_BoundedCurve)::DownCast(c);
return Py::asObject(new GeometryCurvePy(new GeomBoundedCurve(bc)));
}*/
std::string err = "Unhandled curve type ";
err += c->DynamicType()->Name();
throw Py::TypeError(err);
}
} // Part
// ---------------------------------------