Swig C ++: vector de interfaz <objeto de clase *>


8

básicamente estoy tratando de tener una tupla / lista que contenga un diccionario de diferentes tipos de datos de valores (float / int / bool / char / list) en python.

Estoy obteniendo esto del siguiente código:

(<f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f4954bdde10> >, <f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f4954bdde40> >, <f_p.Bunch; proxy of <Swig Object of type 'Bunch
*' at 0x7f495668be70> >, <f_p.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x7f4952d09a50> >)

Quiero obtener el resultado de esta forma:

({'I': 1.0, 'B': 2.0, 'C': 3.0, 'dert _': [1.2, 2.3, 3.4, 4.5, 5.6]})

No puedo tratar con este puntero de objeto de clase (grupo *) y no pude encontrar ninguna solución. Miré en la red pero no pude encontrar una solución que funcionara para mi caso.

f_p.cpp:

#include <iostream>
#include "f_p.h"
#define CPP_14 0

std::vector<Bunch*> form_p(const double *array, int x, int y)  {

    std::vector<Bunch*> v;
    Bunch *b1 = new Bunch(5);
    b1->set_I_B_C(1.0, 2.0, 3.0);
    b1->set_dert_({1.2, 2.3, 3.4, 4.5, 5.6});

    float *_dert = b1->get_dert_();
    for(int i=0; i<5; i++) {
        std::cout << _dert[i] << std::endl;
    }

    v.push_back(b1);
    v.push_back(b1); 
    v.push_back(b1); 
    v.push_back(b1); 

    return v;
}

f_p.h:

#ifndef F_P_H
#define f_P_H
#include <memory> 
#include <vector>
#include <memory> 
#include <algorithm>
#include <tuple>
#include <initializer_list>

class Bunch {
    private:
        unsigned int start;
        unsigned int end;
        float I;
        float B;
        float C;
        bool isPos;
        std::unique_ptr<float[]> dert_;
    public:

        explicit Bunch(size_t width) {
            #if CPP_14
            this->dert_ = std::make_unique<float[]>(width);
            #else
            this->dert_ = std::unique_ptr<float[]>(new float[width]);
            #endif
            std::fill_n(this->dert_.get(), width, -1.0);
        }

        void set_I_B_C(float I, float B, float C) {
            this->I = I;
            this->B = B;
            this->C = C;
        }

        std::tuple<float, float, float> get_I_B_C() const {
            return std::make_tuple(this->I, this->B, this->C);
        }

        float* get_dert_() const {
            return this->dert_.get();
        }

        void set_dert_(std::initializer_list<float> l) {
            int i = 0;
            for (auto e: l){
                dert_[i++] = e;
            }
        }
};
/* Define function prototype */
std::vector<Bunch*> form_p(const double *array, int x, int y)  ;
#endif

f_p.i:

%module f_p
#define SWIGPYTHON_BUILTIN

%{
  #include "numpy/arrayobject.h"
  #define SWIG_FILE_WITH_INIT  /* To import_array() below */
  #include "f_p.h"
%}
%include "std_map.i"
%import "std_deque.i" 
%import "std_vector.i" 

%template (mapiv) std::map<char,float>;
%template () std::vector<Bunch*>;
%include "numpy.i"

%init %{
import_array();
%}

%apply (double* IN_ARRAY2, int DIM1, int DIM2) {
  (const double* array, int x, int y)
}

%include "f_p.h"

build.sh:

rm *.o f_p_wrap.cpp _f_p.so f_p.py
rm -rf __pycache__

g++ -O3 -march=native -fPIC -c f_p.cpp
swig -python -c++ -o f_p_wrap.cpp f_p.i

# Next, compile the wrapper code:

g++ -O3 -march=native -w -fPIC -c $(pkg-config --cflags --libs python3) -I /home/antpc/anaconda3/lib/python3.7/site-packages/numpy/core/include f_p.cpp f_p_wrap.cpp

g++ -std=c++11 -O3 -march=native -shared f_p.o f_p_wrap.o -o _f_p.so -lm

test_sample.py:

from f_p import form_p
import numpy as np
x = np.random.randn(3, 4)
print(form_p(x))

Modifiqué mi código stackoverflow.com/questions/59712985/… para trabajar con diferentes tipos de datos. Pero ahora no puede interactuar con él.
ninjakx

1
Parece que solo quieres crear un typemap(out)para Bunch. ¿Por qué form_pregresa en std::vector<Bunch *>lugar de std::vector<Bunch>? Swig no va a liberar esos punteros, por lo que estás perdiendo memoria.
Indiana Kernick

Si una respuesta ayudó a resolver su problema, entonces no deje que la recompensa se desperdicie
Indiana Kernick

@ Kerndog73: No sabía que solo otorga el 50% de la recompensa cuando no se elige y el resto se desperdicia.
ninjakx

Respuestas:


4

La pregunta realmente se reduce a esto: tienes una clase y te gustaría convertirla en un objeto nativo de Python (en lugar de un objeto envuelto). SWIG genera automáticamente objetos envueltos, pero debe hacer todo lo posible para convertir los tipos de C ++ a los tipos nativos de Python.


Supongo que esto se simplificó Bunchpara que el mapa de tipos sea un poco más legible. Deberías poder adaptar esto a tu con Bunchbastante facilidad. Alternativamente, puede convertir su clase a esta estructura simple antes de pasarla a Python.

struct Bunch {
    float i, b, c;
    std::vector<float> dert;
};

Bunch makeBunch();

Aquí está la implementación de makeBunch.

Bunch makeBunch() {
    return {1.0, 2.0, 3.0, {1.2, 2.3, 3.4, 4.5, 5.6}};
}

He omitido la comprobación de errores para que sea breve y conciso.

%typemap(out) Bunch {
    $result = PyDict_New();
    PyDict_SetItem($result, PyBytes_FromString("I"), PyFloat_FromDouble($1.i));
    PyDict_SetItem($result, PyBytes_FromString("B"), PyFloat_FromDouble($1.b));
    PyDict_SetItem($result, PyBytes_FromString("C"), PyFloat_FromDouble($1.c));
    PyObject *dert = PyList_New($1.dert.size());
    for (size_t i = 0; i != $1.dert.size(); ++i) {
        PyList_SetItem(dert, i, PyFloat_FromDouble($1.dert[i]));
    }
    PyDict_SetItem($result, PyBytes_FromString("dert_"), dert);
}

Cuando compilo y ejecuto esto yo mismo, obtengo los resultados esperados (bueno, ¡lo suficientemente cerca!).

>>> import test
>>> test.makeBunch()
{'I': 1.0, 'C': 3.0, 'B': 2.0, 'dert_': [1.2000000476837158, 2.299999952316284, 3.4000000953674316, 4.5, 5.599999904632568]}

El mapa de tipos no es estrictamente necesario. En su lugar, solo puede usar objetos envueltos. Elimine el mapa de tipo y asegúrese de exponerlo std::vector<float>así.

%include "std_vector.i"
%template(FloatVector) std::vector<float>;

Luego puede acceder a Bunchtravés de un objeto envuelto.

>>> import test
>>> bunch = test.makeBunch()
>>> bunch
<test.Bunch; proxy of <Swig Object of type 'Bunch *' at 0x10b6daba0> >
>>> bunch.i
1.0
>>> bunch.b
2.0
>>> bunch.c
3.0
>>> bunch.dert
<test.FloatVector; proxy of <Swig Object of type 'std::vector< float,std::allocator< float > > *' at 0x10b6dadb0> >
>>> for d in bunch.dert:
...     print(d)
...
1.20000004768
2.29999995232
3.40000009537
4.5
5.59999990463

Algunas fuentes acreditadas:


¿Puedes responder a esta pregunta? Stackoverflow.com/questions/59712985/… la respuesta para eso también es la misma que esta. Quiero cerrar esa pregunta.
ninjakx

@ninjakx Si desea cerrar esa pregunta, simplemente ciérrela (o elimínela).
Indiana Kernick
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.