Remove morph9, we're tight on flash space as it is

.. and no specific use case for morph9 is known that can't be done
with mix+morph.

Saves ~1800 bytes on Memento

Author: jepler

shared-bindings/bitmapfilter/__init__.c

@@ -148,154 +148,14 @@ STATIC mp_obj_t bitmapfilter_morph(size_t n_args, const mp_obj_t *pos_args, mp_m
     return args[ARG_bitmap].u_obj;
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(bitmapfilter_morph_obj, 0, bitmapfilter_morph);
-
-//|
-//| def morph9(
-//|     bitmap: displayio.Bitmap,
-//|     weights: Sequence[int],
-//|     mul: Sequence[float] | None,
-//|     add: Sequence[float] | None,
-//|     mask: displayio.Bitmap | None = None,
-//|     threshold=False,
-//|     offset: int = 0,
-//|     invert: bool = False,
-//| ) -> displayio.Bitmap:
-//|     """Convolve an image with a kernel
-//|
-//|     This is like a combination of 9 calls to morph plus one call to mix. It's
-//|     so complicated and hard to explain that it must be good for something.
-//|
-//|     The ``bitmap``, which must be in RGB565_SWAPPED format, is modified
-//|     according to the ``weights``. Then a scaling factor ``m`` and an
-//|     offset factor ``b`` are applied.
-//|
-//|     The ``weights`` must be a tuple of integers. The length of the tuple
-//|     must be 9 times the square of an odd number, such as 81 or 225. The weights
-//|     are taken in groups of 9, with the first 3 giving the proportion of each of
-//|     R, G, and B that are mixed into the output R, the next three the
-//|     proportions mixed into the output G, and the last 3 the proportions that
-//|     are mixed into the output blue.
-//|
-//|     ``mul`` is a sequence of 3 numbers to multiply the convolution pixel
-//|     results by. When not set it defaults to a value that will prevent scaling
-//|     in the convolution output.
-//|
-//|     ``add`` is a sequence of 3 numbers giving a value to add to each
-//|     convolution pixel result. If unspecified or None, 0 is used for all 3 channels.
-//|
-//|     ``mul`` basically allows you to do a global contrast adjustment and
-//|     add allows you to do a global brightness adjustment. Pixels that go
-//|     outside of the image mins and maxes for color channels will be
-//|     clipped.
-//|
-//|     If you’d like to adaptive threshold the image on the output of the
-//|     filter you can pass ``threshold=True`` which will enable adaptive
-//|     thresholding of the image which sets pixels to one or zero based on a
-//|     pixel’s brightness in relation to the brightness of the kernel of pixels
-//|     around them. A negative ``offset`` value sets more pixels to 1 as you make
-//|     it more negative while a positive value only sets the sharpest contrast
-//|     changes to 1. Set ``invert`` to invert the binary image resulting output.
-//|
-//|     ``mask`` is another image to use as a pixel level mask for the operation.
-//|     The mask should be an image the same size as the image being operated on.
-//|     Only pixels set to a non-zero value in the mask are modified.
-//|
-//|     .. code-block:: python
-//|
-//|         kernel_gauss_3 = [
-//|             1, 2, 1,
-//|             2, 4, 2,
-//|             1, 2, 1]
-//|
-//|         def blur(bitmap):
-//|             \"""Blur the bitmap with a 3x3 gaussian kernel\"""
-//|             bitmapfilter.morph(bitmap, kernel_gauss_3, 1/sum(kernel_gauss_3))
-//|     """
-//|
-
 static mp_obj_t subscr(mp_obj_t o, int i) {
     return mp_obj_subscr(o, MP_OBJ_NEW_SMALL_INT(i), MP_OBJ_SENTINEL);
 }
 
-static mp_obj_t subscr_maybe(mp_obj_t o, int i) {
-    return o == mp_const_none ? o : subscr(o, i);
-}
-
 static mp_float_t float_subscr(mp_obj_t o, int i) {
     return mp_obj_get_float(subscr(o, i));
 }
 
-STATIC mp_float_t float_subscr_maybe(mp_obj_t seq_maybe, int i, mp_float_t defval) {
-    if (seq_maybe == mp_const_none) {
-        return defval;
-    }
-    return float_subscr(seq_maybe, i);
-}
-
-STATIC mp_obj_t bitmapfilter_morph9(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_bitmap, ARG_weights, ARG_mul, ARG_add, ARG_threshold, ARG_offset, ARG_invert, ARG_mask };
-    static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_bitmap, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
-        { MP_QSTR_weights, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
-        { MP_QSTR_mul, MP_ARG_OBJ, { .u_obj = MP_ROM_NONE } },
-        { MP_QSTR_add, MP_ARG_OBJ, { .u_obj = MP_ROM_NONE } },
-        { MP_QSTR_threshold, MP_ARG_BOOL, { .u_bool = false } },
-        { MP_QSTR_offset, MP_ARG_INT, { .u_int = 0 } },
-        { MP_QSTR_invert, MP_ARG_BOOL, { .u_bool = false } },
-        { MP_QSTR_mask, MP_ARG_OBJ, { .u_obj = MP_ROM_NONE } },
-    };
-    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);
-
-    mp_arg_validate_type(args[ARG_bitmap].u_obj, &displayio_bitmap_type, MP_QSTR_bitmap);
-    displayio_bitmap_t *bitmap = args[ARG_bitmap].u_obj;
-
-    displayio_bitmap_t *mask = NULL; // the mask bitmap
-    if (args[ARG_mask].u_obj != mp_const_none) {
-        mp_arg_validate_type(args[ARG_mask].u_obj, &displayio_bitmap_type, MP_QSTR_mask);
-        mask = MP_OBJ_TO_PTR(args[ARG_mask].u_obj);
-    }
-
-    mp_float_t b[3] = {
-        float_subscr_maybe(args[ARG_add].u_obj, 0, 0),
-        float_subscr_maybe(args[ARG_add].u_obj, 1, 0),
-        float_subscr_maybe(args[ARG_add].u_obj, 2, 0),
-    };
-
-    mp_obj_t weights = args[ARG_weights].u_obj;
-    mp_obj_t obj_len = mp_obj_len(weights);
-    if (obj_len == MP_OBJ_NULL || !mp_obj_is_small_int(obj_len)) {
-        mp_raise_ValueError_varg(MP_ERROR_TEXT("%q must be of type %q, not %q"), MP_QSTR_weights, MP_QSTR_Sequence, mp_obj_get_type(weights)->name);
-    }
-
-    size_t n_weights = MP_OBJ_SMALL_INT_VALUE(obj_len);
-
-    size_t sq_n_weights = (int)MICROPY_FLOAT_C_FUN(sqrt)(n_weights / 9);
-    if (sq_n_weights % 2 == 0 || sq_n_weights * sq_n_weights * 9 != n_weights) {
-        mp_raise_ValueError(MP_ERROR_TEXT("weights must be a sequence with 9 times an odd square number of elements (usually 81 or 225)"));
-    }
-
-    int iweights[n_weights];
-    int weight_sum[3] = {0, 0, 0};
-    for (size_t i = 0; i < n_weights; i++) {
-        mp_int_t j = mp_obj_get_int(mp_obj_subscr(weights, MP_OBJ_NEW_SMALL_INT(i), MP_OBJ_SENTINEL));
-        iweights[i] = j;
-        int target_channel = (i / 3) % 3;
-        weight_sum[target_channel] += j;
-    }
-
-    mp_float_t m[3] = {
-        get_m(subscr_maybe(args[ARG_mul].u_obj, 0), weight_sum[0]),
-        get_m(subscr_maybe(args[ARG_mul].u_obj, 1), weight_sum[1]),
-        get_m(subscr_maybe(args[ARG_mul].u_obj, 2), weight_sum[2])
-    };
-
-    shared_module_bitmapfilter_morph9(bitmap, mask, sq_n_weights / 2, iweights, m, b,
-        args[ARG_threshold].u_bool, args[ARG_offset].u_bool, args[ARG_invert].u_bool);
-    return args[ARG_bitmap].u_obj;
-}
-MP_DEFINE_CONST_FUN_OBJ_KW(bitmapfilter_morph9_obj, 0, bitmapfilter_morph9);
-
 //| def mix(
 //|     bitmap: displayio.Bitmap, weights: Sequence[int], mask: displayio.Bitmap | None = None
 //| ) -> displayio.Bitmap:
