¿Cómo uso splines en pythonOCC?

cad opencascade

Question

Tengo una pregunta de dos partes sobre cómo usar splines en pythonOCC.

En primer lugar, sé que puedo crear una spline con

array = []
array.append(gp_Pnt2d (0,0))
array.append(gp_Pnt2d (1,2))
array.append(gp_Pnt2d (2,3))
array.append(gp_Pnt2d (4,3))
array.append(gp_Pnt2d (5,5))
pt2d_list = point2d_list_to_TColgp_Array1OfPnt2d(array)
SPL1 = Geom2dAPI_PointsToBSpline(pt2d_list).Curve()
display.DisplayShape(make_edge2d(SPL1) , update=True)

Y espero que el bspline pueda ser calculado por

BSPL1 = Geom2dAPI_PointsToBSpline(pt2d_list)

Pero, ¿cómo obtengo?

1. ¿El derivado de la bspline?
2. Los nudos de la bspline?
3. ¿Son los nudos la lista pt2d?
4. Los puntos de control de la bspline?
5. ¿Los coeficientes de la spline?

¿Y cómo quito o agrego nudos al bspline?

En segundo lugar, al cargar un archivo .stp de dibujo de CAD en pythonOCC de esta manera:

from OCC import TopoDS, StlAPI
shape = TopoDS.TopoDS_Shape()
stl_reader = StlAPI.StlAPI_Reader()
stl_reader.Read(shape,str(filename))
display.DisplayShape(shape)

¿Cómo puedo sacar los datos de la forma como nudo, línea de base y coeficientes?

Answer 1

He usado el python-boost lograr esto. Echa un vistazo a esta función: http://letslearncomputing.blogspot.com/2013/04/c-program-for-cubic-spline-interpolation.html Aquí puedes obtener algunos de tus 5 valores deseados.

Solo necesitas modificar el código para que sea C++ (no C )

BOOST_PYTHON_MODULE(Spline)
{
import_array();
boost::python::numeric::array::set_module_and_type("numpy", "ndarray");
class_<Spline, Spline*>("Spline", init<>())
.def("spline", &Spline::spline)
;
}

Así que en Python puedes usar:

from Spline.Spline import *
operation = Spline()
value, error_ = operation.spline(np.array(your_x_array), np.array(your_y_array), 0.01)

Clase de cpp:

#define NUMBER_OF_SAMPLES 14
class Spline
{
public:
boost::python::list spline(numeric::array& x_val, numeric::array& y_val, double look_up_val);
};

Luego, en la función boost::python::list Spline::spline(numeric::array& x_val, numeric::array& y_val, double p) obtienes:

PyArrayObject* x_pyArr = (PyArrayObject*)PyArray_FROM_O(x_val.ptr());
PyArrayObject* y_pyArr = (PyArrayObject*)PyArray_FROM_O(y_val.ptr());
int size = *(x_pyArr->dimensions), i , j;
double* data_x = (double*)x_pyArr->data;
double* data_y = (double*)y_pyArr->data;
double h[NUMBER_OF_SAMPLES], a, b, c, d, s[NUMBER_OF_SAMPLES] = { 0 }, F[NUMBER_OF_SAMPLES], f[NUMBER_OF_SAMPLES], x[NUMBER_OF_SAMPLES], m[NUMBER_OF_SAMPLES][NUMBER_OF_SAMPLES] = { 0 }, temp;
for (int i = 0; i < size; i++)
{
x[i] = *(data_x + i);
f[i] = *(data_y + i);
}

Y así sucesivamente según el código en el enlace. Devuelvo una lista de python en mi función Spline::spline :

boost::python::list return_val;
// ....
return_val.append(sum);
return_val.append(result);
return return_val;

Answer 2

Me gustaría echar un vistazo a la documentación de scipy y buscar allí las funciones que está intentando aplicar.