Usar el agrupador opencv de python

Question

OpenCV se puede usar con los enlaces de python y funciona bastante bien. Sin embargo, me preguntaba (con la esperanza) si también es posible usar OpenCv's stitcher en python. Intenté varias cosas pero no pude hacer que funcionara. Si es posible, probablemente necesite hacer una importación adicional, pero no puedo resolverlo y Google tampoco me da la respuesta. Espero que haya un gurú de python abierto que pueda ayudarme.

Answer 1

Bien, entonces, lo descubrí finalmente. Hasta ahora solo he portado el método de puntadas con dos argumentos, pregúntame si tienes problemas para exponer cualquier otra cosa que necesites.

La manera más fácil de compilarlo es compilando todo de una manera independiente de la posición (opción -fPIC para gcc) en una biblioteca dinámica, mientras se enlazan las bibliotecas opencv_core y opencv_stitching. También deberá agregar el directorio de inclusión para la versión de python con la que esté compilando, para que pueda encontrar el encabezado Python.h correcto.

Si compila correctamente, podrá usar la biblioteca compilada de la misma manera que usaría un módulo de python.

Desafortunadamente, dado que no proporcionan acceso al constructor, tuve que conformarme con hacer una instancia global del asunto. Si hay otra forma elegante, soy todo oídos (ojos). Esto significa que cada vez que llame al constructor .Stitcher() devolverá la misma instancia (hay una separada que intenta usar GPU durante la construcción, use .Stitcher (True) para eso).

Aquí está mi archivo pythonPort.h:

/* 
* File: pythonPort.h 
* Author: algomorph 
* 
* Created on December 5, 2012, 10:18 AM 
*/ 

#ifndef PYTHONPORT_H 
#define PYTHONPORT_H 

#define MODULESTR "mycv" 


#include "Python.h" 
#include "numpy/ndarrayobject.h" 
#include <opencv2/core/core.hpp> 
#include <opencv2/stitching/stitcher.hpp> 
/* 
//include your own custom extensions here 
#include "savgol.h" 
#include "filters.hpp" 
*/ 
#include "pythonPortAux.h" 

#endif 

MODULESTR debe ser lo que quiera el nombre de su módulo. Lo he mantenido igual que el nombre de la biblioteca que compila.

Deberá copiar las rutinas opencv_to y opencv_from que necesite del archivo cv2.cpp y colocarlas en algo como mi pythonPortAux.h. El mío tiene muchas rutinas a partir de ahí, puedes encontrarlo at this link. MKTYPE2 macro también está allí.

El resto está aquí en el archivo pythonPort.cpp abajo (tengo otras cosas que hay, esto es sólo la parte Stitcher relevante):

#include "pythonPort.h" 

struct pycvex_Stitcher_t 
{ 
    PyObject_HEAD 
    Ptr<cv::Stitcher> v; 
}; 

static PyTypeObject pycvex_Stitcher_Type = 
{ 
    PyObject_HEAD_INIT(&PyType_Type) 
    0, 
    MODULESTR".Stitcher", 
    sizeof(pycvex_Stitcher_t), 
}; 

static void pycvex_Stitcher_dealloc(PyObject* self) 
{ 
    //((pycvex_Stitcher_t*)self)->v.release(); 
    PyObject_Del(self); 
} 

static PyObject* pyopencv_from(const Ptr<cv::Stitcher>& r) 
{ 
    pycvex_Stitcher_t *m = PyObject_NEW(pycvex_Stitcher_t, &pycvex_Stitcher_Type); 
    new (&(m->v)) Ptr<cv::Stitcher>(); // init Ptr with placement new 
    m->v = r; 
    return (PyObject*)m; 
} 

static bool pyopencv_to(PyObject* src, Ptr<cv::Stitcher>& dst, const char* name="<unknown>") 
{ 
    if(src == NULL || src == Py_None) 
     return true; 
    if(!PyObject_TypeCheck(src, &pycvex_Stitcher_Type)) 
    { 
     failmsg("Expected cv::Stitcher for argument '%s'", name); 
     return false; 
    } 
    dst = ((pycvex_Stitcher_t*)src)->v; 
    return true; 
} 