@@ -557,7 +417,6 @@ MP_DEFINE_CONST_FUN_OBJ_KW(bitmapfilter_false_color_obj, 0, bitmapfilter_false_c
 STATIC const mp_rom_map_elem_t bitmapfilter_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_bitmapfilter) },
     { MP_ROM_QSTR(MP_QSTR_morph), MP_ROM_PTR(&bitmapfilter_morph_obj) },
-    { MP_ROM_QSTR(MP_QSTR_morph9), MP_ROM_PTR(&bitmapfilter_morph9_obj) },
     { MP_ROM_QSTR(MP_QSTR_mix), MP_ROM_PTR(&bitmapfilter_mix_obj) },
     { MP_ROM_QSTR(MP_QSTR_solarize), MP_ROM_PTR(&bitmapfilter_solarize_obj) },
     { MP_ROM_QSTR(MP_QSTR_false_color), MP_ROM_PTR(&bitmapfilter_false_color_obj) },

shared-module/bitmapfilter/__init__.c

@@ -177,151 +177,6 @@ STATIC uint16_t imlib_yuv_to_rgb(uint8_t y, int8_t u, int8_t v) {
 #define COLOR_YUV_TO_RGB565(y, u, v)            imlib_yuv_to_rgb((y), u, v)
 
 
-void shared_module_bitmapfilter_morph9(
-    displayio_bitmap_t *bitmap,
-    displayio_bitmap_t *mask,
-    const int ksize,
-    int krn[9 * (2 * ksize + 1) * (2 * ksize + 1)], // Note: modifies krn[]
-    const mp_float_t m[3],
-    const mp_float_t b[3],
-    bool threshold,
-    int offset,
-    bool invert) {
-
-    int brows = ksize + 1;
-
-    int arrsize = (ksize * 2 + 1) * (ksize * 2 + 1) * 9;
-
-    for (int i = 0; i < arrsize; i++) {
-        int source_channel = i % 3;
-        int target_channel = (i / 3) % 3;
-        int source_is_green = (source_channel == 1);
-        int target_is_green = (target_channel == 1);
-
-        int scale = (source_is_green == target_is_green) ? 65536
-            : source_is_green ? 32768 : 131072;
-
-        krn[i] = (int)MICROPY_FLOAT_C_FUN(round)(scale * m[target_channel] * krn[i]);
-    }
-
-    const int32_t b_int[3] = {
-        (int32_t)MICROPY_FLOAT_C_FUN(round)(65536 * COLOR_R5_MAX * b[0]),
-        (int32_t)MICROPY_FLOAT_C_FUN(round)(65536 * COLOR_G6_MAX * b[1]),
-        (int32_t)MICROPY_FLOAT_C_FUN(round)(65536 * COLOR_B5_MAX * b[2])
-    };
-
-    check_matching_details(bitmap, bitmap);
-
-    switch (bitmap->bits_per_value) {
-        default:
-            mp_raise_ValueError(MP_ERROR_TEXT("unsupported bitmap depth"));
-        case 16: {
-            displayio_bitmap_t buf;
-            scratch_bitmap16(&buf, brows, bitmap->width);
-
-            for (int y = 0, yy = bitmap->height; y < yy; y++) {
-                uint16_t *row_ptr = IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(bitmap, y);
-                uint16_t *buf_row_ptr = IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(&buf, (y % brows));
-
-                for (int x = 0, xx = bitmap->width; x < xx; x++) {
-                    if (mask && common_hal_displayio_bitmap_get_pixel(mask, x, y)) {
-                        IMAGE_PUT_RGB565_PIXEL_FAST(buf_row_ptr, x, IMAGE_GET_RGB565_PIXEL_FAST(row_ptr, x));
-                        continue; // Short circuit.
-
-                    }
-                    int32_t r_acc = b_int[0], g_acc = b_int[1], b_acc = b_int[2], ptr = 0;
-
-                    if (x >= ksize && x < bitmap->width - ksize && y >= ksize && y < bitmap->height - ksize) {
-                        for (int j = -ksize; j <= ksize; j++) {
-                            uint16_t *k_row_ptr = IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(bitmap, y + j);
-                            for (int k = -ksize; k <= ksize; k++) {
-                                int pixel = IMAGE_GET_RGB565_PIXEL_FAST(k_row_ptr, x + k);
-                                int r = COLOR_RGB565_TO_R5(pixel);
-                                int g = COLOR_RGB565_TO_G6(pixel);
-                                int b = COLOR_RGB565_TO_B5(pixel);
-                                r_acc += krn[ptr++] * r;
-                                r_acc += krn[ptr++] * g;
-                                r_acc += krn[ptr++] * b;
-                                g_acc += krn[ptr++] * r;
-                                g_acc += krn[ptr++] * g;
-                                g_acc += krn[ptr++] * b;
-                                b_acc += krn[ptr++] * r;
-                                b_acc += krn[ptr++] * g;
-                                b_acc += krn[ptr++] * b;
-                            }
-                        }
-                    } else {
-                        for (int j = -ksize; j <= ksize; j++) {
-                            uint16_t *k_row_ptr = IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(bitmap,
-                                IM_MIN(IM_MAX(y + j, 0), (bitmap->height - 1)));
-                            for (int k = -ksize; k <= ksize; k++) {
-                                int pixel = IMAGE_GET_RGB565_PIXEL_FAST(k_row_ptr,
-                                    IM_MIN(IM_MAX(x + k, 0), (bitmap->width - 1)));
-                                int r = COLOR_RGB565_TO_R5(pixel);
-                                int g = COLOR_RGB565_TO_G6(pixel);
-                                int b = COLOR_RGB565_TO_B5(pixel);
-                                r_acc += krn[ptr++] * r;
-                                r_acc += krn[ptr++] * g;
-                                r_acc += krn[ptr++] * b;
-                                g_acc += krn[ptr++] * r;
-                                g_acc += krn[ptr++] * g;
-                                g_acc += krn[ptr++] * b;
-                                b_acc += krn[ptr++] * r;
-                                b_acc += krn[ptr++] * g;
-                                b_acc += krn[ptr++] * b;
-                            }
-                        }
-                    }
-                    r_acc >>= 16;
-                    if (r_acc > COLOR_R5_MAX) {
-                        r_acc = COLOR_R5_MAX;
-                    } else if (r_acc < 0) {
-                        r_acc = 0;
-                    }
-                    g_acc >>= 16;
-                    if (g_acc > COLOR_G6_MAX) {
-                        g_acc = COLOR_G6_MAX;
-                    } else if (g_acc < 0) {
-                        g_acc = 0;
-                    }
-                    b_acc >>= 16;
-                    if (b_acc > COLOR_B5_MAX) {
-                        b_acc = COLOR_B5_MAX;
-                    } else if (b_acc < 0) {
-                        b_acc = 0;
-                    }
-
-                    int pixel = COLOR_R5_G6_B5_TO_RGB565(r_acc, g_acc, b_acc);
-
-                    if (threshold) {
-                        if (((COLOR_RGB565_TO_Y(pixel) - offset) < COLOR_RGB565_TO_Y(IMAGE_GET_RGB565_PIXEL_FAST(row_ptr, x))) ^ invert) {
-                            pixel = COLOR_RGB565_BINARY_MAX;
-                        } else {
-                            pixel = COLOR_RGB565_BINARY_MIN;
-                        }
-                    }
-
-                    IMAGE_PUT_RGB565_PIXEL_FAST(buf_row_ptr, x, pixel);
-                }
-
-                if (y >= ksize) {     // Transfer buffer lines...
-                    memcpy(IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(bitmap, (y - ksize)),
-                        IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(&buf, ((y - ksize) % brows)),
-                        IMAGE_RGB565_LINE_LEN_BYTES(bitmap));
-                }
-            }
-
-            // Copy any remaining lines from the buffer image...
-            for (int y = IM_MAX(bitmap->height - ksize, 0), yy = bitmap->height; y < yy; y++) {
-                memcpy(IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(bitmap, y),
-                    IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(&buf, (y % brows)),
-                    IMAGE_RGB565_LINE_LEN_BYTES(bitmap));
-            }
-
-            break;
-        }
-    }
-}
 void shared_module_bitmapfilter_morph(
     displayio_bitmap_t *bitmap,
     displayio_bitmap_t *mask,