diff --git a/src/Mod/Part/App/AppPart.cpp b/src/Mod/Part/App/AppPart.cpp index b751e8f61..e65b78b46 100644 --- a/src/Mod/Part/App/AppPart.cpp +++ b/src/Mod/Part/App/AppPart.cpp @@ -67,6 +67,7 @@ #include "ArcPy.h" #include "ArcOfCirclePy.h" #include "ArcOfEllipsePy.h" +#include "ArcOfParabolaPy.h" #include "BezierCurvePy.h" #include "BSplineCurvePy.h" #include "HyperbolaPy.h" @@ -174,6 +175,7 @@ void PartExport initPart() Base::Interpreter().addType(&Part::ArcPy ::Type,partModule,"Arc"); Base::Interpreter().addType(&Part::ArcOfCirclePy ::Type,partModule,"ArcOfCircle"); Base::Interpreter().addType(&Part::ArcOfEllipsePy ::Type,partModule,"ArcOfEllipse"); + Base::Interpreter().addType(&Part::ArcOfParabolaPy ::Type,partModule,"ArcOfParabola"); Base::Interpreter().addType(&Part::BezierCurvePy ::Type,partModule,"BezierCurve"); Base::Interpreter().addType(&Part::BSplineCurvePy ::Type,partModule,"BSplineCurve"); Base::Interpreter().addType(&Part::OffsetCurvePy ::Type,partModule,"OffsetCurve"); @@ -264,6 +266,7 @@ void PartExport initPart() Part::GeomCircle ::init(); Part::GeomArcOfCircle ::init(); Part::GeomArcOfEllipse ::init(); + Part::GeomArcOfParabola ::init(); Part::GeomEllipse ::init(); Part::GeomHyperbola ::init(); Part::GeomParabola ::init(); diff --git a/src/Mod/Part/App/ArcOfParabolaPy.xml b/src/Mod/Part/App/ArcOfParabolaPy.xml new file mode 100644 index 000000000..86d6dbe4c --- /dev/null +++ b/src/Mod/Part/App/ArcOfParabolaPy.xml @@ -0,0 +1,48 @@ + + + + + + Describes a portion of an parabola + + + + The focal length of the parabola. + + + + + + The angle between the X axis and the major axis of the parabola. + + + + + + Center of the parabola. + + + + + + The axis direction of the parabola + + + + + + The internal parabola representation + + + + + diff --git a/src/Mod/Part/App/ArcOfParabolaPyImp.cpp b/src/Mod/Part/App/ArcOfParabolaPyImp.cpp new file mode 100644 index 000000000..bf887a7e3 --- /dev/null +++ b/src/Mod/Part/App/ArcOfParabolaPyImp.cpp @@ -0,0 +1,221 @@ +/*************************************************************************** + * Copyright (c) 2014 Abdullah Tahiri +# include +# include +# include +# include +#endif + +#include "Mod/Part/App/Geometry.h" +#include "ArcOfParabolaPy.h" +#include "ArcOfParabolaPy.cpp" +#include "ParabolaPy.h" +#include "OCCError.h" + +#include +#include + +using namespace Part; + +extern const char* gce_ErrorStatusText(gce_ErrorType et); + +// returns a string which represents the object e.g. when printed in python +std::string ArcOfParabolaPy::representation(void) const +{ + Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast + (getGeomArcOfParabolaPtr()->handle()); + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast(trim->BasisCurve()); + + gp_Ax1 axis = parabola->Axis(); + gp_Dir dir = axis.Direction(); + gp_Pnt loc = axis.Location(); + Standard_Real fFocal = parabola->Focal(); + Standard_Real u1 = trim->FirstParameter(); + Standard_Real u2 = trim->LastParameter(); + + gp_Dir normal = parabola->Axis().Direction(); + gp_Dir xdir = parabola->XAxis().Direction(); + + gp_Ax2 xdirref(loc, normal); // this is a reference XY for the parabola + + Standard_Real fAngleXU = -xdir.AngleWithRef(xdirref.XDirection(),normal); + + + std::stringstream str; + str << "ArcOfParabola ("; + str << "Focal : " << fFocal << ", "; + str << "AngleXU : " << fAngleXU << ", "; + str << "Position : (" << loc.X() << ", "<< loc.Y() << ", "<< loc.Z() << "), "; + str << "Direction : (" << dir.X() << ", "<< dir.Y() << ", "<< dir.Z() << "), "; + str << "Parameter : (" << u1 << ", " << u2 << ")"; + str << ")"; + + return str.str(); +} + +PyObject *ArcOfParabolaPy::PyMake(struct _typeobject *, PyObject *, PyObject *) // Python wrapper +{ + // create a new instance of ArcOfParabolaPy and the Twin object + return new ArcOfParabolaPy(new GeomArcOfParabola); +} + +// constructor method +int ArcOfParabolaPy::PyInit(PyObject* args, PyObject* kwds) +{ + PyObject* o; + double u1, u2; + PyObject *sense=Py_True; + if (PyArg_ParseTuple(args, "O!dd|O!", &(Part::ParabolaPy::Type), &o, &u1, &u2, &PyBool_Type, &sense)) { + try { + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast + (static_cast(o)->getGeomParabolaPtr()->handle()); + GC_MakeArcOfParabola arc(parabola->Parab(), u1, u2, PyObject_IsTrue(sense) ? Standard_True : Standard_False); + if (!arc.IsDone()) { + PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(arc.Status())); + return -1; + } + + getGeomArcOfParabolaPtr()->setHandle(arc.Value()); + return 0; + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); + return -1; + } + catch (...) { + PyErr_SetString(PartExceptionOCCError, "creation of arc failed"); + return -1; + } + } + + // All checks failed + PyErr_SetString(PyExc_TypeError, + "ArcOfParabola constructor expects an parabola curve and a parameter range"); + return -1; +} + +Py::Float ArcOfParabolaPy::getFocal(void) const +{ + return Py::Float(getGeomArcOfParabolaPtr()->getFocal()); +} + +void ArcOfParabolaPy::setFocal(Py::Float arg) +{ + getGeomArcOfParabolaPtr()->setFocal((double)arg); +} + +Py::Float ArcOfParabolaPy::getAngleXU(void) const +{ + return Py::Float(getGeomArcOfParabolaPtr()->getAngleXU()); +} + +void ArcOfParabolaPy::setAngleXU(Py::Float arg) +{ + getGeomArcOfParabolaPtr()->setAngleXU((double)arg); +} + +Py::Object ArcOfParabolaPy::getCenter(void) const +{ + return Py::Vector(getGeomArcOfParabolaPtr()->getCenter()); +} + +void ArcOfParabolaPy::setCenter(Py::Object arg) +{ + PyObject* p = arg.ptr(); + if (PyObject_TypeCheck(p, &(Base::VectorPy::Type))) { + Base::Vector3d loc = static_cast(p)->value(); + getGeomArcOfParabolaPtr()->setCenter(loc); + } + else if (PyObject_TypeCheck(p, &PyTuple_Type)) { + Base::Vector3d loc = Base::getVectorFromTuple(p); + getGeomArcOfParabolaPtr()->setCenter(loc); + } + else { + std::string error = std::string("type must be 'Vector', not "); + error += p->ob_type->tp_name; + throw Py::TypeError(error); + } +} + +Py::Object ArcOfParabolaPy::getAxis(void) const +{ + Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast + (getGeomArcOfParabolaPtr()->handle()); + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast(trim->BasisCurve()); + gp_Ax1 axis = parabola->Axis(); + gp_Dir dir = axis.Direction(); + return Py::Vector(Base::Vector3d(dir.X(), dir.Y(), dir.Z())); +} + +void ArcOfParabolaPy::setAxis(Py::Object arg) +{ + PyObject* p = arg.ptr(); + Base::Vector3d val; + if (PyObject_TypeCheck(p, &(Base::VectorPy::Type))) { + val = static_cast(p)->value(); + } + else if (PyTuple_Check(p)) { + val = Base::getVectorFromTuple(p); + } + else { + std::string error = std::string("type must be 'Vector', not "); + error += p->ob_type->tp_name; + throw Py::TypeError(error); + } + + Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast + (getGeomArcOfParabolaPtr()->handle()); + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast(trim->BasisCurve()); + try { + gp_Ax1 axis; + axis.SetLocation(parabola->Location()); + axis.SetDirection(gp_Dir(val.x, val.y, val.z)); + parabola->SetAxis(axis); + } + catch (Standard_Failure) { + throw Py::Exception("cannot set axis"); + } +} + +Py::Object ArcOfParabolaPy::getParabola(void) const +{ + Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast + (getGeomArcOfParabolaPtr()->handle()); + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast(trim->BasisCurve()); + return Py::Object(new ParabolaPy(new GeomParabola(parabola)), true); +} + +PyObject *ArcOfParabolaPy::getCustomAttributes(const char* attr) const +{ + return 0; +} + +int ArcOfParabolaPy::setCustomAttributes(const char* attr, PyObject *obj) +{ + return 0; +} diff --git a/src/Mod/Part/App/ArcPyImp.cpp b/src/Mod/Part/App/ArcPyImp.cpp index 8aa4598c6..8c3e72810 100644 --- a/src/Mod/Part/App/ArcPyImp.cpp +++ b/src/Mod/Part/App/ArcPyImp.cpp @@ -26,16 +26,21 @@ # include # include # include +# include # include +# include # include # include # include +# include #endif + #include "ArcPy.h" #include "ArcPy.cpp" #include "CirclePy.h" #include "EllipsePy.h" +#include "ParabolaPy.h" #include "OCCError.h" #include @@ -133,6 +138,32 @@ int ArcPy::PyInit(PyObject* args, PyObject* /*kwd*/) } } + + PyErr_Clear(); + if (PyArg_ParseTuple(args, "O!dd|O!", &(Part::ParabolaPy::Type), &o, &u1, &u2, &PyBool_Type, &sense)) { + try { + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast + (static_cast(o)->getGeomParabolaPtr()->handle()); + GC_MakeArcOfParabola arc(parabola->Parab(), u1, u2, PyObject_IsTrue(sense) ? Standard_True : Standard_False); + if (!arc.IsDone()) { + PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(arc.Status())); + return -1; + } + + getGeomTrimmedCurvePtr()->setHandle(arc.Value()); + return 0; + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); + return -1; + } + catch (...) { + PyErr_SetString(PartExceptionOCCError, "creation of arc failed"); + return -1; + } + } + // All checks failed PyErr_SetString(PyExc_TypeError, "Arc constructor expects a conic curve and a parameter range"); return -1; diff --git a/src/Mod/Part/App/CMakeLists.txt b/src/Mod/Part/App/CMakeLists.txt index b745a5a2c..4ae68b91d 100644 --- a/src/Mod/Part/App/CMakeLists.txt +++ b/src/Mod/Part/App/CMakeLists.txt @@ -39,6 +39,7 @@ endif(FREETYPE_FOUND) generate_from_xml(ArcPy) generate_from_xml(ArcOfCirclePy) +generate_from_xml(ArcOfParabolaPy) generate_from_xml(CirclePy) generate_from_xml(ArcOfEllipsePy) generate_from_xml(EllipsePy) @@ -147,6 +148,8 @@ SET(Python_SRCS ArcPyImp.cpp ArcOfCirclePy.xml ArcOfCirclePyImp.cpp + ArcOfParabolaPy.xml + ArcOfParabolaPyImp.cpp CirclePy.xml CirclePyImp.cpp ArcOfEllipsePy.xml diff --git a/src/Mod/Part/App/Geometry.cpp b/src/Mod/Part/App/Geometry.cpp index 91cf9819a..561d09835 100644 --- a/src/Mod/Part/App/Geometry.cpp +++ b/src/Mod/Part/App/Geometry.cpp @@ -80,6 +80,8 @@ # include # include # include +# include +# include # include # include # include @@ -1352,11 +1354,151 @@ Geometry *GeomParabola::clone(void) const return newPar; } -// Persistence implementer -unsigned int GeomParabola::getMemSize (void) const {assert(0); return 0;/* not implemented yet */} -void GeomParabola::Save (Base::Writer &/*writer*/) const {assert(0); /* not implemented yet */} -void GeomParabola::Restore (Base::XMLReader &/*reader*/) {assert(0); /* not implemented yet */} +Base::Vector3d GeomParabola::getCenter(void) const +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(handle()); + gp_Ax1 axis = p->Axis(); + const gp_Pnt& loc = axis.Location(); + return Base::Vector3d(loc.X(),loc.Y(),loc.Z()); +} +void GeomParabola::setCenter(const Base::Vector3d& Center) +{ + gp_Pnt p1(Center.x,Center.y,Center.z); + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(handle()); + + try { + p->SetLocation(p1); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +double GeomParabola::getFocal(void) const +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(handle()); + return p->Focal(); +} + +void GeomParabola::setFocal(double length) +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(handle()); + + try { + p->SetFocal(length); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +double GeomParabola::getAngleXU(void) const +{ + gp_Pnt center = this->myCurve->Axis().Location(); + gp_Dir normal = this->myCurve->Axis().Direction(); + gp_Dir xdir = this->myCurve->XAxis().Direction(); + + gp_Ax2 xdirref(center, normal); // this is a reference system, might be CCW or CW depending on the creation method + + return -xdir.AngleWithRef(xdirref.XDirection(),normal); +} + +void GeomParabola::setAngleXU(double angle) +{ + try { + gp_Pnt center = this->myCurve->Axis().Location(); + gp_Dir normal = this->myCurve->Axis().Direction(); + + gp_Ax1 normaxis(center, normal); + + gp_Ax2 xdirref(center, normal); + + xdirref.Rotate(normaxis,angle); + + this->myCurve->SetPosition(xdirref); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +// Persistence implementer +unsigned int GeomParabola::getMemSize (void) const +{ + return sizeof(Geom_Parabola); +} + +void GeomParabola::Save(Base::Writer& writer) const +{ + // save the attributes of the father class + GeomCurve::Save(writer); + + gp_Pnt center = this->myCurve->Axis().Location(); + gp_Dir normal = this->myCurve->Axis().Direction(); + gp_Dir xdir = this->myCurve->XAxis().Direction(); + + gp_Ax2 xdirref(center, normal); // this is a reference XY for the ellipse + + double AngleXU = -xdir.AngleWithRef(xdirref.XDirection(),normal); + + writer.Stream() + << writer.ind() + << "myCurve->Focal() << "\" " + << "AngleXU=\"" << AngleXU << "\" " + << "/>" << endl; +} + +void GeomParabola::Restore(Base::XMLReader& reader) +{ + // read the attributes of the father class + GeomCurve::Restore(reader); + + double CenterX,CenterY,CenterZ,NormalX,NormalY,NormalZ,Focal,AngleXU; + // read my Element + reader.readElement("Parabola"); + // get the value of my Attribute + CenterX = reader.getAttributeAsFloat("CenterX"); + CenterY = reader.getAttributeAsFloat("CenterY"); + CenterZ = reader.getAttributeAsFloat("CenterZ"); + NormalX = reader.getAttributeAsFloat("NormalX"); + NormalY = reader.getAttributeAsFloat("NormalY"); + NormalZ = reader.getAttributeAsFloat("NormalZ"); + Focal = reader.getAttributeAsFloat("Focal"); + AngleXU = reader.getAttributeAsFloat("AngleXU"); + + // set the read geometry + gp_Pnt p1(CenterX,CenterY,CenterZ); + gp_Dir norm(NormalX,NormalY,NormalZ); + + gp_Ax1 normaxis(p1,norm); + + gp_Ax2 xdir(p1, norm); + + xdir.Rotate(normaxis,AngleXU); + + try { + gce_MakeParab mc(xdir, Focal); + if (!mc.IsDone()) + throw Base::Exception(gce_ErrorStatusText(mc.Status())); + + this->myCurve = new Geom_Parabola(mc.Value()); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} PyObject *GeomParabola::getPyObject(void) { return new ParabolaPy((GeomParabola*)this->clone()); @@ -1364,6 +1506,248 @@ PyObject *GeomParabola::getPyObject(void) // ------------------------------------------------- +TYPESYSTEM_SOURCE(Part::GeomArcOfParabola,Part::GeomCurve); + +GeomArcOfParabola::GeomArcOfParabola() +{ + Handle_Geom_Parabola p = new Geom_Parabola(gp_Parab()); + this->myCurve = new Geom_TrimmedCurve(p, p->FirstParameter(),p->LastParameter()); +} + +GeomArcOfParabola::GeomArcOfParabola(const Handle_Geom_Parabola& h) +{ + this->myCurve = new Geom_TrimmedCurve(h, h->FirstParameter(),h->LastParameter()); +} + +GeomArcOfParabola::~GeomArcOfParabola() +{ +} + +void GeomArcOfParabola::setHandle(const Handle_Geom_TrimmedCurve& c) +{ + Handle_Geom_Parabola basis = Handle_Geom_Parabola::DownCast(c->BasisCurve()); + if (basis.IsNull()) + Standard_Failure::Raise("Basis curve is not a parabola"); + this->myCurve = Handle_Geom_TrimmedCurve::DownCast(c->Copy()); +} + +const Handle_Geom_Geometry& GeomArcOfParabola::handle() const +{ + return myCurve; +} + +Geometry *GeomArcOfParabola::clone(void) const +{ + GeomArcOfParabola* copy = new GeomArcOfParabola(); + copy->setHandle(this->myCurve); + copy->Construction = this->Construction; + return copy; +} + +Base::Vector3d GeomArcOfParabola::getStartPoint() const +{ + gp_Pnt pnt = this->myCurve->StartPoint(); + return Base::Vector3d(pnt.X(), pnt.Y(), pnt.Z()); +} + +Base::Vector3d GeomArcOfParabola::getEndPoint() const +{ + gp_Pnt pnt = this->myCurve->EndPoint(); + return Base::Vector3d(pnt.X(), pnt.Y(), pnt.Z()); +} + +Base::Vector3d GeomArcOfParabola::getCenter(void) const +{ + Handle_Geom_Hyperbola h = Handle_Geom_Hyperbola::DownCast(myCurve->BasisCurve()); + gp_Ax1 axis = h->Axis(); + const gp_Pnt& loc = axis.Location(); + return Base::Vector3d(loc.X(),loc.Y(),loc.Z()); +} + +void GeomArcOfParabola::setCenter(const Base::Vector3d& Center) +{ + gp_Pnt p1(Center.x,Center.y,Center.z); + Handle_Geom_Hyperbola h = Handle_Geom_Hyperbola::DownCast(myCurve->BasisCurve()); + + try { + h->SetLocation(p1); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +double GeomArcOfParabola::getFocal(void) const +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(myCurve->BasisCurve()); + return p->Focal(); +} + +void GeomArcOfParabola::setFocal(double length) +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(myCurve->BasisCurve()); + + try { + p->SetFocal(length); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +double GeomArcOfParabola::getAngleXU(void) const +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(myCurve->BasisCurve()); + + gp_Pnt center = p->Axis().Location(); + gp_Dir normal = p->Axis().Direction(); + gp_Dir xdir = p->XAxis().Direction(); + + gp_Ax2 xdirref(center, normal); // this is a reference system, might be CCW or CW depending on the creation method + + return -xdir.AngleWithRef(xdirref.XDirection(),normal); + +} + +void GeomArcOfParabola::setAngleXU(double angle) +{ + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(myCurve->BasisCurve()); + + try { + gp_Pnt center = p->Axis().Location(); + gp_Dir normal = p->Axis().Direction(); + + gp_Ax1 normaxis(center, normal); + + gp_Ax2 xdirref(center, normal); + + xdirref.Rotate(normaxis,angle); + + p->SetPosition(xdirref); + + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +void GeomArcOfParabola::getRange(double& u, double& v) const +{ + u = myCurve->FirstParameter(); + v = myCurve->LastParameter(); +} + +void GeomArcOfParabola::setRange(double u, double v) +{ + try { + myCurve->SetTrim(u, v); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +// Persistence implementer +unsigned int GeomArcOfParabola::getMemSize (void) const +{ + return sizeof(Geom_Parabola) + 2 *sizeof(double); +} + +void GeomArcOfParabola::Save(Base::Writer &writer) const +{ + // save the attributes of the father class + GeomCurve::Save(writer); + + Handle_Geom_Parabola p = Handle_Geom_Parabola::DownCast(this->myCurve->BasisCurve()); + + gp_Pnt center = p->Axis().Location(); + gp_Dir normal = p->Axis().Direction(); + gp_Dir xdir = p->XAxis().Direction(); + + gp_Ax2 xdirref(center, normal); // this is a reference XY for the ellipse + + double AngleXU = -xdir.AngleWithRef(xdirref.XDirection(),normal); + + writer.Stream() + << writer.ind() + << "Focal() << "\" " + << "AngleXU=\"" << AngleXU << "\" " + << "StartAngle=\"" << this->myCurve->FirstParameter() << "\" " + << "EndAngle=\"" << this->myCurve->LastParameter() << "\" " + << "/>" << endl; +} + +void GeomArcOfParabola::Restore(Base::XMLReader &reader) +{ + // read the attributes of the father class + GeomCurve::Restore(reader); + + double CenterX,CenterY,CenterZ,NormalX,NormalY,NormalZ,Focal,AngleXU,StartAngle,EndAngle; + // read my Element + reader.readElement("ArcOfHyperbola"); + // get the value of my Attribute + CenterX = reader.getAttributeAsFloat("CenterX"); + CenterY = reader.getAttributeAsFloat("CenterY"); + CenterZ = reader.getAttributeAsFloat("CenterZ"); + NormalX = reader.getAttributeAsFloat("NormalX"); + NormalY = reader.getAttributeAsFloat("NormalY"); + NormalZ = reader.getAttributeAsFloat("NormalZ"); + Focal = reader.getAttributeAsFloat("Focal"); + AngleXU = reader.getAttributeAsFloat("AngleXU"); + StartAngle = reader.getAttributeAsFloat("StartAngle"); + EndAngle = reader.getAttributeAsFloat("EndAngle"); + + + // set the read geometry + gp_Pnt p1(CenterX,CenterY,CenterZ); + gp_Dir norm(NormalX,NormalY,NormalZ); + + gp_Ax1 normaxis(p1,norm); + + gp_Ax2 xdir(p1, norm); + + xdir.Rotate(normaxis,AngleXU); + + try { + gce_MakeParab mc(xdir, Focal); + if (!mc.IsDone()) + throw Base::Exception(gce_ErrorStatusText(mc.Status())); + + GC_MakeArcOfParabola ma(mc.Value(), StartAngle, EndAngle, 1); + if (!ma.IsDone()) + throw Base::Exception(gce_ErrorStatusText(ma.Status())); + + Handle_Geom_TrimmedCurve tmpcurve = ma.Value(); + Handle_Geom_Parabola tmpparabola = Handle_Geom_Parabola::DownCast(tmpcurve->BasisCurve()); + Handle_Geom_Parabola parabola = Handle_Geom_Parabola::DownCast(this->myCurve->BasisCurve()); + + parabola->SetParab(tmpparabola->Parab()); + this->myCurve->SetTrim(tmpcurve->FirstParameter(), tmpcurve->LastParameter()); + } + catch (Standard_Failure) { + Handle_Standard_Failure e = Standard_Failure::Caught(); + throw Base::Exception(e->GetMessageString()); + } +} + +PyObject *GeomArcOfParabola::getPyObject(void) +{ + //return new ArcOfParabolaPy(static_cast(this->clone())); +} + +// ------------------------------------------------- + TYPESYSTEM_SOURCE(Part::GeomLine,Part::GeomCurve); GeomLine::GeomLine() diff --git a/src/Mod/Part/App/Geometry.h b/src/Mod/Part/App/Geometry.h index 3d583bf39..6bccc2494 100644 --- a/src/Mod/Part/App/Geometry.h +++ b/src/Mod/Part/App/Geometry.h @@ -329,6 +329,13 @@ public: GeomParabola(const Handle_Geom_Parabola&); virtual ~GeomParabola(); virtual Geometry *clone(void) const; + + Base::Vector3d getCenter(void) const; + void setCenter(const Base::Vector3d& Center); + double getFocal(void) const; + void setFocal(double length); + double getAngleXU(void) const; + void setAngleXU(double angle); // Persistence implementer --------------------- virtual unsigned int getMemSize(void) const; @@ -343,6 +350,42 @@ private: Handle_Geom_Parabola myCurve; }; +class PartExport GeomArcOfParabola : public GeomCurve +{ + TYPESYSTEM_HEADER(); +public: + GeomArcOfParabola(); + GeomArcOfParabola(const Handle_Geom_Parabola&); + virtual ~GeomArcOfParabola(); + virtual Geometry *clone(void) const; + + Base::Vector3d getStartPoint() const; + Base::Vector3d getEndPoint() const; + + Base::Vector3d getCenter(void) const; + void setCenter(const Base::Vector3d& Center); + double getFocal(void) const; + void setFocal(double length); + double getAngleXU(void) const; + void setAngleXU(double angle); + + void getRange(double& u, double& v) const; + void setRange(double u, double v); + + // Persistence implementer --------------------- + virtual unsigned int getMemSize(void) const; + virtual void Save(Base::Writer &/*writer*/) const; + virtual void Restore(Base::XMLReader &/*reader*/); + // Base implementer ---------------------------- + virtual PyObject *getPyObject(void); + + void setHandle(const Handle_Geom_TrimmedCurve&); + const Handle_Geom_Geometry& handle() const; + +private: + Handle_Geom_TrimmedCurve myCurve; +}; + class PartExport GeomLine : public GeomCurve { TYPESYSTEM_HEADER(); diff --git a/src/Mod/Part/App/OpenCascadeAll.h b/src/Mod/Part/App/OpenCascadeAll.h index 16435c9b1..7e5630ede 100644 --- a/src/Mod/Part/App/OpenCascadeAll.h +++ b/src/Mod/Part/App/OpenCascadeAll.h @@ -172,9 +172,10 @@ #include #include #include +#include #include #include -#include +#include #include #include #include @@ -192,9 +193,9 @@ #include #include #include -#include +#include #include -#include +#include #include #include #include @@ -261,5 +262,5 @@ #include -#endif // __OpenCascadeAll__ - +#endif // __OpenCascadeAll__ +