Improve Tera Type reader using the new brightness filter.

Author: Mysticial

SerialPrograms/Source/CommonTools/Images/ImageFilter.cpp

@@ -161,7 +161,6 @@ std::vector<std::pair<ImageRGB32, size_t>> to_blackwhite_rgb32_range(
 
 
 
-#if 0
 ImageRGB32 to_blackwhite_rgb32_brightness(
     const ImageViewRGB32& image,
     bool in_range_black,
@@ -170,11 +169,12 @@ ImageRGB32 to_blackwhite_rgb32_brightness(
     ImageRGB32 ret(image.width(), image.height());
     Kernels::to_blackwhite_rgb32_brightness(
         image.data(), image.bytes_per_row(), image.width(), image.height(),
-        ret.data(), ret.bytes_per_row(), mins, maxs, in_range_black
+        ret.data(), ret.bytes_per_row(),
+        in_range_black,
+        in_range_black, max_brightness
     );
     return ret;
 }
-#endif
 
 
 

SerialPrograms/Source/Kernels/ImageFilters/RGB32_Brightness/Kernels_ImageFilter_RGB32_Brightness.cpp

@@ -39,5 +39,32 @@ size_t filter_rgb32_brightness(
 
 
 
+size_t to_blackwhite_rgb32_brightness_Default(
+    const uint32_t* in, size_t in_bytes_per_row, size_t width, size_t height,
+    uint32_t* out, size_t out_bytes_per_row,
+    bool in_range_black,
+    uint32_t min_brightness, uint32_t max_brightness
+);
+size_t to_blackwhite_rgb32_brightness(
+    const uint32_t* in, size_t in_bytes_per_row, size_t width, size_t height,
+    uint32_t* out, size_t out_bytes_per_row,
+    bool in_range_black,
+    uint32_t min_brightness, uint32_t max_brightness
+){
+    if (width * height > 0xffffffff){
+        throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Image is too large. more than 2^32 pixels.");
+    }
+
+    return to_blackwhite_rgb32_brightness_Default(
+        in, in_bytes_per_row, width, height,
+        out, out_bytes_per_row,
+        in_range_black,
+        min_brightness, max_brightness
+    );
+}
+
+
+
+
 }
 }

SerialPrograms/Source/Kernels/ImageFilters/RGB32_Brightness/Kernels_ImageFilter_RGB32_Brightness.h

@@ -25,6 +25,14 @@ size_t filter_rgb32_brightness(
 );
 
 
+size_t to_blackwhite_rgb32_brightness(
+    const uint32_t* in, size_t in_bytes_per_row, size_t width, size_t height,
+    uint32_t* out, size_t out_bytes_per_row,
+    bool in_range_black,
+    uint32_t min_brightness, uint32_t max_brightness
+);
+
+
 
 
 }

SerialPrograms/Source/Kernels/ImageFilters/RGB32_Brightness/Kernels_ImageFilter_RGB32_Brightness_Default.cpp

@@ -18,8 +18,8 @@ class ImageFilter_RgbBrightness_Default{
 
 public:
     ImageFilter_RgbBrightness_Default(
-        uint32_t min_brightness, uint32_t max_brightness,
-        uint32_t replacement_color, bool replace_color_within_range
+        uint32_t replacement_color, bool replace_color_within_range,
+        uint32_t min_brightness, uint32_t max_brightness
     )
         : m_replacement_color(replacement_color)
         , m_replace_color_within_range(replace_color_within_range ? 1 : 0)
@@ -59,7 +59,10 @@ size_t filter_rgb32_brightness_Default(
     uint32_t replacement, bool replace_color_within_range,
     uint32_t min_brightness, uint32_t max_brightness
 ){
-    ImageFilter_RgbBrightness_Default filter(replacement, replace_color_within_range, min_brightness, max_brightness);
+    ImageFilter_RgbBrightness_Default filter(
+        replacement, replace_color_within_range,
+        min_brightness, max_brightness
+    );
     filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
     return filter.count();
 }
@@ -68,5 +71,61 @@ size_t filter_rgb32_brightness_Default(
 
 
 
+
+class ToBlackWhite_RgbBrightness_Default{
+public:
+    static const size_t VECTOR_SIZE = 1;
+    using Mask = size_t;
+
+public:
+    ToBlackWhite_RgbBrightness_Default(
+        bool in_range_black,
+        uint32_t min_brightness, uint32_t max_brightness
+    )
+        : m_in_range_black(in_range_black ? 1 : 0)
+        , m_min_brightness(min_brightness)
+        , m_max_brightness(max_brightness)
+        , m_count(0)
+    {}
+
+    PA_FORCE_INLINE size_t count() const{
+        return m_count;
+    }
+
+    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+        uint32_t pixel = in[0];
+        uint32_t brightness = 0;
+        brightness += ((pixel >>  0) & 0x000000ff);
+        brightness += ((pixel >>  8) & 0x000000ff);
+        brightness += ((pixel >> 16) & 0x000000ff);
+        uint32_t ret = m_min_brightness <= brightness && brightness <= m_max_brightness;
+        m_count += ret;
+        ret ^= m_in_range_black;
+        out[0] = ret ? 0xffffffff : 0xff000000;
+    }
+    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, size_t left){
+        process_full(out, in);
+    }
+
+private:
+    const uint32_t m_in_range_black;
+    uint32_t m_min_brightness;
+    uint32_t m_max_brightness;
+    size_t m_count;
+};
+size_t to_blackwhite_rgb32_brightness_Default(
+    const uint32_t* in, size_t in_bytes_per_row, size_t width, size_t height,
+    uint32_t* out, size_t out_bytes_per_row,
+    bool in_range_black,
+    uint32_t min_brightness, uint32_t max_brightness
+){
+    ToBlackWhite_RgbBrightness_Default filter(in_range_black, min_brightness, max_brightness);
+    filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
+    return filter.count();
+}
+
+
+
+
 }
 }

SerialPrograms/Source/PokemonSV/Inference/Tera/PokemonSV_TeraTypeReader.cpp

@@ -66,7 +66,7 @@ ImageMatch::ImageMatchResult TeraTypeReader::read(const ImageViewRGB32& screen)
             cropped_image,
             // The filter is a lambda function that returns true on black tera type pixels.
             [=](Color pixel){
-                return (uint32_t)pixel.red() + pixel.green() + pixel.blue() < threshold;
+                return (uint32_t)pixel.red() + pixel.green() + pixel.blue() <= threshold;
             }
         );
 
@@ -77,14 +77,11 @@ ImageMatch::ImageMatchResult TeraTypeReader::read(const ImageViewRGB32& screen)
         ImageRGB32 processed_image = extract_box_reference(cropped_image, tight_box).copy();
 //        processed_image.save("processed_image-" + std::to_string(threshold) + ".png");
 
-        uint32_t upper_filter = threshold / 3 * 0x00010101;
-        upper_filter |= 0xff000000;
-
-        ImageRGB32 filtered_image = to_blackwhite_rgb32_range(processed_image, 0xff000000, upper_filter, true);
+        ImageRGB32 filtered_image = to_blackwhite_rgb32_brightness(processed_image, true, 0, threshold);
 //        filtered_image.save("filtered_image-" + std::to_string(threshold) + ".png");
 
         ImageMatch::ImageMatchResult types = m_matcher.match(filtered_image, ALPHA_SPREAD);
-//        types.log(global_logger_tagged(), MAX_ALPHA);   //  REMOVE
+//        types.log(global_logger_tagged(), MAX_ALPHA);
         types.clear_beyond_alpha(MAX_ALPHA);
 
         if (types.results.size() == 1){