bitmapfilter: Add solarize, add comments

Author: jepler

shared-bindings/bitmapfilter/__init__.c

@@ -229,13 +229,40 @@ STATIC mp_obj_t bitmapfilter_mix(size_t n_args, const mp_obj_t *pos_args, mp_map
     shared_module_bitmapfilter_mix(bitmap, mask, weights);
     return mp_const_none;
 }
-
 MP_DEFINE_CONST_FUN_OBJ_KW(bitmapfilter_mix_obj, 0, bitmapfilter_mix);
 
+STATIC mp_obj_t bitmapfilter_solarize(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_bitmap, ARG_threshold, 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_threshold, MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
+        { 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_float_t threshold = (args[ARG_threshold].u_obj == NULL) ? MICROPY_FLOAT_CONST(0.5) : mp_obj_get_float(args[ARG_threshold].u_obj);
+    mp_arg_validate_type(args[ARG_bitmap].u_obj, &displayio_bitmap_type, MP_QSTR_bitmap);
+    displayio_bitmap_t *bitmap = MP_OBJ_TO_PTR(args[ARG_bitmap].u_obj);
+
+
+    displayio_bitmap_t *mask = NULL;
+    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);
+    }
+
+    shared_module_bitmapfilter_solarize(bitmap, mask, threshold);
+    return mp_const_none;
+}
+
+MP_DEFINE_CONST_FUN_OBJ_KW(bitmapfilter_solarize_obj, 0, bitmapfilter_solarize);
+
 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_mix), MP_ROM_PTR(&bitmapfilter_mix_obj) },
+    { MP_ROM_QSTR(MP_QSTR_solarize), MP_ROM_PTR(&bitmapfilter_solarize_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(bitmapfilter_module_globals, bitmapfilter_module_globals_table);
 

shared-bindings/bitmapfilter/__init__.h

@@ -43,3 +43,8 @@ void shared_module_bitmapfilter_mix(
     displayio_bitmap_t *bitmap,
     displayio_bitmap_t *mask,
     const mp_float_t weights[12]);
+
+void shared_module_bitmapfilter_solarize(
+    displayio_bitmap_t *bitmap,
+    displayio_bitmap_t *mask,
+    const mp_float_t threshold);

shared-module/bitmapfilter/__init__.c

@@ -258,10 +258,10 @@ void shared_module_bitmapfilter_mix(
         // As well, the final value in each row has to be scaled up by the
         // component's maxval.
         int scale =
-            (i == 1 || i == 9) ? 32768 :
-            (i == 4 || i == 6) ? 131072 :
-            (i == 3 || i == 11) ? 65535 * COLOR_B5_MAX :
-            (i == 7) ? 65535 * COLOR_G6_MAX :
+            (i == 1 || i == 9) ? 32768 : // Mixing G into R/B
+            (i == 4 || i == 6) ? 131072 : // Mixing R/B into G
+            (i == 3 || i == 11) ? 65535 * COLOR_B5_MAX : // Offset for R/B
+            (i == 7) ? 65535 * COLOR_G6_MAX : // Offset for G
             65536;
         wt[i] = (int32_t)MICROPY_FLOAT_C_FUN(round)(scale * weights[i]);
     }
@@ -315,3 +315,35 @@ void shared_module_bitmapfilter_mix(
         }
     }
 }
+
+void shared_module_bitmapfilter_solarize(
+    displayio_bitmap_t *bitmap,
+    displayio_bitmap_t *mask,
+    const mp_float_t threshold) {
+
+    int threshold_i = (int32_t)MICROPY_FLOAT_C_FUN(round)(256 * threshold);
+    switch (bitmap->bits_per_value) {
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("unsupported bitmap depth"));
+        case 16: {
+            for (int y = 0, yy = bitmap->height; y < yy; y++) {
+                uint16_t *row_ptr = IMAGE_COMPUTE_RGB565_PIXEL_ROW_PTR(bitmap, y);
+                for (int x = 0, xx = bitmap->width; x < xx; x++) {
+                    if (mask && common_hal_displayio_bitmap_get_pixel(mask, x, y)) {
+                        continue; // Short circuit.
+                    }
+                    int pixel = IMAGE_GET_RGB565_PIXEL_FAST(row_ptr, x);
+                    if (COLOR_RGB565_TO_Y(pixel) > threshold_i) {
+                        int r = COLOR_R5_MAX - COLOR_RGB565_TO_R5(pixel);
+                        int g = COLOR_G6_MAX - COLOR_RGB565_TO_G6(pixel);
+                        int b = COLOR_B5_MAX - COLOR_RGB565_TO_B5(pixel);
+
+                        pixel = COLOR_R5_G6_B5_TO_RGB565(r, g, b);
+                        IMAGE_PUT_RGB565_PIXEL_FAST(row_ptr, x, pixel);
+                    }
+                }
+            }
+            break;
+        }
+    }
+}