PyObject* BSplineCurvePy::getPolesAndWeights(PyObject * args) { if (!PyArg_ParseTuple(args, "")) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); TColgp_Array1OfPnt p(1,curve->NbPoles()); curve->Poles(p); TColStd_Array1OfReal w(1,curve->NbPoles()); curve->Weights(w); Py::List poles; for (Standard_Integer i=p.Lower(); i<=p.Upper(); i++) { gp_Pnt pnt = p(i); double weight = w(i); Py::Tuple t(4); t.setItem(0, Py::Float(pnt.X())); t.setItem(1, Py::Float(pnt.Y())); t.setItem(2, Py::Float(pnt.Z())); t.setItem(3, Py::Float(weight)); poles.append(t); } return Py::new_reference_to(poles); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
Py::Object BSplineCurvePy::getEndPoint(void) const { Handle_Geom_BSplineCurve c = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); gp_Pnt pnt = c->EndPoint(); return Py::Vector(Base::Vector3d(pnt.X(), pnt.Y(), pnt.Z())); }
PyObject* BSplineCurvePy::setKnots(PyObject * args) { PyObject* obj; if (!PyArg_ParseTuple(args, "O", &obj)) return 0; try { Py::Sequence list(obj); TColStd_Array1OfReal k(1,list.size()); int index=1; for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) { Py::Float val(*it); k(index++) = (double)val; } Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->SetKnots(k); Py_Return; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::isClosed(PyObject *args) { if (!PyArg_ParseTuple(args, "")) return 0; Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); Standard_Boolean val = curve->IsClosed(); return PyBool_FromLong(val ? 1 : 0); }
//! Can this BSpline be represented by a straight line? bool BSpline::isLine() { bool result = false; BRepAdaptor_Curve c(occEdge); Handle_Geom_BSplineCurve spline = c.BSpline(); if (spline->NbPoles() == 2) { result = true; } return result; }
PyObject* BSplineCurvePy::getKnot(PyObject * args) { int Index; if (!PyArg_ParseTuple(args, "i", &Index)) return 0; Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); double M = curve->Knot(Index); return Py_BuildValue("d",M); }
PyObject* BSplineCurvePy::increaseDegree(PyObject * args) { int degree; if (!PyArg_ParseTuple(args, "i", °ree)) return 0; PY_TRY { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->IncreaseDegree(degree); Py_Return; } PY_CATCH_OCC ; }
PyObject* BSplineCurvePy::setPeriodic(PyObject * args) { if (!PyArg_ParseTuple(args, "")) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->SetPeriodic(); Py_Return; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::getMultiplicity(PyObject * args) { int index; if (!PyArg_ParseTuple(args, "i", &index)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); int mult = curve->Multiplicity(index); return Py_BuildValue("i", mult); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::setKnot(PyObject * args) { int Index, M=-1; double K; if (!PyArg_ParseTuple(args, "id|i", &Index, &K, &M)) return 0; Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); if (M == -1) { curve->SetKnot(Index, K); } else { curve->SetKnot(Index, K, M); } Py_Return; }
PyObject* BSplineCurvePy::setWeight(PyObject * args) { int index; double weight; if (!PyArg_ParseTuple(args, "id", &index,&weight)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->SetWeight(index,weight); Py_Return; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::getResolution(PyObject * args) { double tol; if (!PyArg_ParseTuple(args, "d", &tol)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); double utol; curve->Resolution(tol,utol); return Py_BuildValue("d",utol); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::getWeight(PyObject * args) { int index; if (!PyArg_ParseTuple(args, "i", &index)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); Standard_OutOfRange_Raise_if (index < 1 || index > curve->NbPoles() , "Weight index out of range"); double weight = curve->Weight(index); return Py_BuildValue("d", weight); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::incrementMultiplicity(PyObject * args) { int start, end, mult; if (!PyArg_ParseTuple(args, "iii", &start, &end, &mult)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->IncrementMultiplicity(start, end, mult); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } Py_Return; }
PyObject* BSplineCurvePy::increaseMultiplicity(PyObject * args) { int mult=-1; int start, end; if (!PyArg_ParseTuple(args, "ii|i", &start, &end, &mult)) return 0; Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); if (mult == -1) { mult = end; curve->IncreaseMultiplicity(start, mult); } else { curve->IncreaseMultiplicity(start, end, mult); } Py_Return; }
PyObject* BSplineCurvePy::removeKnot(PyObject * args) { double tol; int Index,M; if (!PyArg_ParseTuple(args, "iid", &Index, &M, &tol)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); Standard_Boolean ok = curve->RemoveKnot(Index,M,tol); return PyBool_FromLong(ok ? 1 : 0); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::getPole(PyObject * args) { int index; if (!PyArg_ParseTuple(args, "i", &index)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); Standard_OutOfRange_Raise_if (index < 1 || index > curve->NbPoles(), "Pole index out of range"); gp_Pnt pnt = curve->Pole(index); Base::VectorPy* vec = new Base::VectorPy(Base::Vector3d( pnt.X(), pnt.Y(), pnt.Z())); return vec; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::getWeights(PyObject * args) { if (!PyArg_ParseTuple(args, "")) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); TColStd_Array1OfReal w(1,curve->NbPoles()); curve->Weights(w); Py::List weights; for (Standard_Integer i=w.Lower(); i<=w.Upper(); i++) { weights.append(Py::Float(w(i))); } return Py::new_reference_to(weights); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::insertKnot(PyObject * args) { double U, tol = 0.0; int M=1; PyObject* add = Py_True; if (!PyArg_ParseTuple(args, "d|idO!", &U, &M, &tol, &PyBool_Type, &add)) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->InsertKnot(U,M,tol,PyObject_IsTrue(add) ? Standard_True : Standard_False); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } Py_Return; }
PyObject* BSplineCurvePy::getMultiplicities(PyObject * args) { if (!PyArg_ParseTuple(args, "")) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); TColStd_Array1OfInteger m(1,curve->NbKnots()); curve->Multiplicities(m); Py::List mults; for (Standard_Integer i=m.Lower(); i<=m.Upper(); i++) { mults.append(Py::Int(m(i))); } return Py::new_reference_to(mults); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::movePoint(PyObject * args) { double U; int index1, index2; PyObject* pnt; if (!PyArg_ParseTuple(args, "dO!ii", &U, &(Base::VectorPy::Type),&pnt, &index1, &index2)) return 0; try { Base::Vector3d p = static_cast<Base::VectorPy*>(pnt)->value(); Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); int first, last; curve->MovePoint(U, gp_Pnt(p.x,p.y,p.z), index1, index2, first, last); return Py_BuildValue("(ii)",first, last); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::insertKnots(PyObject * args) { double tol = 0.0; PyObject* add = Py_True; PyObject* obj1; PyObject* obj2; if (!PyArg_ParseTuple(args, "OO|dO!", &obj1, &obj2, &tol, &PyBool_Type, &add)) return 0; try { Py::Sequence knots(obj1); TColStd_Array1OfReal k(1,knots.size()); int index=1; for (Py::Sequence::iterator it = knots.begin(); it != knots.end(); ++it) { Py::Float val(*it); k(index++) = (double)val; } Py::Sequence mults(obj2); TColStd_Array1OfInteger m(1,mults.size()); index=1; for (Py::Sequence::iterator it = mults.begin(); it != mults.end(); ++it) { Py::Int val(*it); m(index++) = (int)val; } Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); curve->InsertKnots(k,m,tol,PyObject_IsTrue(add) ? Standard_True : Standard_False); Py_Return; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } Py_Return; }
PyObject* BSplineCurvePy::getPoles(PyObject * args) { if (!PyArg_ParseTuple(args, "")) return 0; try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); TColgp_Array1OfPnt p(1,curve->NbPoles()); curve->Poles(p); Py::List poles; for (Standard_Integer i=p.Lower(); i<=p.Upper(); i++) { gp_Pnt pnt = p(i); Base::VectorPy* vec = new Base::VectorPy(Base::Vector3d( pnt.X(), pnt.Y(), pnt.Z())); poles.append(Py::Object(vec)); } return Py::new_reference_to(poles); } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::setPole(PyObject * args) { int index; double weight=-1.0; PyObject* p; if (!PyArg_ParseTuple(args, "iO!|d", &index, &(Base::VectorPy::Type), &p, &weight)) return 0; Base::Vector3d vec = static_cast<Base::VectorPy*>(p)->value(); gp_Pnt pnt(vec.x, vec.y, vec.z); try { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); if (weight < 0.0) curve->SetPole(index,pnt); else curve->SetPole(index,pnt,weight); Py_Return; } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
Py::List BSplineCurvePy::getKnotSequence(void) const { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); Standard_Integer m = 0; if (curve->IsPeriodic()) { // knots=poles+2*degree-mult(1)+2 m = curve->NbPoles() + 2*curve->Degree() - curve->Multiplicity(1) + 2; } else { // knots=poles+degree+1 for (int i=1; i<= curve->NbKnots(); i++) m += curve->Multiplicity(i); } TColStd_Array1OfReal k(1,m); curve->KnotSequence(k); Py::List list; for (Standard_Integer i=k.Lower(); i<=k.Upper(); i++) { list.append(Py::Float(k(i))); } return list; }
PyObject* BSplineCurvePy::buildFromPoles(PyObject *args) { PyObject* obj; int degree = 3; PyObject* periodic = Py_False; PyObject* interpolate = Py_False; if (!PyArg_ParseTuple(args, "O|O!iO!",&obj, &PyBool_Type, &periodic, °ree, &PyBool_Type, interpolate)) return 0; try { Py::Sequence list(obj); TColgp_Array1OfPnt poles(1, list.size()); Standard_Integer index = 1; for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) { Py::Vector v(*it); Base::Vector3d pnt = v.toVector(); poles(index++) = gp_Pnt(pnt.x,pnt.y,pnt.z); } if (poles.Length() <= degree) degree = poles.Length()-1; if (PyObject_IsTrue(periodic)) { int mult; int len; if (PyObject_IsTrue(interpolate)) { mult = degree; len = poles.Length() - mult + 2; } else { mult = 1; len = poles.Length() + 1; } TColStd_Array1OfReal knots(1, len); TColStd_Array1OfInteger mults(1, len); for (int i=1; i<=knots.Length(); i++){ knots.SetValue(i,(double)(i-1)/(knots.Length()-1)); mults.SetValue(i,1); } mults.SetValue(1, mult); mults.SetValue(knots.Length(), mult); Handle_Geom_BSplineCurve spline = new Geom_BSplineCurve(poles, knots, mults, degree, Standard_True); if (!spline.IsNull()) { this->getGeomBSplineCurvePtr()->setHandle(spline); Py_Return; } else { Standard_Failure::Raise("failed to create spline"); return 0; // goes to the catch block } } else { TColStd_Array1OfReal knots(1, poles.Length()+degree+1-2*(degree)); TColStd_Array1OfInteger mults(1, poles.Length()+degree+1-2*(degree)); for (int i=1; i<=knots.Length(); i++){ knots.SetValue(i,(double)(i-1)/(knots.Length()-1)); mults.SetValue(i,1); } mults.SetValue(1, degree+1); mults.SetValue(knots.Length(), degree+1); Handle_Geom_BSplineCurve spline = new Geom_BSplineCurve(poles, knots, mults, degree, Standard_False); if (!spline.IsNull()) { this->getGeomBSplineCurvePtr()->setHandle(spline); Py_Return; } else { Standard_Failure::Raise("failed to create spline"); return 0; // goes to the catch block } } } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
PyObject* BSplineCurvePy::approximate(PyObject *args, PyObject *kwds) { PyObject* obj; Standard_Integer degMin=3; Standard_Integer degMax=8; char* continuity = "C2"; double tol3d = 1e-3; char* parType = "ChordLength"; PyObject* par = 0; double weight1 = 0; double weight2 = 0; double weight3 = 0; static char* kwds_interp[] = {"Points", "DegMax", "Continuity", "Tolerance", "DegMin", "ParamType", "Parameters", "LengthWeight", "CurvatureWeight", "TorsionWeight", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|isdisOddd",kwds_interp, &obj, °Max, &continuity, &tol3d, °Min, &parType, &par, &weight1, &weight2, &weight3)) return 0; try { Py::Sequence list(obj); TColgp_Array1OfPnt pnts(1,list.size()); Standard_Integer index = 1; for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) { Base::Vector3d vec = Py::Vector(*it).toVector(); pnts(index++) = gp_Pnt(vec.x,vec.y,vec.z); } if (degMin > degMax) { Standard_Failure::Raise("DegMin must be lower or equal to DegMax"); } GeomAbs_Shape c; std::string str = continuity; if (str == "C0") c = GeomAbs_C0; else if (str == "G1") c = GeomAbs_G1; else if (str == "C1") c = GeomAbs_C1; else if (str == "G2") c = GeomAbs_G2; else if (str == "C2") c = GeomAbs_C2; else if (str == "C3") c = GeomAbs_C3; else if (str == "CN") c = GeomAbs_CN; else c = GeomAbs_C2; if (weight1 || weight2 || weight3) { // It seems that this function only works with Continuity = C0, C1 or C2 if (!(c == GeomAbs_C0 || c == GeomAbs_C1 || c == GeomAbs_C2)) { c = GeomAbs_C2; } GeomAPI_PointsToBSpline fit(pnts, weight1, weight2, weight3, degMax, c, tol3d); Handle_Geom_BSplineCurve spline = fit.Curve(); if (!spline.IsNull()) { this->getGeomBSplineCurvePtr()->setHandle(spline); Py_Return; } else { Standard_Failure::Raise("Smoothing approximation failed"); return 0; // goes to the catch block } } if (par) { Py::Sequence plist(par); TColStd_Array1OfReal parameters(1,plist.size()); Standard_Integer index = 1; for (Py::Sequence::iterator it = plist.begin(); it != plist.end(); ++it) { Py::Float f(*it); parameters(index++) = static_cast<double>(f); } GeomAPI_PointsToBSpline fit(pnts, parameters, degMin, degMax, c, tol3d); Handle_Geom_BSplineCurve spline = fit.Curve(); if (!spline.IsNull()) { this->getGeomBSplineCurvePtr()->setHandle(spline); Py_Return; } else { Standard_Failure::Raise("Approximation with parameters failed"); return 0; // goes to the catch block } } Approx_ParametrizationType pt; std::string pstr = parType; if (pstr == "Uniform") pt = Approx_IsoParametric; else if (pstr == "Centripetal") pt = Approx_Centripetal; else pt = Approx_ChordLength; GeomAPI_PointsToBSpline fit(pnts, pt, degMin, degMax, c, tol3d); Handle_Geom_BSplineCurve spline = fit.Curve(); if (!spline.IsNull()) { this->getGeomBSplineCurvePtr()->setHandle(spline); Py_Return; } else { Standard_Failure::Raise("failed to approximate points"); return 0; // goes to the catch block } } catch (Standard_Failure) { Handle_Standard_Failure e = Standard_Failure::Caught(); PyErr_SetString(PartExceptionOCCError, e->GetMessageString()); return 0; } }
Py::Object BSplineCurvePy::getLastUKnotIndex(void) const { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); return Py::Int(curve->LastUKnotIndex()); }
Py::Int BSplineCurvePy::getNbKnots(void) const { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); return Py::Int(curve->NbKnots()); }
Py::Int BSplineCurvePy::getMaxDegree(void) const { Handle_Geom_BSplineCurve curve = Handle_Geom_BSplineCurve::DownCast (getGeometryPtr()->handle()); return Py::Int(curve->MaxDegree()); }