Initial implementation

Author: sfe-SparkFro

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "src/opencv"]
+	path = src/opencv
+	url = https://github.com/sfe-SparkFro/opencv.git
+[submodule "src/ulab"]
+	path = src/ulab
+	url = https://github.com/v923z/micropython-ulab.git
+[submodule "micropython"]
+	path = micropython
+	url = https://github.com/sparkfun/micropython.git

Makefile

@@ -0,0 +1,20 @@
+# Set Pico SDK flags to create our own malloc wrapper and enable exceptions
+CMAKE_ARGS += -DSKIP_PICO_MALLOC=1 -DPICO_CXX_ENABLE_EXCEPTIONS=1
+
+# Get current directory
+CURRENT_DIR = $(shell pwd)
+
+# Set the MicroPython user C module path to the OpenCV module
+MAKE_ARGS = USER_C_MODULES="$(CURRENT_DIR)/src/opencv_upy.cmake"
+
+# Build MicroPython with the OpenCV module
+all:
+	@cd micropython/ports/rp2 && export CMAKE_ARGS="$(CMAKE_ARGS)" && make -f Makefile $(MAKEFLAGS) $(MAKE_ARGS)
+
+# Clean the MicroPython build
+clean:
+	@cd micropython/ports/rp2 && make -f Makefile $(MAKEFLAGS) clean
+
+# Load the MicroPython submodules
+submodules:
+	@cd micropython/ports/rp2 && make -f Makefile $(MAKEFLAGS) submodules

micropython

@@ -0,0 +1,65 @@
+// C headers
+#include "py/runtime.h"
+
+// Hacky solution to see if the GC is initialized. If so, we can use gc_alloc
+// and gc_free. Otherwise, we need to use __real_malloc and __real_free.
+// TODO: Determine if this is acceptable or if we should use a different method.
+// Would be nice to be able to #define MICROPY_BOARD_EARLY_INIT to set a flag,
+// however that needs to be #defined in the board's mpconfigboard.h file.
+bool gc_inited() {
+    return MP_STATE_MEM(area).gc_pool_start != NULL;
+}
+
+// Since the linker flag `-Wl,--wrap=malloc` (and calloc, realloc, and free) is
+// set, calls to `malloc()` get replaced with `__wrap_malloc()` by the linker.
+// To use the original `malloc()`, we can instead use `__real_malloc()`, which
+// the linker replaces with the original `malloc()`. However because that's done
+// by the linker, we need to declare it here so the compiler knows about it.
+extern void *__real_malloc(size_t size);
+extern void *__real_calloc(size_t count, size_t size);
+extern void *__real_realloc(void *mem, size_t size);
+extern void *__real_free(void *mem);
+
+// Implementations of the malloc, calloc, realloc, and free functions. If the
+// GC is initialized, we use the MicroPython functions to use the GC heap.
+// Otherwise, we use the "real" functions to use the C heap.
+void *__wrap_malloc(size_t size) {
+    if(gc_inited()) {
+        return m_tracked_calloc(1, size);
+    }
+    else {
+        return __real_malloc(size);
+    }
+}
+void __wrap_free(void *ptr) {
+    if(gc_inited()) {
+        m_tracked_free(ptr);
+    }
+    else {
+        __real_free(ptr);
+    }
+}
+void *__wrap_calloc(size_t count, size_t size)
+{
+    if(gc_inited()) {
+        return m_tracked_calloc(count, size);
+    }
+    else {
+        return __real_calloc(count, size);
+    }
+}
+void *__wrap_realloc(void *ptr, size_t size)
+{
+    if(gc_inited()) {
+        void *new_ptr = m_tracked_calloc(1, size);
+        if (new_ptr == NULL) {
+            return NULL;
+        }
+        memcpy(new_ptr, ptr, size);
+        m_tracked_free(ptr);
+        return new_ptr;
+    }
+    else {
+        return __real_realloc(ptr, size);
+    }
+}

src/alloc.c

