cpp_module.cpp

#define PY_SSIZE_T_CLEAN
#include <Python.h>

#include <iostream>
#include <stdexcept>
#include <vector>

#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include "numpy/arrayobject.h"

#include <opencv2/opencv.hpp>

extern "C" {

// Simple addition test function (return = in1 + in2)
static PyObject* test_func(PyObject* self, PyObject* args) {
    int input1, input2;
    if (!PyArg_ParseTuple(args, "ii", &input1, &input2)) {      // Arguments are 2 integer values ("ii")
        return nullptr;
    }
    PyObject *return_value = PyLong_FromLong(input1 + input2);  // Create object to return
    return return_value;
}

// Simple image processing function (Inverse image color)
static PyObject* test_image_processing(PyObject* self, PyObject* args) {
    PyArrayObject* input_image;
    PyObject* output_image;
    if(!PyArg_ParseTuple(args, "O!", &PyArray_Type, &input_image)) {            // Argument is an Numpy array object
        return nullptr;
    }
    output_image = PyArray_NewLikeArray(input_image, NPY_ANYORDER, NULL, 0);    // Create object to return

    int ndim = PyArray_NDIM(input_image);                           // Number of dimensions of the input Numpy array
    npy_intp *shape;
    shape = PyArray_SHAPE(input_image);                             // Shape of the input Numpy array (npy_intp[])

    // Obtain data buffer pointers
    char* in_buf  = static_cast<char*>(PyArray_DATA(input_image));   // PyArray_DATA() will return void*
    char* out_buf = static_cast<char*>(PyArray_DATA(reinterpret_cast<PyArrayObject*>(output_image)));

    // Image processing
    size_t C = shape[2];
    size_t W = shape[1];
    size_t H = shape[0];
    for(size_t y=0; y<H; y++) {
        for(size_t x=0; x<W; x++){
            for(size_t c=0; c<C; c++) {
                out_buf[y*W*C + x*C + c] = 255 - in_buf[y*W*C + x*C + c];
            }
        }
    }

    return output_image;    // Returned object must exist after exiting of this C++ function
}

// Simple image processing function using OpenCV (Canny edge detection)
static PyObject* test_image_processing_OCV(PyObject* self, PyObject* args) {
    PyArrayObject* input_image;
    int th1, th2;               // Threshold value for Canny edge detection
    if(!PyArg_ParseTuple(args, "O!ii", &PyArray_Type, &input_image, &th1, &th2)) {  // 3 arguments (Numpy obj, int, int)
        return nullptr;
    }

    npy_intp* shape = PyArray_SHAPE(input_image);

    char* in_buf = static_cast<char*>(PyArray_DATA(input_image));          // PyArray_DATA() will return void*

    // Image processing with OpenCV
    cv::Mat in_mat(shape[0] /*Width(rows)*/, shape[1] /*Height(cols)*/, CV_8UC3, in_buf);   // Input cv::Mat generated from input Numpy object
    cv::Mat out_mat;                                    // Mat object to store final image
    cv::Mat channels[3];                                // Mat object for channel extraction
    cv::cvtColor(in_mat, in_mat, cv::COLOR_BGR2GRAY);   // Color -> Gray scale
    cv::split(in_mat, channels);                        // Channel extraction. packed BGR -> [B, G, R]
    cv::Canny(channels[0], out_mat, th1, th2);          // Canny edge detection

    npy_intp out_shape[] = { out_mat.rows, out_mat.cols, out_mat.channels() };
    PyObject* result = PyArray_SimpleNew(3, out_shape, NPY_UINT8);                              // Create a Numpy object to return
    char* out_buf = static_cast<char*>(PyArray_DATA(reinterpret_cast<PyArrayObject*>(result))); // Obtain data buffer pointer of the final image
    memcpy(out_buf, out_mat.data, out_shape[0] * out_shape[1] * out_shape[2]);                  // Copy data buffer

    return result;          // Return created Numpy object
}

// Numpy array attribute extraction test function
static PyObject* npy_array_test(PyObject* self, PyObject* args) {
    PyArrayObject* input_image;

    if(!PyArg_ParseTuple(args, "O!", &PyArray_Type, &input_image)) {        // Argument is a Numpy object
        return nullptr;
    }

    size_t ndims = PyArray_NDIM(input_image);                               // Number of dimensions
    std::cout << "#Dims: " << PyArray_NDIM(input_image) << std::endl;

    npy_intp* shape = PyArray_SHAPE(input_image);                           // Shape
    for(size_t i=0; i<ndims; i++) {
        std::cout << "Dim" << i << ": " << shape[i] << std::endl;
    }
    std::cout << "NpyType: " << PyArray_TYPE(input_image) << std::endl;         // Numpy data type
    std::cout << "ItemSize: " << PyArray_ITEMSIZE(input_image) << std::endl;    // Size of item (element)
    std::cout << "TotalSize: " << PyArray_SIZE(input_image) << std::endl;       // Total size (in size of item)
    std::cout << "TotalBytes: " << PyArray_NBYTES(input_image) << std::endl;    // Total bytes
    uint8_t* buffer = static_cast<uint8_t*>(PyArray_DATA(input_image));         // PyArray_DATA() will return void*

    // Show first 10 items of the Numpy array
    int bytes = PyArray_NBYTES(input_image);
    int disp_size = bytes<10 ? bytes : 10;
    for(size_t i=0; i<disp_size; i++) {
        std::cout << (int)buffer[i] << " ";
    }
    std::cout << std::endl;

    return PyLong_FromLong(0);
}

// Function definition table to export to Python
PyMethodDef method_table[] = {
    {"test_func", static_cast<PyCFunction>(test_func), METH_VARARGS, "test method function of test module"},
    {"test_image_processing", static_cast<PyCFunction>(test_image_processing), METH_VARARGS, "test image processing function"},
    {"test_image_processing_OCV", static_cast<PyCFunction>(test_image_processing_OCV), METH_VARARGS, "test image processing function"},
    {"npy_array_test", static_cast<PyCFunction>(npy_array_test), METH_VARARGS, "test numpy array handling test"},
    {NULL, NULL, 0, NULL}
};

// Module definition table
PyModuleDef test_module = {
    PyModuleDef_HEAD_INIT,
    "python_cpp_module",
    "test module",
    -1,
    method_table
};

// Initialize and register module function
// Function name must be 'PyInit_'+module name
// This function must be the only *non-static* function in the source code
PyMODINIT_FUNC PyInit_python_cpp_module(void) {
    import_array();                                 // Required to receive Numpy object as arguments
    if (PyErr_Occurred()) {
        return nullptr;
    }
    return PyModule_Create(&test_module);
}

} // extern "C"