Refactor ImageFilter Euclidean to use template routines.

Author: Mysticial

SerialPrograms/Source/Kernels/ImageFilters/RGB32_EuclideanDistance/Kernels_ImageFilter_RGB32_Euclidean.cpp

@@ -36,7 +36,7 @@ size_t filter_rgb32_euclidean_x64_AVX512(
     uint32_t replacement, bool replace_color_within_range,
     uint32_t expected, double max_euclidean_distance
 );
-size_t filter_rgb32_euclidean_arm64_NEON(
+size_t filter_rgb32_euclidean_ARM64_NEON(
     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,
     uint32_t replacement, bool replace_color_within_range,
@@ -83,7 +83,7 @@ size_t filter_rgb32_euclidean(
 #endif
 #ifdef PA_AutoDispatch_arm64_20_M1
     if (CPU_CAPABILITY_CURRENT.OK_M1){
-        return filter_rgb32_euclidean_arm64_NEON(
+        return filter_rgb32_euclidean_ARM64_NEON(
             in, in_bytes_per_row, width, height,
             out, out_bytes_per_row,
             replacement, replace_color_within_range,

SerialPrograms/Source/Kernels/ImageFilters/RGB32_EuclideanDistance/Kernels_ImageFilter_RGB32_Euclidean_ARM64_NEON.cpp

@@ -15,6 +15,87 @@ namespace PokemonAutomation{
 namespace Kernels{
 
 
+
+class PixelTest_Rgb32Euclidean_ARM64_NEON{
+public:
+    static const size_t VECTOR_SIZE = 4;
+    using Mask = size_t;
+
+public:
+    PA_FORCE_INLINE PixelTest_Rgb32Euclidean_ARM64_NEON(
+        uint32_t expected, double max_euclidean_distance
+    )
+        : m_expected_color_rgb_u8(vreinterpretq_u8_u32(vdupq_n_u32(expected_color & 0x00ffffff)))
+        , m_distance_squared_u32(vdupq_n_u32((uint32_t)(max_euclidean_distance * max_euclidean_distance)))
+    {}
+
+    //  Return a mask indicating which lanes are in range.
+    PA_FORCE_INLINE uint32x4_t test_word(uint32x4_t& pixel) const{
+        uint32x4_t in_u32 = vld1q_u32(in);
+        // subtract the expected values
+        uint32x4_t in_dif_u32 = vreinterpretq_u32_u8(vabdq_u8(vreinterpretq_u8_u32(in_u32), m_expected_color_rgb_u8));
+
+        // Get green channel
+        uint32x4_t in_g_u32 = vandq_u32(in_dif_u32, vdupq_n_u32(0x0000ff00));
+        // Move green channel to the lower end of the 16-bit regions
+        uint16x8_t in_g_u16 = vshrq_n_u16(vreinterpretq_u16_u32(in_g_u32), 8);
+        // in_rb_u16 contains the red and blue channels. Each channel occupies a 16-bit region
+        uint16x8_t in_rb_u16 = vandq_u16(vreinterpretq_u16_u32(in_dif_u32), vdupq_n_u16(0x00ff));
+
+        // Square operation
+        uint16x8_t in_g2_u16 = vmulq_u16(in_g_u16, in_g_u16);
+        uint16x8_t in_r2b2_u16 = vmulq_u16(in_rb_u16, in_rb_u16);
+
+        uint32x4_t in_g2_u32 = vreinterpretq_u32_u16(in_g2_u16);
+        // Use pairwise addition and accumulate to add r2, g2, and b2 together
+        uint32x4_t sum_sqr_u32 = vpadalq_u16(in_g2_u32, in_r2b2_u16);
+
+        // cmp_u32: if each pixel is within the range, its uint32_t in `cmp_u32` is all 1 bits, otherwise, all 0 bits
+        return vcleq_u32(sum_sqr_u32, m_distance_squared_u32);
+    }
+
+private:
+    uint8x16_t m_expected_color_rgb_u8;
+    uint32x4_t m_distance_squared_u32;
+};
+
+
+
+size_t filter_rgb32_euclidean_ARM64_NEON(
+    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,
+    uint32_t replacement, bool replace_color_within_range,
+    uint32_t expected, double max_euclidean_distance
+){
+    PixelTest_Rgb32Euclidean_ARM64_NEON tester(
+        expected, max_euclidean_distance
+    );
+    FilterImage_Rgb32_ARM64_NEON<PixelTest_Rgb32Euclidean_ARM64_NEON> filter(
+        tester, replacement, replace_color_within_range
+    );
+    filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
+    return filter.count();
+}
+size_t to_blackwhite_rgb32_euclidean_ARM64_NEON(
+    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 expected, double max_euclidean_distance
+){
+    PixelTest_Rgb32Euclidean_ARM64_NEON tester(
+        expected, max_euclidean_distance
+    );
+    ToBlackWhite_Rgb32_ARM64_NEON<PixelTest_Rgb32Euclidean_ARM64_NEON> filter(
+        tester, in_range_black
+    );
+    filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
+    return filter.count();
+}
+
+
+
+#if 0
+
 class ImageFilter_RgbEuclidean_arm64_NEON{
 public:
     static const size_t VECTOR_SIZE = 4;
@@ -112,7 +193,7 @@ size_t filter_rgb32_euclidean_arm64_NEON(
     filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
     return filter.count();
 }
-
+#endif
 
 
 

SerialPrograms/Source/Kernels/ImageFilters/RGB32_EuclideanDistance/Kernels_ImageFilter_RGB32_Euclidean_Default.cpp

@@ -5,38 +5,32 @@
  */
 
 #include "Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines.h"
+#include "Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_Default.h"
 #include "Kernels_ImageFilter_RGB32_Euclidean.h"
 
 namespace PokemonAutomation{
 namespace Kernels{
 
 
 
-class ImageFilter_RgbEuclidean_Default{
+
+class PixelTest_Rgb32Euclidean_Default{
 public:
     static const size_t VECTOR_SIZE = 1;
     using Mask = size_t;
 
 public:
-    ImageFilter_RgbEuclidean_Default(
-        uint32_t replacement_color, bool replace_color_within_range,
-        uint32_t expected_color, double max_euclidean_distance
+    PA_FORCE_INLINE PixelTest_Rgb32Euclidean_Default(
+        uint32_t expected, double max_euclidean_distance
     )
-        : m_replacement_color(replacement_color)
-        , m_replace_color_within_range(replace_color_within_range ? 1 : 0)
-        , m_expected_r((expected_color & 0x00ff0000) >> 16)
-        , m_expected_g((expected_color & 0x0000ff00) >> 8)
-        , m_expected_b(expected_color & 0x000000ff)
+        : m_expected_r((expected & 0x00ff0000) >> 16)
+        , m_expected_g((expected & 0x0000ff00) >> 8)
+        , m_expected_b(expected & 0x000000ff)
         , m_max_distance_squared((uint32_t)(max_euclidean_distance * max_euclidean_distance))
-        , 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];
+    //  Return a mask indicating which lanes are in range.
+    PA_FORCE_INLINE bool test_word(uint32_t pixel) const{
         uint32_t sum_sqr = 0;
         {
             uint32_t p = (pixel & 0x00ff0000) >> 16;
@@ -53,37 +47,51 @@ class ImageFilter_RgbEuclidean_Default{
             p -= m_expected_b;
             sum_sqr += p * p;
         }
-        uint32_t ret = sum_sqr <= m_max_distance_squared;
-        m_count += ret;
-        ret ^= m_replace_color_within_range;
-        out[0] = ret ? pixel : m_replacement_color;
-    }
-    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, size_t left){
-        process_full(out, in);
+        return sum_sqr <= m_max_distance_squared;
     }
 
 private:
-    const uint32_t m_replacement_color;
-    const uint32_t m_replace_color_within_range;
     uint32_t m_expected_r;
     uint32_t m_expected_g;
     uint32_t m_expected_b;
     uint32_t m_max_distance_squared;
-    size_t m_count;
 };
+
+
+
 size_t filter_rgb32_euclidean_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,
     uint32_t replacement, bool replace_color_within_range,
     uint32_t expected, double max_euclidean_distance
 ){
-    ImageFilter_RgbEuclidean_Default filter(
-        replacement, replace_color_within_range,
+    PixelTest_Rgb32Euclidean_Default tester(
         expected, max_euclidean_distance
     );
+    FilterImage_Rgb32_Default<PixelTest_Rgb32Euclidean_Default> filter(
+        tester, replacement, replace_color_within_range
+    );
     filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
     return filter.count();
 }
+size_t to_blackwhite_rgb32_euclidean_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 expected, double max_euclidean_distance
+){
+    PixelTest_Rgb32Euclidean_Default tester(
+        expected, max_euclidean_distance
+    );
+    ToBlackWhite_Rgb32_Default<PixelTest_Rgb32Euclidean_Default> filter(
+        tester, in_range_black
+    );
+    filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
+    return filter.count();
+}
+
+
+
 
 
 

SerialPrograms/Source/Kernels/ImageFilters/RGB32_EuclideanDistance/Kernels_ImageFilter_RGB32_Euclidean_x64_AVX2.cpp

@@ -7,55 +7,32 @@
 #ifdef PA_AutoDispatch_x64_13_Haswell
 
 #include <immintrin.h>
-#include "Kernels/Kernels_x64_AVX2.h"
 #include "Kernels/PartialWordAccess/Kernels_PartialWordAccess_x64_AVX2.h"
 #include "Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines.h"
+#include "Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX2.h"
 #include "Kernels_ImageFilter_RGB32_Euclidean.h"
 
 namespace PokemonAutomation{
 namespace Kernels{
 
 
-class ImageFilter_RgbEuclidean_x64_AVX2{
+
+class PixelTest_Rgb32Euclidean_x64_AVX2{
 public:
     static const size_t VECTOR_SIZE = 8;
     using Mask = PartialWordAccess32_x64_AVX2;
 
 public:
-    ImageFilter_RgbEuclidean_x64_AVX2(
-        uint32_t replacement, bool replace_color_within_range,
+    PA_FORCE_INLINE PixelTest_Rgb32Euclidean_x64_AVX2(
         uint32_t expected, double max_euclidean_distance
     )
-        : m_replacement(_mm256_set1_epi32(replacement))
-        , m_invert(replace_color_within_range ? _mm256_set1_epi32(-1) : _mm256_setzero_si256())
-        , m_expected_ag(_mm256_set1_epi32((expected >> 8) & 0x000000ff))
+        : m_expected_ag(_mm256_set1_epi32((expected >> 8) & 0x000000ff))
         , m_expected_rb(_mm256_set1_epi32(expected & 0x00ff00ff))
         , m_distance_squared(_mm256_set1_epi32((uint32_t)(max_euclidean_distance * max_euclidean_distance)))
-        , m_count(_mm256_setzero_si256())
     {}
 
-    PA_FORCE_INLINE size_t count() const{
-        return reduce_add32_x64_AVX2(m_count);
-    }
-
-    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
-        __m256i pixel = _mm256_loadu_si256((const __m256i*)in);
-        __m256i in_range_pixels = process_word(pixel);
-        m_count = _mm256_sub_epi32(m_count, in_range_pixels);
-        _mm256_storeu_si256((__m256i*)out, pixel);
-    }
-    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, const Mask& mask){
-        __m256i pixel = mask.load_i32(in);
-        __m256i in_range_pixels = process_word(pixel);
-        in_range_pixels = _mm256_and_si256(in_range_pixels, mask.mask());
-        m_count = _mm256_sub_epi32(m_count, in_range_pixels);
-        mask.store(out, pixel);
-    }
-
-private:
-    //  Process the pixel in-place.
     //  Return a mask indicating which lanes are in range.
-    PA_FORCE_INLINE __m256i process_word(__m256i& pixel) const{
+    PA_FORCE_INLINE __m256i test_word(__m256i pixel) const{
         __m256i ag = _mm256_and_si256(_mm256_srli_epi16(pixel, 8), _mm256_set1_epi32(0x000000ff));
         __m256i rb = _mm256_and_si256(pixel, _mm256_set1_epi32(0x00ff00ff));
 
@@ -70,30 +47,44 @@ class ImageFilter_RgbEuclidean_x64_AVX2{
         __m256i sum_sqr = _mm256_add_epi32(r, g);
         sum_sqr = _mm256_add_epi32(sum_sqr, b);
 
-        __m256i cmp = _mm256_cmpgt_epi32(m_distance_squared, sum_sqr);
-        pixel = _mm256_blendv_epi8(m_replacement, pixel, _mm256_xor_si256(cmp, m_invert));
-
-        return cmp;
+        return _mm256_cmpgt_epi32(m_distance_squared, sum_sqr);
     }
 
 private:
-    const __m256i m_replacement;
-    const __m256i m_invert;
     const __m256i m_expected_ag;
     const __m256i m_expected_rb;
     const __m256i m_distance_squared;
-    __m256i m_count;
 };
+
+
+
 size_t filter_rgb32_euclidean_x64_AVX2(
     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,
     uint32_t replacement, bool replace_color_within_range,
     uint32_t expected, double max_euclidean_distance
 ){
-    ImageFilter_RgbEuclidean_x64_AVX2 filter(
-        replacement, replace_color_within_range,
+    PixelTest_Rgb32Euclidean_x64_AVX2 tester(
         expected, max_euclidean_distance
     );
+    FilterImage_Rgb32_x64_AVX2<PixelTest_Rgb32Euclidean_x64_AVX2> filter(
+        tester, replacement, replace_color_within_range
+    );
+    filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
+    return filter.count();
+}
+size_t to_blackwhite_rgb32_euclidean_x64_AVX2(
+    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 expected, double max_euclidean_distance
+){
+    PixelTest_Rgb32Euclidean_x64_AVX2 tester(
+        expected, max_euclidean_distance
+    );
+    ToBlackWhite_Rgb32_x64_AVX2<PixelTest_Rgb32Euclidean_x64_AVX2> filter(
+        tester, in_range_black
+    );
     filter_per_pixel(in, in_bytes_per_row, width, height, filter, out, out_bytes_per_row);
     return filter.count();
 }