Swig C ++: vetor de interface <Objeto de classe *>

8

Basicamente, estou tentando ter uma tupla / lista que contém um dicionário de diferentes tipos de dados de valores (float / int / bool / char / list) em python.

Estou recebendo isso do seguinte 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> >)

Eu quero obter a saída neste formulário:

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

Não consigo lidar com esse ponteiro de objeto de classe (monte *) e não consegui encontrar nenhuma solução para ele. Procurei na net, mas não consegui encontrar uma solução para o meu 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))
ninjakx
fonte
Modifiquei meu código stackoverflow.com/questions/59712985/… para trabalhar com diferentes tipos de dados. Mas agora não é possível fazer a interface.
ninjakx 16/01
1
Parece que você deseja apenas criar um typemap(out)para Bunch. Por que form_pretornar em std::vector<Bunch *>vez de std::vector<Bunch>? Swig não vai liberar esses ponteiros, então você está vazando memória.
Indiana Kernick 22/01
Se uma resposta ajudou a resolver o seu problema, então não deixe a recompensa desperdiçar
Indiana Kernick 26/01
@ Kerndog73: Eu não sabia que ele concede apenas 50% da recompensa quando não escolhido e o resto é desperdiçado.
ninjakx 27/01

Respostas:

4

A questão realmente se resume a isso: você tem uma classe e gostaria de convertê-la em um objeto Python nativo (em vez de um objeto encapsulado). O SWIG gera automaticamente objetos quebrados, mas você precisa fazer o possível para converter tipos C ++ em tipos nativos de Python.


Suponho que isso seja simplificado Bunchpara tornar o mapa de tipos um pouco mais legível. Você deve conseguir adaptar isso Bunchfacilmente ao seu . Como alternativa, você pode converter sua classe para essa estrutura simples antes de passá-la para o Python.

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

Bunch makeBunch();

Aqui está a implementação de makeBunch.

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

Omiti a verificação de erros para mantê-lo breve e 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);
}

Quando eu compilar e executar isso pessoalmente, obtenho os resultados esperados (bem, perto o suficiente!).

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

O mapa de tipos não é estritamente necessário. Você pode usar objetos quebrados. Remova o mapa de tipos e exponha std::vector<float>assim.

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

Então você pode acessar Bunchatravés de um objeto empacotado.

>>> 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

Algumas fontes respeitáveis:

Indiana Kernick
fonte
Você pode responder a esta pergunta: stackoverflow.com/questions/59712985/… a resposta para isso também é a mesma que esta. Eu quero fechar essa pergunta.
ninjakx 27/01
@ ninjakx Se você quiser fechar essa pergunta, basta fechá-la (ou excluí-la).
Indiana Kernick 27/01