/* module functions */
static PyObject * approxSurface(PyObject *self, PyObject *args)
{
PyObject *o;
int orderU=4,orderV=4;
int pointsU=6,pointsV=6;
if (!PyArg_ParseTuple(args, "O|iiii",&o,&orderU,&orderV,&pointsU,&pointsV))
return NULL;
PY_TRY {
Py::Sequence l(o);
TColgp_Array1OfPnt clPoints(0, l.size()-1);
int index=0;
for (Py::Sequence::iterator it = l.begin(); it != l.end(); ++it) {
Py::Tuple t(*it);
clPoints(index++) = gp_Pnt(
(double)Py::Float(t.getItem(0)),
(double)Py::Float(t.getItem(1)),
(double)Py::Float(t.getItem(2)));
}
Reen::BSplineParameterCorrection pc(orderU,orderV,pointsU,pointsV);
Handle_Geom_BSplineSurface hSurf;
//pc.EnableSmoothing(true, 0.1f, 0.5f, 0.2f, 0.3f);
pc.EnableSmoothing(true, 0.1f, 1.0f, 0.0f, 0.0f);
hSurf = pc.CreateSurface(clPoints, 5, true, 1.0);
if (!hSurf.IsNull()) {
return new Part::BSplineSurfacePy(new Part::GeomBSplineSurface(hSurf));
}
PyErr_SetString(PyExc_Exception, "Computation of B-Spline surface failed");
return 0;
} PY_CATCH;
}
Py::Object BSplineSurfacePy::getLastUKnotIndex(void) const
{
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
int index = surf->LastUKnotIndex();
return Py::Int(index);
}
Py::Int BSplineSurfacePy::getVDegree(void) const
{
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
int deg = surf->VDegree();
return Py::Int(deg);
}
PyObject* BSplineSurfacePy::exchangeUV(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->ExchangeUV();
Py_Return;
}
PyObject* BSplineSurfacePy::increaseDegree(PyObject *args)
{
int udegree, vdegree;
if (!PyArg_ParseTuple(args, "ii",&udegree,&vdegree))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->IncreaseDegree(udegree,vdegree);
Py_Return;
}
PyObject* BSplineSurfacePy::getVKnot(PyObject *args)
{
int Index;
if (!PyArg_ParseTuple(args, "i", &Index))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
double M = surf->VKnot(Index);
return Py_BuildValue("d",M);
}
PyObject* BSplineSurfacePy::reparametrize(PyObject * args)
{
int u,v;
double tol = 0.000001;
if (!PyArg_ParseTuple(args, "ii|d", &u, &v, &tol))
return 0;
// u,v must be at least 2
u = std::max<int>(u, 2);
v = std::max<int>(v, 2);
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
double maxU = surf->UKnot(surf->NbUKnots()); // 1.0 if normalized surface
double maxV = surf->VKnot(surf->NbVKnots()); // 1.0 if normalized surface
GeomBSplineSurface* geom = new GeomBSplineSurface();
Handle_Geom_BSplineSurface spline = Handle_Geom_BSplineSurface::DownCast
(geom->handle());
for (int i=1; i<u-1; i++) {
double U = i * 1.0 / (u-1.0);
spline->InsertUKnot(U,i,tol,Standard_True);
}
for (int i=1; i<v-1; i++) {
double V = i * 1.0 / (v-1.0);
spline->InsertVKnot(V,i,tol,Standard_True);
}
for (int j=0; j<u; j++) {
double U = j * maxU / (u-1.0);
double newU = j * 1.0 / (u-1.0);
for (int k=0; k<v; k++) {
double V = k * maxV / (v-1.0);
double newV = k * 1.0 / (v-1.0);
// Get UV point and move new surface UV point
gp_Pnt point = surf->Value(U,V);
int ufirst, ulast, vfirst, vlast;
spline->MovePoint(newU, newV, point, j+1, j+1, k+1, k+1, ufirst, ulast, vfirst, vlast);
}
}
return new BSplineSurfacePy(geom);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
Py::List BSplineSurfacePy::getVKnotSequence(void) const
{
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
Standard_Integer m = 0;
for (int i=1; i<= surf->NbVKnots(); i++)
m += surf->VMultiplicity(i);
TColStd_Array1OfReal k(1,m);
surf->VKnotSequence(k);
Py::List list;
for (Standard_Integer i=k.Lower(); i<=k.Upper(); i++) {
list.append(Py::Float(k(i)));
}
return list;
}
PyObject* BSplineSurfacePy::bounds(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
Py::Tuple bound(4);
Standard_Real u1,u2,v1,v2;
surf->Bounds(u1,u2,v1,v2);
bound.setItem(0,Py::Float(u1));
bound.setItem(1,Py::Float(u2));
bound.setItem(2,Py::Float(v1));
bound.setItem(3,Py::Float(v2));
return Py::new_reference_to(bound);
}
PyObject* BSplineSurfacePy::setUPeriodic(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->SetUPeriodic();
Py_Return;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* PlateSurfacePy::makeApprox(PyObject *args, PyObject* kwds)
{
static char* kwds_Parameter[] = {"Tol3d","MaxSegments","MaxDegree","MaxDistance",
"CritOrder","Continuity","EnlargeCoeff",NULL};
double tol3d=0.01;
int maxSeg=9;
int maxDegree=3;
double dmax = 0.0001;
int critOrder=0;
char* cont = "C1";
double enlargeCoeff = 1.1;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|diidisd", kwds_Parameter,
&tol3d, &maxSeg, &maxDegree, &dmax, &critOrder, &cont, &enlargeCoeff))
return 0;
GeomAbs_Shape continuity;
std::string uc = cont;
if (uc == "C0")
continuity = GeomAbs_C0;
else if (uc == "C1")
continuity = GeomAbs_C1;
else if (uc == "C2")
continuity = GeomAbs_C2;
else if (uc == "C3")
continuity = GeomAbs_C3;
else if (uc == "CN")
continuity = GeomAbs_CN;
else if (uc == "G1")
continuity = GeomAbs_G1;
else
continuity = GeomAbs_C1;
PY_TRY {
GeomPlate_MakeApprox approx(Handle_GeomPlate_Surface::DownCast(getGeomPlateSurfacePtr()->handle()),
tol3d, maxSeg, maxDegree, dmax, critOrder, continuity, enlargeCoeff);
Handle_Geom_BSplineSurface hSurf = approx.Surface();
if (!hSurf.IsNull()) {
return new Part::BSplineSurfacePy(new Part::GeomBSplineSurface(hSurf));
}
PyErr_SetString(PyExc_RuntimeError, "Approximation of B-Spline surface failed");
return 0;
} PY_CATCH_OCC;
}
PyObject* BSplineSurfacePy::isURational(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
Standard_Boolean val = surf->IsURational();
if (val) {
Py_INCREF(Py_True);
return Py_True;
}
else {
Py_INCREF(Py_False);
return Py_False;
}
}
PyObject* BSplineSurfacePy::segment(PyObject *args)
{
double u1,u2,v1,v2;
if (!PyArg_ParseTuple(args, "dddd", &u1,&u2,&v1,&v2))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->Segment(u1,u2,v1,v2);
Py_Return;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::getVMultiplicity(PyObject *args)
{
int index;
if (!PyArg_ParseTuple(args, "i", &index))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
int mult = surf->VMultiplicity(index);
return Py_BuildValue("i", mult);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::setVKnot(PyObject *args)
{
int Index, M=-1;
double K;
if (!PyArg_ParseTuple(args, "id|i", &Index, &K, &M))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
if (M == -1) {
surf->SetUKnot(Index, K);
}
else {
surf->SetUKnot(Index, K, M);
}
Py_Return;
}
PyObject* BSplineSurfacePy::vIso(PyObject * args)
{
double v;
if (!PyArg_ParseTuple(args, "d", &v))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
Handle_Geom_Curve c = surf->VIso(v);
return new BSplineCurvePy(new GeomBSplineCurve(Handle_Geom_BSplineCurve::DownCast(c)));
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::setWeight(PyObject *args)
{
int uindex,vindex;
double weight;
if (!PyArg_ParseTuple(args, "iid",&uindex,&vindex,&weight))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->SetWeight(uindex,vindex,weight);
Py_Return;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::getResolution(PyObject *args)
{
double tol;
if (!PyArg_ParseTuple(args, "d", &tol))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
double utol, vtol;
surf->Resolution(tol,utol,vtol);
return Py_BuildValue("(dd)",utol,vtol);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::increaseVMultiplicity(PyObject *args)
{
int mult=-1;
int start, end;
if (!PyArg_ParseTuple(args, "ii|i", &start, &end, &mult))
return 0;
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
if (mult == -1) {
mult = end;
surf->IncreaseVMultiplicity(start, mult);
}
else {
surf->IncreaseVMultiplicity(start, end, mult);
}
Py_Return;
}
PyObject* BSplineSurfacePy::incrementVMultiplicity(PyObject *args)
{
int start, end, mult;
if (!PyArg_ParseTuple(args, "iii", &start, &end, &mult))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->IncrementVMultiplicity(start, end, mult);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
Py_Return;
}
PyObject* BSplineSurfacePy::getWeight(PyObject *args)
{
int uindex,vindex;
if (!PyArg_ParseTuple(args, "ii",&uindex,&vindex))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
Standard_OutOfRange_Raise_if
(uindex < 1 || uindex > surf->NbUPoles() ||
vindex < 1 || vindex > surf->NbVPoles(), "Weight index out of range");
double w = surf->Weight(uindex,vindex);
return Py_BuildValue("d", w);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::getUMultiplicities(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
TColStd_Array1OfInteger m(1,surf->NbUKnots());
surf->UMultiplicities(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(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::insertVKnot(PyObject *args)
{
double V, tol = 0.0;
int M=1;
PyObject* add = Py_True;
if (!PyArg_ParseTuple(args, "did|O!", &V, &M, &tol, &PyBool_Type, &add))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->InsertVKnot(V,M,tol,PyObject_IsTrue(add));
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
Py_Return;
}
PyObject* BSplineSurfacePy::getVKnots(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
TColStd_Array1OfReal w(1,surf->NbVKnots());
surf->VKnots(w);
Py::List knots;
for (Standard_Integer i=w.Lower(); i<=w.Upper(); i++) {
knots.append(Py::Float(w(i)));
}
return Py::new_reference_to(knots);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::insertVKnots(PyObject *args)
{
double tol = 0.0;
PyObject* add = Py_True;
PyObject* obj1;
PyObject* obj2;
if (!PyArg_ParseTuple(args, "O!O!|dO!", &PyList_Type, &obj1,
&PyList_Type, &obj2,
&tol, &PyBool_Type, &add))
return 0;
try {
Py::List knots(obj1);
TColStd_Array1OfReal k(1,knots.size());
int index=1;
for (Py::List::iterator it = knots.begin(); it != knots.end(); ++it) {
Py::Float val(*it);
k(index++) = (double)val;
}
Py::List mults(obj2);
TColStd_Array1OfInteger m(1,mults.size());
index=1;
for (Py::List::iterator it = mults.begin(); it != mults.end(); ++it) {
Py::Int val(*it);
m(index++) = (int)val;
}
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
surf->InsertVKnots(k,m,tol,PyObject_IsTrue(add));
Py_Return;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
Py_Return;
}
PyObject* BSplineSurfacePy::setPoleRow(PyObject *args)
{
int uindex;
PyObject* obj;
PyObject* obj2=0;
if (!PyArg_ParseTuple(args, "iO!|O!",&uindex,&PyList_Type,&obj,&PyList_Type,&obj2))
return 0;
try {
Py::List list(obj);
TColgp_Array1OfPnt poles(1, list.size());
int index=1;
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
Py::Vector p(*it);
Base::Vector3d v = p.toVector();
poles(index++) = gp_Pnt(v.x,v.y,v.z);
}
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
if (obj2 == 0) {
surf->SetPoleRow(uindex, poles);
}
else {
Py::List list(obj2);
TColStd_Array1OfReal weights(1, list.size());
int index=1;
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
weights(index++) = (double)Py::Float(*it);
}
surf->SetPoleRow(uindex, poles, weights);
}
Py_Return;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::getPole(PyObject *args)
{
int uindex,vindex;
if (!PyArg_ParseTuple(args, "ii", &uindex,&vindex))
return 0;
try {
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
Standard_OutOfRange_Raise_if
(uindex < 1 || uindex > surf->NbUPoles() ||
vindex < 1 || vindex > surf->NbVPoles(), "Pole index out of range");
gp_Pnt pnt = surf->Pole(uindex,vindex);
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(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::movePoint(PyObject *args)
{
double U,V;
int uindex1, uindex2;
int vindex1, vindex2;
PyObject* pnt;
if (!PyArg_ParseTuple(args, "ddO!iiii", &U, &V, &(Base::VectorPy::Type),&pnt,
&uindex1, &uindex2,&vindex1, &vindex2))
return 0;
try {
Base::Vector3d p = static_cast<Base::VectorPy*>(pnt)->value();
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
int ufirst, ulast, vfirst, vlast;
surf->MovePoint(U, V, gp_Pnt(p.x,p.y,p.z), uindex1, uindex2, vindex1, vindex2,
ufirst, ulast, vfirst, vlast);
return Py_BuildValue("(iiii)",ufirst, ulast, vfirst, vlast);
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
PyObject* BSplineSurfacePy::setPole(PyObject *args)
{
int uindex, vindex;
double weight=-1.0;
PyObject* p;
if (!PyArg_ParseTuple(args, "iiO!|d", &uindex,&vindex,&(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_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
if (weight < 0.0)
surf->SetPole(uindex,vindex,pnt);
else
surf->SetPole(uindex,vindex,pnt,weight);
Py_Return;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
Py::Int BSplineSurfacePy::getNbVKnots(void) const
{
Handle_Geom_BSplineSurface surf = Handle_Geom_BSplineSurface::DownCast
(getGeometryPtr()->handle());
return Py::Int(surf->NbVKnots());
}