initial commit

Author: yas-sim

CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(python_cpp_module)
+
+find_package(OpenCV 4 REQUIRED COMPONENTS core imgproc highgui)
+find_package(PythonInterp 3.6 REQUIRED)
+find_package(PythonLibs "${PYTHON_VERSION_STRING}" EXACT REQUIRED)
+execute_process(
+    COMMAND "${PYTHON_EXECUTABLE}" -c "import numpy; print(numpy.get_include())"
+    OUTPUT_VARIABLE NUMPY_INCLUDE_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE NUMPY_NOT_FOUND
+)
+if(NUMPY_NOT_FOUND)
+    message(FATAL_ERROR "NumPy headers not found")
+endif()
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(target_name python_cpp_module)
+add_library(${target_name} MODULE cpp_module.cpp)
+
+target_include_directories(${target_name} PRIVATE src/ ${PYTHON_INCLUDE_DIRS} ${NUMPY_INCLUDE_DIR})
+target_link_libraries(${target_name} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_highgui)
+set_target_properties(${target_name} PROPERTIES PREFIX "")
+if(WIN32)
+    set_target_properties(${target_name} PROPERTIES SUFFIX ".pyd")
+endif()

README.md

@@ -0,0 +1,14 @@
+# Sample code of Python extension module
+
+### Description:  
+This project includes C++ Python extension module which handles Numpy objects. Numpy object and OpenCV Mat object interaction code example is also included.  
+
+![image](./resources/result.jpg)
+
+### How to build:
+```sh
+build.bat
+```
+
+### Note:  
+Tested on Win10 with MSVC 2019.

cpp_module.cpp

@@ -0,0 +1,144 @@
+#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;
+    }
+
+    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);
+}

resources/car_1.bmp

@@ -0,0 +1,27 @@
+# test.py
+
+from python_cpp_module import test_func, test_image_processing, npy_array_test, test_image_processing_OCV
+import numpy as np
+import cv2
+
+image_file = './resources/car_1.bmp'
+
+# Simple addition function test
+print(test_func(1,3))    # Anser should be 4.
+
+# Numpy array parameter extraction test
+a=np.zeros((480,640,3), dtype=np.uint8)
+a[0,0,0:3] = [5,6,7]
+npy_array_test(a)
+
+# Simple image processing test (inverse color)
+img = cv2.imread(image_file)
+cv2.imshow('input', img)
+img=test_image_processing(img)
+cv2.imshow('inversed', img)
+
+# Simple image processing test with OpenCV (Canny edge detection)
+img = cv2.imread(image_file)
+img = test_image_processing_OCV(img, 100, 200)
+cv2.imshow('Canny', img)
+cv2.waitKey(0)