GaussianBlur support

uccoder · May 24, 2021, 4:33pm

Do you have GaussianBlur implementation in omv/imglib?

kwagyeman · May 25, 2021, 12:04am

Yes, use the image — machine vision — MicroPython 1.15 documentation.

Please ask questions that you can’t google…

uccoder · May 25, 2021, 2:45am

Thank you…

As I mentioned in other topic, I was exploring it the native implementation openmv/src/omv/imlib at master · openmv/openmv · GitHub

I will go through the documentation & implementation to understand more. It seems it is micro python interface. I am trying to understand how this python code is mapping to native implementation in imlib.
I would be very helpful, if you could provide some information or internals of how this python code is mapping to native implementation & what to look for…

kwagyeman · May 25, 2021, 3:28am

Ah, yes, the way this works is that:

There’s a python wrapper method in the py_image.c file which has all the image methods:

github.com

openmv/openmv/blob/master/src/omv/modules/py_image.c#L2509


      
          #ifdef IMLIB_ENABLE_MIDPOINT
          STATIC mp_obj_t py_image_midpoint(uint n_args, const mp_obj_t *args, mp_map_t *kw_args)
          {
              image_t *arg_img =
                  py_helper_arg_to_image_mutable(args[0]);
              int arg_ksize =
                  py_helper_arg_to_ksize(args[1]);
              float arg_bias =
                  py_helper_keyword_float(n_args, args, 2, kw_args, MP_OBJ_NEW_QSTR(MP_QSTR_bias), 0.5f);
              PY_ASSERT_TRUE_MSG((0 <= arg_bias) && (arg_bias <= 1), "Error: 0 <= bias <= 1!");
              bool arg_threshold =
                  py_helper_keyword_int(n_args, args, 3, kw_args, MP_OBJ_NEW_QSTR(MP_QSTR_threshold), false);
              int arg_offset =
                  py_helper_keyword_int(n_args, args, 4, kw_args, MP_OBJ_NEW_QSTR(MP_QSTR_offset), 0);
              bool arg_invert =
                  py_helper_keyword_int(n_args, args, 5, kw_args, MP_OBJ_NEW_QSTR(MP_QSTR_invert), false);
              image_t *arg_msk =
                  py_helper_keyword_to_image_mutable_mask(n_args, args, 6, kw_args);
          
          
    fb_alloc_mark();
              imlib_midpoint_filter(arg_img, arg_ksize, arg_bias, arg_threshold, arg_offset, arg_invert, arg_msk);

That generally parses arguments from python in a flexible way. Then it will call the C method in the imlib file:

github.com

openmv/openmv/blob/master/src/omv/imlib/filter.c#L1182


      
                  default: {
                      break;
                  }
              }
              fb_free();
          }
          #endif // IMLIB_ENABLE_MIDPOINT
          
          
// http://www.fmwconcepts.com/imagemagick/digital_image_filtering.pdf
          
          
void imlib_morph(image_t *img, const int ksize, const int *krn, const float m, const int b, bool threshold, int offset, bool invert, image_t *mask)
          {
              int brows = ksize + 1;
              image_t buf;
              buf.w = img->w;
              buf.h = brows;
              buf.pixfmt = img->pixfmt;
              const int32_t m_int = (int32_t)(65536.0 * m); // m is 1/kernel_weight
          
          
    switch (img->pixfmt) {
                  case PIXFORMAT_BINARY: {

…

Note, after partnering with Arduino we’ve been going through our code and updating it from hobbyist level work to hardened pro code. Over the years we’ve gotten a lot better and writing high performance code that is fast and uses SIMD like features on the Cortex-M4/7 (and soon the M55).

Morph was optimized slightly by a paid performance optimizer. However, there’s quite a bit of speed that we left on the table for the sake of code space.

We’re focused on improving the performance of multi-media parts of the code right now but in the future we will work on making kernels much faster.

For example, we could automatically make the method detect if the kernel is vertically and horizontally separateable and then reduce complexity from O(N^2) to (2N). Also, we could hardcode and unroll known frequently used kernel sizes.