@@ -0,0 +1,149 @@
+// C++ headers
+#include "convert.h"
+#include "numpy.h"
+
+// C headers
+extern "C" {
+#include "ulab_tools.h"
+#include "py/obj.h"
+} // extern "C"
+
+uint8_t mat_depth_to_ndarray_type(int depth)
+{
+    switch (depth) {
+        case CV_8U: return NDARRAY_UINT8;
+        case CV_8S: return NDARRAY_INT8;
+        case CV_16U: return NDARRAY_UINT16;
+        case CV_16S: return NDARRAY_INT16;
+        case CV_32F: return NDARRAY_FLOAT;
+        // case CV_Bool: return NDARRAY_BOOL;
+        default: mp_raise_ValueError(MP_ERROR_TEXT("Unsupported Mat depth"));
+    }
+}
+
+int ndarray_type_to_mat_depth(uint8_t type)
+{
+    switch (type) {
+        case NDARRAY_UINT8: return CV_8U;
+        case NDARRAY_INT8: return CV_8S;
+        case NDARRAY_UINT16: return CV_16U;
+        case NDARRAY_INT16: return CV_16S;
+        case NDARRAY_FLOAT: return CV_32F;
+        // case NDARRAY_BOOL: return CV_Bool;
+        default: mp_raise_ValueError(MP_ERROR_TEXT("Unsupported ndarray type"));
+    }
+}
+
+ndarray_obj_t *mat_to_ndarray(Mat& mat)
+{
+    // Derived from:
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L313-L328
+    if(mat.data == NULL)
+        mp_const_none;
+    Mat temp, *ptr = (Mat*)&mat;
+    if(!ptr->u || ptr->allocator != &GetNumpyAllocator())
+    {
+        temp.allocator = &GetNumpyAllocator();
+        mat.copyTo(temp);
+        ptr = &temp;
+    }
+    ndarray_obj_t* ndarray = (ndarray_obj_t*) ptr->u->userdata;
+    return ndarray;
+}
+
+Mat ndarray_to_mat(ndarray_obj_t *ndarray)
+{
+    // Derived from:
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L54-L311
+    // Some steps are skipped, as they are not needed or handle extreme edge
+    // cases. Skipping these steps helps keep the code smaller and run faster.
+
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L56-L119
+    // We have an ndarray_obj_t, so these checks have already been done.
+
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L130-L172
+    int type = ndarray_type_to_mat_depth(ndarray->dtype);
+
+    int ndims = ndarray->ndim;
+    size_t elemsize = ndarray->itemsize;
+    int _sizes[ndarray->ndim];
+    size_t _strides[ndarray->ndim];
+    for (int i = 0; i < ndarray->ndim; i++) {
+        _sizes[i] = ndarray->shape[ULAB_MAX_DIMS - ndarray->ndim + i];
+        _strides[i] = ndarray->strides[ULAB_MAX_DIMS - ndarray->ndim + i];
+    }
+
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L176-L221
+    bool ismultichannel = ndims == 3;
+
+    if (ismultichannel)
+    {
+        int channels = ndims >= 1 ? (int)_sizes[ndims - 1] : 1;
+        ndims--;
+        type |= CV_MAKETYPE(0, channels);
+        elemsize = CV_ELEM_SIZE(type);
+    }
+
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L243-L261
+    int size[CV_MAX_DIM+1] = {};
+    size_t step[CV_MAX_DIM+1] = {};
+
+    size_t default_step = elemsize;
+    for ( int i = ndims - 1; i >= 0; --i )
+    {
+        size[i] = (int)_sizes[i];
+        if ( size[i] > 1 )
+        {
+            step[i] = (size_t)_strides[i];
+            default_step = step[i] * size[i];
+        }
+        else
+        {
+            step[i] = default_step;
+            default_step *= size[i];
+        }
+    }
+
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L290-L294
+    if( ndims == 0) {
+        size[ndims] = 1;
+        step[ndims] = elemsize;
+        ndims++;
+    }
+
+    // https://github.com/opencv/opencv/blob/aee828ac6ed3e45d7ca359d125349a570ca4e098/modules/python/src2/cv2_convert.cpp#L300-L10
+    Mat mat = Mat(ndims, size, type, (void*) ndarray->array, step);
+    mat.u = GetNumpyAllocator().allocate(ndarray, ndims, size, type, step);
+    mat.addref();
+
+    mat.allocator = &GetNumpyAllocator();
+
+    return mat;
+}
+
+mp_obj_t mat_to_mp_obj(Mat &mat)
+{
+    return MP_OBJ_FROM_PTR(mat_to_ndarray(mat));
+}
+
+Mat mp_obj_to_mat(mp_obj_t obj)
+{
+    // Check for None object
+    if(obj == mp_const_none)
+    {
+        // Create an empty Mat object. Set the NumpyAllocator in case this
+        // matrix gets automatically allocated later
+        Mat mat;
+        mat.allocator = &GetNumpyAllocator();
+        return mat;
+    }
+
+    // Assume the object is a ndarray, or can be converted to one. Will raise an
+    // exception if not
+    ndarray_obj_t *ndarray = ndarray_from_mp_obj(obj, 0);
+
+    // Convert ndarray to Mat
+    Mat mat = ndarray_to_mat(ndarray);
+
+    return mat;
+}

