Can you tell me how to produce the Base64 encoded code for a C function?

[wind0204]

I'd like to allow ImageSearchAll function to have tolerance(variation) in each pixel comparison, but do not know how to get the Base64 encoded code to DllCall in Autohotkey.

Thanks in advance!

@@ -1,4 +1,4 @@
-unsigned int * imagesearch(unsigned int * start, unsigned int width, unsigned int height, unsigned int * s, unsigned int w, unsigned int h) 
>+unsigned int * imagesearch(unsigned int * start, unsigned int width, unsigned int height, unsigned int * s, unsigned int w, unsigned int , unsigned int variation) {
     // width, height, start, current, end refer to the haystack (main image)
     // x, y, w, h, s, c, e refer to the needle (search image)
 
@@ -35,7 +35,7 @@
                 e = c + w;
                 while (c < e) {
                     if (*((unsigned char *) c + 3)) { // skip transparent pixels in search image
-                        if (*c != *p)
+                        if (*c - *p > variation && *c - *p < (0 - variation))
                             goto next;
                     }
                     c++; // Here simply incrementing will interate the entire image

[iseahound]

Use McodeForGCC.
https://github.com/joedf/MCode4GCC
You may need to enable SSE2 flags to compile for x86.

The ImageSearch you're editing happens to be outdated. This one is currrent (it's a comment in ImagePut.ahk).
https://godbolt.org/z/cKxrrT4ss

The difference between the two versions is that this one essentially does a parallel pixel search of 2 pixels, where the first is the top left, and the 2nd pixel is specified by an (x, y) coordinate. This approach minimizes time spent in the subimage loop.

I never got around to optimizing the above code using SSE2 128-bit wide intrinsics. If you browse through the current approach for PixelSearch, you can see just how much work is needed.

Feel free to make a pull request even for an unoptimized version.

[wind0204]

Thank you for the fast reply! I'll try to get things work but, let you benchmark and check if it's optimized well ;-p

[iseahound]

Adding ImageSearch with variation was stalled because I didn't want to implement something slow. ImageSearch by itself was already troubling slow (albeit many times faster than Python's template matching). You can think of the problem like this:

1. Search for a matching pixel. (Linear search, fast)
2. If found, match the image with the source. (Subimage loop, slow)
3. Variation (Even slower)

You can play around with the order of operations:

    if (c4 == *(current + x + y * width) // Rank 1 - Focused Pixel
    &&  c1 == *(current)                 // Rank 2 - First Pixel
    && (left <= range_width)             // Rank 3 - X-Range Check

but generally, I found this to work best.

[wind0204]

I've made a pull request, please take a look. #36

[wind0204]

Oops, I guess the patch I showed in the post seems to only compare the alpha value, 😆

[wind0204]

the whole value actually, in a reckless way ;-p

[iseahound]

In case it helps, the approach I would take is similar to pixelsearch4:

https://github.com/iseahound/ImagePut/blob/master/source/pixelsearch4.c

To optimize the calculation, do the addition and subtraction first, to create "high" and "low" search images. Then check if the current pixel is less than the "high" and greater than the "low". This is faster because you aren't doing a (pixel + variation) calculation for every instance of the subimage loop.

[iseahound]

So your header might change to:

unsigned int * imagesearch(unsigned int * start, unsigned int width, unsigned int height, unsigned int * h, unsigned int * l, unsigned int w, unsigned int x, unsigned int y)

Note variation has disappeared because the image should be preprocessed into two "high" and "low" images.

Feel free to do as you wish however — some progress is better than none 😂

[iseahound]

AI generated comments: Lightly edited for accuracy.

unsigned int * pixelsearch4(unsigned int * start, unsigned int * end, unsigned int * high, unsigned int * low, unsigned int length) {
    // This function searches for a pixel that matches a given color range, [where the image is a 1D array]
    // The parameters are pointers to unsigned integers that represent the pixel values in [ARGB] format. [But alpha is ignored]
    // start and end are the pointers to the first and last pixels of the region to search, respectively. [wrong]
    // high and low are the pointers to the arrays of upper and lower bounds of the color range, respectively.
    // length is the number of elements in the high and low arrays, which should be the same.
    // The function returns a pointer to the first matching pixel, or the end pointer if no match is found.

    unsigned char r, g, b, rh, gh, bh, rl, gl, bl; // Declare variables to store the red, green, and blue components of the pixels and the color range
    while (start < end) { // Loop through the pixels from start to end

// [note: ARGB, as in 0xAABBCCDD means the zero offset is DD, the 1 offset is CC and so on. This is due to Little Endian encoding]

        r = *((unsigned char *) start + 2); // Get the red component of the current pixel by casting the pointer to unsigned char and adding 2
        g = *((unsigned char *) start + 1); // Get the green component of the current pixel by casting the pointer to unsigned char and adding 1
        b = *((unsigned char *) start + 0); // Get the blue component of the current pixel by casting the pointer to unsigned char and adding 0

        for (int i = 0; i < length; i++) { // Loop through the color range arrays

            rh = *((unsigned char *) high + 4*i + 2); // Get the upper bound of the red component for the i-th element of the color range by casting the pointer to unsigned char and adding 4*i + 2
            gh = *((unsigned char *) high + 4*i + 1); // Get the upper bound of the green component for the i-th element of the color range by casting the pointer to unsigned char and adding 4*i + 1
            bh = *((unsigned char *) high + 4*i + 0); // Get the upper bound of the blue component for the i-th element of the color range by casting the pointer to unsigned char and adding 4*i + 0
            rl = *((unsigned char *) low + 4*i + 2); // Get the lower bound of the red component for the i-th element of the color range by casting the pointer to unsigned char and adding 4*i + 2
            gl = *((unsigned char *) low + 4*i + 1); // Get the lower bound of the green component for the i-th element of the color range by casting the pointer to unsigned char and adding 4*i + 1
            bl = *((unsigned char *) low + 4*i + 0); // Get the lower bound of the blue component for the i-th element of the color range by casting the pointer to unsigned char and adding 4*i + 0

            if (rh >= r && r >= rl && gh >= g && g >= gl && bh >= b && b >= bl) // Check if the current pixel matches the i-th element of the color range
                return start; // If yes, return the pointer to the current pixel
        }
        start++; // If no, increment the pointer to the next pixel
    }
    return start; // If no match is found, return the end pointer
}

[martona]

actually you should use this :)

https://github.com/martona/ahkmcodegen