#include <cstdio>
#include <cstdlib>
#include <iostream>
 
 
    return (a - mn) / (mx - mn);
}
 
void drawRectangle(
array& out, 
unsigned x, 
unsigned y, 
unsigned dim0,
 
                   unsigned dim1) {
    printf("\nMatching patch origin = (%u, %u)\n\n", x, y);
    seq col_span(x, x + dim0, 1);
 
    seq row_span(y, y + dim1, 1);
 
    
    out(col_span, y, 0) = 0.f;
    out(col_span, y, 1) = 0.f;
    out(col_span, y, 2) = 1.f;
    
    out(col_span, y + dim1, 0) = 0.f;
    out(col_span, y + dim1, 1) = 0.f;
    out(col_span, y + dim1, 2) = 1.f;
    
    out(x, row_span, 0) = 0.f;
    out(x, row_span, 1) = 0.f;
    out(x, row_span, 2) = 1.f;
    
    out(x + dim0, row_span, 0) = 0.f;
    out(x + dim0, row_span, 1) = 0.f;
    out(x + dim0, row_span, 2) = 1.f;
}
 
static void templateMatchingDemo(bool console) {
    
    if (console)
        img_color = 
loadImage(ASSETS_DIR 
"/examples/images/square.png", 
true);
    else
        img_color = 
loadImage(ASSETS_DIR 
"/examples/images/man.jpg", 
true);
 
    
    std::cout << "Input image dimensions: " << iDims << std::endl << std::endl;
    
    
 
    
    unsigned patch_size = 100;
        img(
seq(100, 100 + patch_size, 1.0), 
seq(100, 100 + patch_size, 1.0));
                                      
                                      
                                      
                                      
    array disp_img = img / 255.0f;
 
    array disp_tmp = tmp_img / 255.0f;
 
    array disp_res = normalize(result);
 
 
    unsigned minLoc;
    float minVal;
    std::cout << "Location(linear index) of minimum disparity value = "
              << minLoc << std::endl;
 
    if (!console) {
        
        drawRectangle(marked_res, minLoc % iDims[0], minLoc / iDims[0],
                      patch_size, patch_size);
 
        std::cout << "Note: Based on the disparity metric option provided to "
                     "matchTemplate function\n"
                     "either minimum or maximum disparity location is the "
                     "starting corner\n"
                     "of our best matching patch to template image in the "
                     "search image"
                  << std::endl;
 
 
        
        while (!wnd.close()) {
            wnd.grid(2, 2);
            wnd(0, 0).image(disp_img, "Search Image");
            wnd(0, 1).image(disp_tmp, "Template Patch");
            wnd(1, 0).image(marked_res, "Best Match");
            wnd(1, 1).image(disp_res, "Disparity values");
            wnd.show();
        }
    }
}
 
int main(int argc, char** argv) {
    int device   = argc > 1 ? atoi(argv[1]) : 0;
    bool console = argc > 2 ? argv[2][0] == '-' : false;
 
    try {
        std::cout << "** ArrayFire template matching Demo **" << std::endl
                  << std::endl;
        templateMatchingDemo(console);
 
        std::cerr << ae.
what() << std::endl;
        throw;
    }
 
    return 0;
}
Window object to render af::arrays.
A multi dimensional data container.
dim4 dims() const
Get dimensions of the array.
Generic object that represents size and shape.
An ArrayFire exception class.
virtual const char * what() const
Returns an error message for the exception in a string format.
seq is used to create sequences for indexing af::array
@ AF_COLORMAP_DEFAULT
Default grayscale map.
@ AF_COLORMAP_HEAT
Heat map.
array matchTemplate(const array &searchImg, const array &templateImg, const matchType mType=AF_SAD)
C++ Interface for image template matching.
void setDevice(const int device)
Sets the current device.
array colorSpace(const array &image, const CSpace to, const CSpace from)
C++ Interface wrapper for colorspace conversion.
array loadImage(const char *filename, const bool is_color=false)
C++ Interface for loading an image.
array tile(const array &in, const unsigned x, const unsigned y=1, const unsigned z=1, const unsigned w=1)
C++ Interface to generate a tiled array.
array max(const array &in, const int dim=-1)
C++ Interface to return the maximum along a given dimension.
array min(const array &in, const int dim=-1)
C++ Interface to return the minimum along a given dimension.