static PyObject* pycvex_Stitcher_repr(PyObject* self) 
{ 
    char str[1000]; 
    sprintf(str, "<Stitcher %p>", self); 
    return PyString_FromString(str); 
} 

Stitcher gStitcher = cv::Stitcher::createDefault(false); 
Stitcher gStitcherGPU = cv::Stitcher::createDefault(true); 

static PyObject* pycvex_Stitcher_Stitcher(PyObject* , PyObject* args, PyObject* kw) 
{ 
    PyErr_Clear(); 
    { 
     pycvex_Stitcher_t* self = 0; 
     bool try_use_gpu = false; 

     const char* keywords[] = { "img", "pt1", "pt2","connectivity","leftToRight", NULL }; 
     if (PyArg_ParseTupleAndKeywords(args, kw, "|b:Stitcher", 
       (char**) keywords, &try_use_gpu)){ 
      self = PyObject_NEW(pycvex_Stitcher_t, &pycvex_Stitcher_Type); 
      if (self) 
       ERRWRAP2(
         if(try_use_gpu) 
          self->v = &gStitcherGPU; 
         else 
          self->v = &gStitcher; 
         ); 
      return (PyObject*) self; 
     } 
    } 
    return NULL; 
} 
static PyGetSetDef pycvex_Stitcher_getseters[] = 
{ 
    {NULL} /* Sentinel */ 
}; 

static PyObject* pycvex_Stitcher_stitch(PyObject* self, PyObject* args, PyObject* kw){ 
    if(!PyObject_TypeCheck(self, &pycvex_Stitcher_Type)) 
     return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); 
    Stitcher* _self_ = ((pycvex_Stitcher_t*)self)->v; 
    //Stitcher::Status status; 
    int status; 

    PyObject* pyobj_images = NULL; 
    vector<Mat> images = vector<Mat>(); 
    Mat pano; 

    const char* keywords[] = { "images", NULL }; 
    if(PyArg_ParseTupleAndKeywords(args, kw, "O:Stitcher.stitch", (char**)keywords, &pyobj_images) && 
     pyopencv_to(pyobj_images, images, ArgInfo("images", false))) 
    { 
     ERRWRAP2(status = (int)_self_->stitch(images, pano)); 
     return Py_BuildValue("(NN)", pyopencv_from(status), pyopencv_from(pano)); 
    } 

    return NULL; 
} 

static PyMethodDef pycvex_Stitcher_methods[] = 
{ 
    {"stitch", (PyCFunction)pycvex_Stitcher_stitch, METH_KEYWORDS, "stitch(image) -> status, pano"}, 
    {NULL, NULL} 
}; 

static void pycvex_Stitcher_specials(void) 
{ 
    pycvex_Stitcher_Type.tp_base = NULL; 
    pycvex_Stitcher_Type.tp_dealloc = pycvex_Stitcher_dealloc; 
    pycvex_Stitcher_Type.tp_repr = pycvex_Stitcher_repr; 
    pycvex_Stitcher_Type.tp_getset = pycvex_Stitcher_getseters; 
    pycvex_Stitcher_Type.tp_methods = pycvex_Stitcher_methods; 
} 


static PyMethodDef methods[] = { 
    {"Stitcher",(PyCFunction)pycvex_Stitcher_Stitcher, METH_KEYWORDS, "Stitcher([tryUseGpu=False]) -> <Stitcher object>"}, 
    {NULL, NULL} 
}; 

extern "C"{ 
    #if defined WIN32 || defined _WIN32 
    __declspec(dllexport) 
    #endif 
    void initcvex() 
    { 
     MKTYPE2(Stitcher); 
     import_array(); 
     PyObject* m = Py_InitModule(MODULESTR, methods); 
     PyObject* d = PyModule_GetDict(m); 
     //PyDict_SetItemString(d, "__version__", PyString_FromString(CV_VERSION)) 
     opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL); 
     PyDict_SetItemString(d, "error", opencv_error); 
    } 
}