Experiment with ImageSearchAll with tolerance to color variation

ImagePut.ahk

@@ -2839,6 +2839,12 @@ class ImagePut {
       }
 
       ImageSearch(image) {
+         ; FIXME Since I haven't install the GCC libraries for 32bit libraries and build 32bit binary, it won't work on 32-bit systems, Thank you for your understanding!
+         if ( A_PtrSize == 4 ) {
+           MsgBox("Since I haven't install the GCC libraries for 32bit libraries and build 32bit binary, it won't work on 32-bit systems, Thank you for your understanding!")
+           return False
+         }
+
          ; C source code - https://godbolt.org/z/cKxrrT4ss
          code := this.Base64Code((A_PtrSize == 4)
             ? "VYnlV1ZTg+wgi0Uki1UYi30Ui00gD6/Qi3UIix8Pr0UMAcqJXeSLHJeLfQwByItVECtVHIlF7MHnAold4ItdDA+v1ytdGANVCIlV"
@@ -2867,47 +2873,75 @@ class ImagePut {
          return [mod(offset, this.width), offset // this.width]
       }
 
-      ImageSearchAll(image) {
+      ImageSearchAll(image, variation := 0) {
+         ; FIXME Since I haven't install the GCC libraries for 32bit libraries and build 32bit binary, it won't work on 32-bit systems, Thank you for your understanding!
+         if ( A_PtrSize == 4 ) {
+           MsgBox("Since I haven't install the GCC libraries for 32bit libraries and build 32bit binary, it won't work on 32-bit systems, Thank you for your understanding!")
+           return False
+         }
+
          ; C source code - https://godbolt.org/z/qPodGdP1d
          code := this.Base64Code((A_PtrSize == 4)
             ? "VYnlV1ZTg+wUi0UMi1UYi00IjTyFAAAAAItFECtFHA+vxwNFCIlF6ItFDCnQiUXkjQSVAAAAAIlF7ItF6DnBc2eLRRSLADkBdAmL"
             . "RRSAeAMAdVCJyCtFCDHSwfgC93UMOVXkfD4x0otFFInLiVXwi3XwO3UcdDyLVeyJ3gHCiVXgi1XgOdBzFIB4AwB0BosWORB1D4PA"
             . "BIPGBOvl/0XwAfvrzIPBBOuSi0UQD6/HA0UIicGDxBSJyFteX13D"
-            : "QVdBVkFVQVRVV1ZTSIPsGEUx20SLpCSYAAAAi4QkgAAAAESLlCSQAAAASIu8JIgAAABEKeBBD6/BSInLidZMicFNjSyARInIRCnQ"
-            . "iUQkDEqNBJUAAAAASIkEJEw56XN0iwc5AXQGgH8DAHViSInIMdJMKcBIwfgCQffxOVQkDHxNSIn4Me0x0kQ54nQyTIs8JEGJ7k6N"
-            . "NLFJAcdMOfhzGIB4AwB0CEWLFkQ5EHUgSIPABEmDxgTr4//CRAHN68lBOfNzB0SJ2EiJDMNB/8NIg8EE64dEidhIg8QYW15fXUFc"
-            . "QV1BXkFfww==")
+            : "QVdBVkFVQVRVV1ZTSIPsSIuEJNAAAACLtCTIAAAARImMJKgAAABED7eMJNgAAABIiYwkkAAAAImUJJgAAABMiYQkoAAAAIXAD4Xa"
+            . "AwAARIuUJMAAAACJ8kSLnCTAAAAAweoCD6+UJMAAAACLjCTAAAAARA+v1kHB6wJIi7wkuAAAAESJ2EgBwkWJ0EiNFJdMAcFIjRyP"
+            . "SDnaD4MOAwAARIuEJMAAAABB0ehJweACSo0MAkg50XcW6ZMDAAAPH0AASIPCBEg50Q+G1AIAAIB6AwB07UiJ0EgrhCS4AAAAMdJI"
+            . "wfgC97QkwAAAAGaJVCQwRA+3wg+30InRD6+MJMAAAACJVCQ0TAHBSMHhAkiLhCS4AAAASIu8JKAAAABEi6wkqAAAAEQrrCTAAAAA"
+            . "iwQIi4wksAAAACnxD6+MJKgAAABIjSyPSDnvD4PtAgAAD6+UJKgAAABJiftFicrHRCQsAAAAAEH32kwBwkiNPJUAAAAAi5QkwAAA"
+            . "AEiNXwFIiXwkCEiDxwJIiVwkEIucJKgAAABIiXwkIEiNPJUAAAAASYncSIlcJDiLnCTAAAAASSnUjVP/ScHkAkiNHJUAAAAAD7bQ"
+            . "ZolUJCgPttTB6BAPtsBIiRwkMduJVCQcZolEJCrrFg8fgAAAAABMAxwkMdtJOesPgwoBAABEOet37EiLRCQIQQ+2FAMPt0QkKCnQ"
+            . "ZkE5wXMKZkQ50A+CyAAAAEiLRCQQQQ+2FAMPt0QkHCnQZkE5wXMKZkQ50A+CpwAAAEiLRCQgQQ+2FAMPt0QkKinQZkE5wXMKZkQ5"
+            . "0A+ChgAAAEiLhCS4AAAATInaRTH/hfYPhNsAAABMjQQ4STnAdxvpzQAAAA8fRAAASIPABEiDwgRJOcAPhqcAAACAeAMAdOkPtghE"
+            . "D7YyRCnxZkE5yXMGZkQ50XIwD7ZIAUQPtnIBRCnxZkE5yXMGZkQ50XIYD7ZIAkQPtnICRCnxZkE5yXOpZkQ50XOjSYPDBIPDATHA"
+            . "O5wkqAAAAA9D2Ek56w+C9v7//4tEJCxIi7QkkAAAAAHASI0EhkiJhCSQAAAASInGi0QkMMHgEAtEJDSJBotEJCxIg8RIW15fXUFc"
+            . "QV1BXkFfw0GDxwFMAeJEOf4PhSX///+LTCQsOYwkmAAAAHYwTInYSCuEJKAAAABIwfgCSJlI93wkOGYPbsJIi5QkkAAAAGYPOiLA"
+            . "AY0ECWYP1gSCg0QkLAFJAfsDnCTAAAAA6Uv///9MAcJIOdMPhwH9//9Ii7wkuAAAADHJRTHAMdJmRIlEJDCAfA8DAIlUJDQPhTv9"
+            . "//+LjCTAAAAAQY1T/0QrlCTAAAAASMHgAkwB0kj32EQp2UiNFJdIweECSPfZSYnQSQHAchXrUWYuDx+EAAAAAABIg+oESTnQcz6A"
+            . "egMAdPHpr/z//w8fQABBicBBwegQZkSJRCQw6br8///HRCQsAAAAAEiLtCSQAAAA6c/+//9IicrpTf///0gByuug")
+            ;: "QVdBVkFVQVRVV1ZTSIPsGEUx20SLpCSYAAAAi4QkgAAAAESLlCSQAAAASIu8JIgAAABEKeBBD6/BSInLidZMicFNjSyARInIRCnQ"
+            ;. "iUQkDEqNBJUAAAAASIkEJEw56XN0iwc5AXQGgH8DAHViSInIMdJMKcBIwfgCQffxOVQkDHxNSIn4Me0x0kQ54nQyTIs8JEGJ7k6N"
+            ;. "NLFJAcdMOfhzGIB4AwB0CEWLFkQ5EHUgSIPABEmDxgTr4//CRAHN68lBOfNzB0SJ2EiJDMNB/8NIg8EE64dEidhIg8QYW15fXUFc"
+            ;. "QV1BXkFfww==")
 
          ; Convert image to a buffer object.
          if !(IsObject(image) && ObjHasOwnProp(image, "ptr") && ObjHasOwnProp(image, "size"))
             image := ImagePutBuffer(image)
 
+         ; Check if the object has the coordinates.
+         coord_focus := ObjHasOwnProp(image, "coord_focus") ? image.coord_focus : 0
+
          ; Search for the address of the first matching image.
          capacity := 256
-         result := Buffer(A_PtrSize * capacity)
+         result := Buffer(2 * 4 * capacity + 4)
          count := DllCall(code, "ptr", result, "uint", capacity
                            , "ptr", this.ptr, "uint", this.width, "uint", this.height
-                           , "ptr", image.ptr, "uint", image.width, "uint", image.height, "cdecl uint")
+                           , "ptr", image.ptr, "uint", image.width, "uint", image.height
+                           , "UInt", coord_focus, "UShort", variation, "cdecl uint")
 
-         ; If more than 256 results, run the function with the true capacity.
-         if (count > capacity) {
-            result.size := A_PtrSize * count
-            count := DllCall(code, "ptr", result, "uint", capacity
-                           , "ptr", this.ptr, "uint", this.width, "uint", this.height
-                           , "ptr", image.ptr, "uint", image.width, "uint", image.height, "cdecl uint")
-         }
+         ; Prevent another search for focused pixel
+         image.coord_focus := NumGet(result, 2*4*count, "UInt")
+         coord_focus := image.coord_focus
 
          ; Check if any matches are found.
          if (count = 0)
             return False
 
+         ; If more than 256 results, run the function with the true capacity.
+         if (count > capacity) {
+            result.Size := 2 * 4 * count + 4
+            count := DllCall(code, "ptr", result, "uint", count
+                           , "ptr", this.ptr, "uint", this.width, "uint", this.height
+                           , "ptr", image.ptr, "uint", image.width, "uint", image.height
+                           , "UInt", coord_focus, "UShort", variation, "cdecl uint")
+         }
+
          ; Create an array of [x, y] coordinates.
          xys := []
-         xys.count := count
          loop count {
-            address := NumGet(result, A_PtrSize*(A_Index-1), "ptr")
-            offset := (address - this.ptr) // 4
-            xy := [mod(offset, this.width), offset // this.width]
+            xy := [NumGet(result, 2*4*(A_Index-1), "UInt"),
+               NumGet(result, 2*4*(A_Index-1) + 4, "UInt")]
             xys.push(xy)
          }
          return xys

source/imagesearch2.c

@@ -0,0 +1,156 @@
+__attribute__((ms_abi))  // Tells GCC we want to compile for Windows.
+__attribute__ ((target ("sse4.2")))  // According to godbolt.org it doesn't do anything even with
+                                     // __builtin_assume_aligned(ptr, 16) and -Ofast -msse4.2.
+                                     // You might want to study SIMD instructions and if there is a good instruction to
+                                     // take advantage of, go with inline assembly.
+unsigned int imagesearch2(unsigned int * restrict result, unsigned int * start, unsigned int width, unsigned int height, unsigned int * s, unsigned int w, unsigned int h, unsigned int coord_focus, unsigned short variation) {
+    // width, height, start, current, end, color refer to the haystack (main image)
+    // x, y, w, h, s, c, e, cf refer to the needle (search image)
+    // The location of the focused pixel
+    unsigned short x;
+    unsigned short y;
+
+    if ( coord_focus ) {
+        x = coord_focus >> sizeof(x)*8;
+        y = coord_focus & 0x0000ffff;
+        goto focus_determined;
+    }
+
+    // Try to locate the focused pixel in the middle of the sprite
+    unsigned int * c = s + w/4 + h/4 * w;
+    unsigned int * last_pixel = s + w + h * w;
+    while(c < last_pixel) {
+        for (unsigned int * e = c + w / 2; c < e; c++) {
+            if ( *((unsigned char *) c + 3) ) {
+                unsigned int offset = (c - s);
+                x = offset % w;
+                y = offset / w;
+                goto focus_determined;
+            }
+        }
+        c += w / 2;
+    }
+
+    // If every pixel in the middle was transparent
+    // try to find a non-transparent pixel on the left-hand side.
+
+    // This falls into an infinite loop if somehow the sprite doesn't have any
+    // non-transparent pixel in the leftmost quarter.
+    if ( *((unsigned char *)(s + x + y * w) + 3) == 0 ) {
+        unsigned int * c = s + (w/4-1) + (h-1) * w;
+        while(-1) {
+            for (unsigned int * e = c - w / 4; c > e; c--) {
+                if ( *((unsigned char *) c + 3) ) {
+                    unsigned int offset = (c - s);
+                    x = offset % w;
+                    y = offset / w;
+                    goto focus_determined;
+                }
+            }
+            c -= w - w / 4;
+        }
+    }
+
+    focus_determined:;
+
+    // Hide the coordinates of the focused pixel
+    *(result + 2) = x << sizeof(x)*8 | y;
+
+
+
+    // Prepare the search.
+
+    // The color on the focused pixel
+    unsigned int cf = *(s + x + y * w);
+
+    // We don't need to search in the narrow edge on the right-hand side
+    unsigned int range_width = width - w;
+    // Remaining area must be greater than search height
+    unsigned int range_height = height - h;
+
+    unsigned int * current = start;
+    unsigned int * end = start + width * range_height;
+
+    // Start the search.
+    unsigned int left = 0;
+    while ( current < end ) {
+
+        unsigned int offset = current - start;
+        //unsigned int left = offset % width;
+        // TODO Remove the comment below
+        // I believe div is worse than cmov'ing one constant number.
+        // The code loses some readability though.
+        unsigned int top = offset / width;  // optimized away
+
+        // Checks before subimage loop.
+
+        // X-Range Check
+        if ( left > range_width ) {
+            current += w - 1;
+            left = 0;
+            continue;
+        }
+        // 
+
+        // Focused Pixel
+        unsigned int * color;
+        color = current + x + y * width;
+        for (int b = 0; b < 3; b++) {
+            unsigned short diff = *((unsigned char *)&cf + b) - *((unsigned char *)color + b);
+            if ( diff > variation && diff < (unsigned short)(0 - variation) ) {
+                current++;
+                left++;
+                goto next;
+            }
+        }
+
+        // Subimage loop.
+        unsigned int * c = s;
+        color = current;
+        for (int i = 0; i < h; i++) {
+            unsigned int * e = c + w;
+            while (c < e) {
+                if ( *((unsigned char *) c + 3) ) {  // Skip transparent pixels
+                    for (int b = 0; b < 3; b++) {
+                        unsigned short diff = *((unsigned char *) c + b) - *((unsigned char *) color + b);
+                        if ( diff > variation && diff < (unsigned short)(0 - variation) ) {
+                            current++;
+                            left++;
+                            goto next;
+                        }
+                    }
+                }
+                c++;  // Iterate over the needle image
+                color++;  // Iterate over the haystack image
+            }
+            color = color - w + width;  // Reset pointer for each scanline
+        }
+
+        // Found a matching image!
+        *(result) = (current - start) % width;
+        *(result + 1) = (current - start) / width;
+        return 1;
+
+        next:
+        if ( left >= width ) {
+            left = 0;
+        }
+    }
+
+// TODO Remove the comment below for clean code
+//
+// This is how I checked the input data, writing the first few pixels at s or start
+// and then ImagePutClipboard and check each pixel's color in GIMP.
+//
+// It seems loading with ({sprite: fpath}) gives you the right buffer but
+// loading with (fpath, transparent_color) gives a buffer with no transparent pixels
+// even if the file had pixels with the matching transparent_color.
+//
+//for ( unsigned int k = 0; k < w*h/2; k++ ) {
+//  *(result+k) = *(s + k%32);
+//}
+//return (w*h)/2/2;
+//
+
+    return 0;
+}

source/imagesearchall2.c

@@ -0,0 +1,164 @@
+__attribute__((ms_abi))  // Tells GCC we want to compile for Windows.
+__attribute__ ((target ("sse4.2")))  // According to godbolt.org it doesn't do anything even with
+                                     // __builtin_assume_aligned(ptr, 16) and -Ofast -msse4.2.
+                                     // You might want to study SIMD instructions and if there is a good instruction to
+                                     // take advantage of, go with inline assembly.
+unsigned int imagesearchall2(unsigned int * restrict result, unsigned int capacity, unsigned int * start, unsigned int width, unsigned int height, unsigned int * s, unsigned int w, unsigned int h, unsigned int coord_focus, unsigned short variation ) {
+    // width, height, start, current, end, color refer to the haystack (main image)
+    // x, y, w, h, s, c, e, cf refer to the needle (search image)
+    unsigned int count = 0;
+
+    // The location of the focused pixel
+    unsigned short x;
+    unsigned short y;
+
+    if ( coord_focus ) {
+        x = coord_focus >> sizeof(x)*8;
+        y = coord_focus & 0x0000ffff;
+        goto focus_determined;
+    }
+
+    // Try to locate the focused pixel in the middle of the sprite
+    unsigned int * c = s + w/4 + h/4 * w;
+    unsigned int * last_pixel = s + w + h * w;
+    while(c < last_pixel) {
+        for (unsigned int * e = c + w / 2; c < e; c++) {
+            if ( *((unsigned char *) c + 3) ) {
+                unsigned int offset = (c - s);
+                x = offset % w;
+                y = offset / w;
+                goto focus_determined;
+            }
+        }
+        c += w / 2;
+    }
+
+    // If every pixel in the middle was transparent
+    // try to find a non-transparent pixel on the left-hand side.
+
+    // This falls into an infinite loop if somehow the sprite doesn't have any
+    // non-transparent pixel in the leftmost quarter.
+    if ( *((unsigned char *)(s + x + y * w) + 3) == 0 ) {
+        unsigned int * c = s + (w/4-1) + (h-1) * w;
+        while(-1) {
+            for (unsigned int * e = c - w / 4; c > e; c--) {
+                if ( *((unsigned char *) c + 3) ) {
+                    unsigned int offset = (c - s);
+                    x = offset % w;
+                    y = offset / w;
+                    goto focus_determined;
+                }
+            }
+            c -= w - w / 4;
+        }
+    }
+
+    focus_determined:;
+
+
+
+    // Prepare the search.
+
+    // The color on the focused pixel
+    unsigned int cf = *(s + x + y * w);
+
+    // We don't need to search in the narrow edge on the right-hand side
+    unsigned int range_width = width - w;
+    // Remaining area must be greater than search height
+    unsigned int range_height = height - h;
+
+    unsigned int * current = start;
+    unsigned int * end = start + width * range_height;
+
+    // Start the search.
+    unsigned int left = 0;
+    while ( current < end ) {
+
+        unsigned int offset = current - start;
+        //unsigned int left = offset % width;
+        // TODO Remove the comment below
+        // I believe div is worse than cmov'ing one constant number.
+        // The code loses some readability though.
+        unsigned int top = offset / width;  // optimized away
+
+        // Checks before subimage loop.
+
+        // X-Range Check
+        if ( left > range_width ) {
+            current += w - 1;
+            left = 0;
+            continue;
+        }
+        // 
+
+        // Focused Pixel
+        unsigned int * color;
+        color = current + x + y * width;
+        for (int b = 0; b < 3; b++) {
+            unsigned short diff = *((unsigned char *)&cf + b) - *((unsigned char *)color + b);
+            if ( diff > variation && diff < (unsigned short)(0 - variation) ) {
+                current++;
+                left++;
+                goto next;
+            }
+        }
+
+        // Subimage loop.
+        unsigned int * c = s;
+        color = current;
+        for (int i = 0; i < h; i++) {
+            unsigned int * e = c + w;
+            while (c < e) {
+                if ( *((unsigned char *) c + 3) ) {  // Skip transparent pixels
+                    for (int b = 0; b < 3; b++) {
+                        unsigned short diff = *((unsigned char *) c + b) - *((unsigned char *) color + b);
+                        if ( diff > variation && diff < (unsigned short)(0 - variation) ) {
+                            current++;
+                            left++;
+                            goto next;
+                        }
+                    }
+                }
+                c++;  // Iterate over the needle image
+                color++;  // Iterate over the haystack image
+            }
+            color = color - w + width;  // Reset pointer for each scanline
+        }
+
+        // Found a matching image!
+        if ( count < capacity ) {
+            *(result + count * 2) = (current - start) % width;
+            *(result + count * 2 + 1) = (current - start) / width;
+        }
+        count++;
+
+        // XXX Let us not deal with overlapped matches
+        current += w;
+        left += w;
+
+        next:
+        if ( left >= width ) {
+            left = 0;
+        }
+    }
+
+    // Hide the coordinates of the focused pixel
+    *(result + count * 2) = x << sizeof(x)*8 | y;
+
+// TODO Remove the comment below for clean code
+//
+// This is how I checked the input data, writing the first few pixels at s or start
+// and then ImagePutClipboard and check each pixel's color in GIMP.
+//
+// It seems loading with ({sprite: fpath}) gives you the right buffer but
+// loading with (fpath, transparent_color) gives a buffer with no transparent pixels
+// even if the file had pixels with the matching transparent_color.
+//
+//for ( unsigned int k = 0; k < w*h/2; k++ ) {
+//  *(result+k) = *(s + k%32);
+//}
+//return (w*h)/2/2;
+//
+
+    return count;
+}