larcv::convert::NDArrayConverter Class Reference

#include <NDArrayConverter.h>

Public Member Functions
	NDArrayConverter ()
::cv::Mat	toMat (const PyObject *o)
PyObject *	toNDArray (const ::cv::Mat &mat)
PyObject *	toNDArray (const ::larcv::Image2D &img)
PyObject *	toNDArray (const ::larcv::Point2DArray &pt_v)

Private Member Functions
void	init ()

Detailed Description

Definition at line 65 of file NDArrayConverter.h.

Constructor & Destructor Documentation

larcv::convert::NDArrayConverter::NDArrayConverter

(

)

Definition at line 200 of file NDArrayConverter.cxx.

References init().

{ init(); }

Member Function Documentation

void larcv::convert::NDArrayConverter::init ( )

private

Definition at line 202 of file NDArrayConverter.cxx.

Referenced by NDArrayConverter().

    {
      import_array();
    }

cv::Mat larcv::convert::NDArrayConverter::toMat

(

const PyObject *

o)

Definition at line 207 of file NDArrayConverter.cxx.

References larcv::convert::failmsg(), larcv::convert::g_numpyAllocator, and larcv::convert::refcountFromPyObject().

    {
      ::cv::Mat m;
      
      if(!o || o == Py_None)
    {
      if( !m.data )
        m.allocator = &g_numpyAllocator;
    }
      
      if( !PyArray_Check(o) )
    {
      failmsg("toMat: Object is not a numpy array");
    }
      
      int typenum = PyArray_TYPE(o);
      int type = typenum == NPY_UBYTE ? CV_8U : typenum == NPY_BYTE ? CV_8S :
    typenum == NPY_USHORT ? CV_16U : typenum == NPY_SHORT ? CV_16S :
    typenum == NPY_INT || typenum == NPY_LONG ? CV_32S :
    typenum == NPY_FLOAT ? CV_32F :
    typenum == NPY_DOUBLE ? CV_64F : -1;
      
      if( type < 0 )
    {
      failmsg("toMat: Data type = %d is not supported", typenum);
    }
      
      int ndims = PyArray_NDIM(o);
      
      if(ndims >= CV_MAX_DIM)
    {
      failmsg("toMat: Dimensionality (=%d) is too high", ndims);
    }
      
      int size[CV_MAX_DIM+1];
      size_t step[CV_MAX_DIM+1], elemsize = CV_ELEM_SIZE1(type);
      const npy_intp* _sizes = PyArray_DIMS(o);
      const npy_intp* _strides = PyArray_STRIDES(o);
      bool transposed = false;
      
      for(int i = 0; i < ndims; i++)
    {
      size[i] = (int)_sizes[i];
      step[i] = (size_t)_strides[i];
    }
      
      if( ndims == 0 || step[ndims-1] > elemsize ) {
    size[ndims] = 1;
    step[ndims] = elemsize;
    ndims++;
      }
      
      if( ndims >= 2 && step[0] < step[1] )
    {
      std::swap(size[0], size[1]);
      std::swap(step[0], step[1]);
      transposed = true;
    }
      
      // std::cerr << " ndims: " << ndims
      //           << " size: " << size
      //           << " type: " << type
      //           << " step: " << step
      //           << " size: " << size[2] << std::endl;
      
      // TODO: Possible bug in multi-dimensional matrices
#if 0
      if( ndims == 3 && size[2] <= CV_CN_MAX && step[1] == elemsize*size[2] )
    {
      ndims--;
      type |= CV_MAKETYPE(0, size[2]);
    }
#endif
      
      if( ndims > 2)
    {
      failmsg("toMat: Object has more than 2 dimensions");
    }
      
      m = ::cv::Mat(ndims, size, type, PyArray_DATA(o), step);
      // m.u = g_numpyAllocator.allocate(o, ndims, size, type, step);
      
      if( m.data )
    {
#if OPENCV_3
      m.addref();
      Py_INCREF(o);
#else
      m.refcount = refcountFromPyObject(o);
      m.addref(); // protect the original numpy array from deallocation
      // (since Mat destructor will decrement the reference counter)
#endif
    };
      m.allocator = &g_numpyAllocator;
      
      if( transposed )
    {
      ::cv::Mat tmp;
      tmp.allocator = &g_numpyAllocator;
      transpose(m, tmp);
      m = tmp;
    }
      return m;
    }

PyObject * larcv::convert::NDArrayConverter::toNDArray

(

const ::cv::Mat &

mat)

Definition at line 312 of file NDArrayConverter.cxx.

References ERRWRAP2, larcv::convert::g_numpyAllocator, and larcv::convert::pyObjectFromRefcount().

Referenced by larlite::HitImageMaker::GetCanny(), and larlite::HitImageMaker::GetImage().

    {
#if OPENCV_3
      if( !m.data )
    Py_RETURN_NONE;
      ::cv::Mat temp, *p = (::cv::Mat*)&m;
      if(!p->u || p->allocator != &g_numpyAllocator)
    {
      temp.allocator = &g_numpyAllocator;
      m.copyTo(temp);
      p = &temp;
    }
      PyObject* o = (PyObject*)p->u->userdata;
      Py_INCREF(o);
      // p->addref();
      // pyObjectFromRefcount(p->refcount);
      return o;
#else
      if( !m.data )
    Py_RETURN_NONE;
      ::cv::Mat temp, *p = (::cv::Mat*)&m;
      if(!p->refcount || p->allocator != &g_numpyAllocator)
    {
      temp.allocator = &g_numpyAllocator;
      ERRWRAP2(m.copyTo(temp));
      p = &temp;
    }
      p->addref();
      return pyObjectFromRefcount(p->refcount);
#endif
    }

PyObject * larcv::convert::NDArrayConverter::toNDArray

(

const ::larcv::Image2D &

img)

Definition at line 344 of file NDArrayConverter.cxx.

    {
      return nullptr;
    }

PyObject * larcv::convert::NDArrayConverter::toNDArray

(

const ::larcv::Point2DArray &

pt_v)

Definition at line 348 of file NDArrayConverter.cxx.

    {
      int* dim_data = new int[2];
      dim_data[0] = 2;
      dim_data[1] = (int)(pt_v.size());

      return PyArray_FromDimsAndData( 2, dim_data, NPY_DOUBLE, (char*) &(pt_v._data[0]) );
    }

---

The documentation for this class was generated from the following files:

• NDArrayConverter.h
• NDArrayConverter.cxx