src/convert.cpp

@@ -0,0 +1,23 @@
+// C++ headers
+#include "opencv2/core.hpp"
+
+// C headers
+extern "C" {
+#include "py/runtime.h"
+#include "ulab/code/ndarray.h"
+} // extern "C"
+
+using namespace cv;
+
+// Conversion functions between Mat depth and ndarray_obj_t type
+uint8_t mat_depth_to_ndarray_type(int depth);
+int ndarray_type_to_mat_depth(uint8_t type);
+
+// Converstion functions between Mat and ndarray_obj_t
+ndarray_obj_t *mat_to_ndarray(Mat &mat);
+Mat ndarray_to_mat(ndarray_obj_t *ndarray);
+
+// Conversion functions  between Mat and mp_obj_t. Abstracts away intermediate
+// conversions to ndarray_obj_t
+mp_obj_t mat_to_mp_obj(Mat &mat);
+Mat mp_obj_to_mat(mp_obj_t obj);

src/convert.h

@@ -0,0 +1,101 @@
+// C++ headers
+#include "opencv2/core.hpp"
+#include "convert.h"
+#include "numpy.h"
+
+// C headers
+extern "C" {
+#include "core.h"
+#include "ulab/code/ndarray.h"
+} // extern "C"
+
+using namespace cv;
+
+mp_obj_t cv2_core_inRange(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // Define the arguments
+    enum { ARG_src, ARG_lower, ARG_upper, ARG_dst };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_src, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_lower, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_upper, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_dst, MP_ARG_OBJ, { .u_obj = mp_const_none } },
+    };
+
+    // Parse the arguments
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // Convert arguments to required types
+    Mat src = mp_obj_to_mat(args[ARG_src].u_obj);
+    Mat lower = mp_obj_to_mat(args[ARG_lower].u_obj);
+    Mat upper = mp_obj_to_mat(args[ARG_upper].u_obj);
+    Mat dst = mp_obj_to_mat(args[ARG_dst].u_obj);
+
+    // Call the corresponding OpenCV function
+    try {
+        inRange(src, lower, upper, dst);
+    } catch(Exception& e) {
+        mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT(e.what()));
+    }
+
+    // Return the result
+    return mat_to_mp_obj(dst);
+}
+
+mp_obj_t cv2_core_max(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // Define the arguments
+    enum { ARG_src1, ARG_src2, ARG_dst };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_src1, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_src2, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_dst, MP_ARG_OBJ, { .u_obj = mp_const_none } },
+    };
+
+    // Parse the arguments
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // Convert arguments to required types
+    Mat src1 = mp_obj_to_mat(args[ARG_src1].u_obj);
+    Mat src2 = mp_obj_to_mat(args[ARG_src2].u_obj);
+    Mat dst = mp_obj_to_mat(args[ARG_dst].u_obj);
+
+    // Call the corresponding OpenCV function
+    try {
+        max(src1, src2, dst);
+    } catch(Exception& e) {
+        mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT(e.what()));
+    }
+    
+    // Return the result
+    return mat_to_mp_obj(dst);
+}
+
+mp_obj_t cv2_core_min(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // Define the arguments
+    enum { ARG_src1, ARG_src2, ARG_dst };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_src1, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_src2, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_dst, MP_ARG_OBJ, { .u_obj = mp_const_none } },
+    };
+
+    // Parse the arguments
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // Convert arguments to required types
+    Mat src1 = mp_obj_to_mat(args[ARG_src1].u_obj);
+    Mat src2 = mp_obj_to_mat(args[ARG_src2].u_obj);
+    Mat dst = mp_obj_to_mat(args[ARG_dst].u_obj);
+
+    // Call the corresponding OpenCV function
+    try {
+        min(src1, src2, dst);
+    } catch(Exception& e) {
+        mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT(e.what()));
+    }
+
+    // Return the result
+    return mat_to_mp_obj(dst);
+}

src/core.cpp

@@ -0,0 +1,6 @@
+// C headers
+#include "py/runtime.h"
+
+extern mp_obj_t cv2_core_inRange(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t cv2_core_max(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t cv2_core_min(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);