Come si usano le spline in pythonOCC?

Question

Ho una domanda in due parti su come utilizzare le spline in pythonOCC.

In primo luogo, so che posso creare 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) 

E mi aspetto che il BSPLINE può essere calcolato

BSPL1  = Geom2dAPI_PointsToBSpline(pt2d_list) 

Ma come faccio ad avere:

1. La derivata della bspline?
2. I nodi del bspline?
3. I nodi sono pt2d_list?
4. I punti di controllo del bspline?
5. I coefficienti della spline?

E come rimuovere o aggiungere nodi alla bspline?

In secondo luogo, quando si carica un file CAD di disegno stp in pythonOCC come questo:

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

Come posso ottenere i dati fuori dalla forma come nodo, BSPLINE, e coefficienti.

Answer 1

Vorrei dare un'occhiata a scipy documentation e cercare lì le funzioni che stai tentando di applicare.

Answer 2

Ho usato il python-boost fare questo. Dai un'occhiata a questa funzione: http://letslearncomputing.blogspot.com/2013/04/c-program-for-cubic-spline-interpolation.html Puoi ottenere qui alcuni dei 5 valori desiderati.

Hai solo bisogno di modificare il codice per essere C++ (non 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) 
     ; 
} 

Così in Python è possibile utilizzare: classe

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

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); 
}; 

Poi nella funzione boost::python::list Spline::spline(numeric::array& x_val, numeric::array& y_val, double p) è possibile ottenere:

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); 
} 

E così via secondo il codice in collegamento. Ritorna una lista python nella mia funzione Spline::spline:

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