Add more contour functions

Author: sfe-SparkFro

src/convert.cpp

@@ -201,6 +201,61 @@ Size mp_obj_to_size(mp_obj_t obj)
     return size;
 }
 
+Size2f mp_obj_to_size2f(mp_obj_t obj)
+{
+    // Check for None object
+    if(obj == mp_const_none)
+    {
+        // Create an empty Size2f object
+        return Size2f();
+    }
+
+    // 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);
+    
+    // Validate the length of the ndarray
+    if(ndarray->len != 2)
+    {
+        mp_raise_TypeError(MP_ERROR_TEXT("Size2f must be length 2"));
+    }
+
+    // Compute the size, checking the type of the ndarray
+    Size2f size;
+    switch(ndarray->dtype)
+    {
+        case NDARRAY_UINT8:
+            size.width = ((uint8_t*) ndarray->array)[0];
+            size.height = ((uint8_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_INT8:
+            size.width = ((int8_t*) ndarray->array)[0];
+            size.height = ((int8_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_UINT16:
+            size.width = ((uint16_t*) ndarray->array)[0];
+            size.height = ((uint16_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_INT16:
+            size.width = ((int16_t*) ndarray->array)[0];
+            size.height = ((int16_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_FLOAT:
+            size.width = ((float*) ndarray->array)[0];
+            size.height = ((float*) ndarray->array)[1];
+            break;
+        case NDARRAY_BOOL:
+            size.width = ((bool*) ndarray->array)[0];
+            size.height = ((bool*) ndarray->array)[1];
+            break;
+        default:
+            mp_raise_TypeError(MP_ERROR_TEXT("Unsupported ndarray type"));
+            break;
+    }
+
+    return size;
+}
+
 Point mp_obj_to_point(mp_obj_t obj)
 {
     // Check for None object
@@ -256,6 +311,61 @@ Point mp_obj_to_point(mp_obj_t obj)
     return point;
 }
 
+Point2f mp_obj_to_point2f(mp_obj_t obj)
+{
+    // Check for None object
+    if(obj == mp_const_none)
+    {
+        // Create an empty Point2f object
+        return Point2f();
+    }
+
+    // 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);
+
+    // Validate the length of the ndarray
+    if(ndarray->len != 2)
+    {
+        mp_raise_TypeError(MP_ERROR_TEXT("Point2f must be length 2"));
+    }
+
+    // Compute the point, checking the type of the ndarray
+    Point2f point;
+    switch(ndarray->dtype)
+    {
+        case NDARRAY_UINT8:
+            point.x = ((uint8_t*) ndarray->array)[0];
+            point.y = ((uint8_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_INT8:
+            point.x = ((int8_t*) ndarray->array)[0];
+            point.y = ((int8_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_UINT16:
+            point.x = ((uint16_t*) ndarray->array)[0];
+            point.y = ((uint16_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_INT16:
+            point.x = ((int16_t*) ndarray->array)[0];
+            point.y = ((int16_t*) ndarray->array)[1];
+            break;
+        case NDARRAY_FLOAT:
+            point.x = ((float*) ndarray->array)[0];
+            point.y = ((float*) ndarray->array)[1];
+            break;
+        case NDARRAY_BOOL:
+            point.x = ((bool*) ndarray->array)[0];
+            point.y = ((bool*) ndarray->array)[1];
+            break;
+        default:
+            mp_raise_TypeError(MP_ERROR_TEXT("Unsupported ndarray type"));
+            break;
+    }
+
+    return point;
+}
+
 Scalar mp_obj_to_scalar(mp_obj_t obj)
 {
     // Check for None object

src/convert.h

@@ -24,9 +24,11 @@ Mat mp_obj_to_mat(mp_obj_t obj);
 
 // Conversion functions between Size and mp_obj_t
 Size mp_obj_to_size(mp_obj_t obj);
+Size2f mp_obj_to_size2f(mp_obj_t obj);
 
 // Conversion functions between Point and mp_obj_t
 Point mp_obj_to_point(mp_obj_t obj);
+Point2f mp_obj_to_point2f(mp_obj_t obj);
 
 // Conversion functions between Scalar and mp_obj_t
 Scalar mp_obj_to_scalar(mp_obj_t obj);

src/core.cpp

@@ -122,3 +122,47 @@ mp_obj_t cv2_core_inRange(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_
     // Return the result
     return mat_to_mp_obj(dst);
 }
+
+mp_obj_t cv2_core_minMaxLoc(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // Define the arguments
+    enum { ARG_src, ARG_mask };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_src, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { MP_QSTR_mask, 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 mask = mp_obj_to_mat(args[ARG_mask].u_obj);
+
+    double minVal, maxVal;
+    Point minLoc, maxLoc;
+
+    // Call the corresponding OpenCV function
+    try {
+        minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, mask);
+    } catch(Exception& e) {
+        mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT(e.what()));
+    }
+
+    // Return the result
+    mp_obj_t min_loc_tuple[2] = {
+        mp_obj_new_float(minLoc.x),
+        mp_obj_new_float(minLoc.y)
+    };
+    mp_obj_t max_loc_tuple[2] = {
+        mp_obj_new_float(maxLoc.x),
+        mp_obj_new_float(maxLoc.y)
+    };
+    mp_obj_t result_tuple[4] = {
+        mp_obj_new_float(minVal),
+        mp_obj_new_float(maxVal),
+        mp_obj_new_tuple(2, min_loc_tuple),
+        mp_obj_new_tuple(2, max_loc_tuple)
+    };
+    return mp_obj_new_tuple(4, result_tuple);
+}

src/core.h

@@ -4,16 +4,19 @@
 // Function declarations
 extern mp_obj_t cv2_core_convertScaleAbs(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
 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_minMaxLoc(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
 
 // Python references to the functions
 static MP_DEFINE_CONST_FUN_OBJ_KW(cv2_core_convertScaleAbs_obj, 1, cv2_core_convertScaleAbs);
 static MP_DEFINE_CONST_FUN_OBJ_KW(cv2_core_inRange_obj, 3, cv2_core_inRange);
+static MP_DEFINE_CONST_FUN_OBJ_KW(cv2_core_minMaxLoc_obj, 1, cv2_core_minMaxLoc);
 
 // Global definitions for functions and constants
 #define OPENCV_CORE_GLOBALS \
     /* Functions */ \
     { MP_ROM_QSTR(MP_QSTR_convertScaleAbs), MP_ROM_PTR(&cv2_core_convertScaleAbs_obj) }, \
     { MP_ROM_QSTR(MP_QSTR_inRange), MP_ROM_PTR(&cv2_core_inRange_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_minMaxLoc), MP_ROM_PTR(&cv2_core_minMaxLoc_obj) }, \
     \
     /* OpenCV data types, from opencv2/core/hal/interface.h */ \
     /* Other types are currently not supported by ulab */ \