computer_vision/matching.cpp

/*******************************************************
 * Copyright (c) 2015, ArrayFire
 * All rights reserved.
 *
 * This file is distributed under 3-clause BSD license.
 * The complete license agreement can be obtained at:
 * http://arrayfire.com/licenses/BSD-3-Clause
 ********************************************************/
 
#include <arrayfire.h>
#include <cstdio>
#include <cstdlib>
#include <iostream>
 
using namespace af;
 
array normalize(array a) {
    float mx = af::max<float>(a);
    float mn = af::min<float>(a);
    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);
    // edge on left
    out(col_span, y, 0) = 0.f;
    out(col_span, y, 1) = 0.f;
    out(col_span, y, 2) = 1.f;
    // edge on right
    out(col_span, y + dim1, 0) = 0.f;
    out(col_span, y + dim1, 1) = 0.f;
    out(col_span, y + dim1, 2) = 1.f;
    // edge on top
    out(x, row_span, 0) = 0.f;
    out(x, row_span, 1) = 0.f;
    out(x, row_span, 2) = 1.f;
    // edge on bottom
    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) {
    // Load image
    array img_color;
    if (console)
        img_color = loadImage(ASSETS_DIR "/examples/images/square.png", true);
    else
        img_color = loadImage(ASSETS_DIR "/examples/images/man.jpg", true);
 
    // Convert the image from RGB to gray-scale
    array img  = colorSpace(img_color, AF_GRAY, AF_RGB);
    dim4 iDims = img.dims();
    std::cout << "Input image dimensions: " << iDims << std::endl << std::endl;
    // For visualization in ArrayFire, color images must be in the [0.0f-1.0f]
    // interval
 
    // extract a patch from input image
    unsigned patch_size = 100;
    array tmp_img =
        img(seq(100, 100 + patch_size, 1.0), seq(100, 100 + patch_size, 1.0));
    array result =
        matchTemplate(img, tmp_img);  // Default disparity metric is
                                      // Sum of Absolute differences (SAD)
                                      // Currently supported metrics are
                                      // AF_SAD, AF_ZSAD, AF_LSAD, AF_SSD,
                                      // AF_ZSSD, ASF_LSSD
    array disp_img = img / 255.0f;
    array disp_tmp = tmp_img / 255.0f;
    array disp_res = normalize(result);
 
    unsigned minLoc;
    float minVal;
    min<float>(&minVal, &minLoc, disp_res);
    std::cout << "Location(linear index) of minimum disparity value = "
              << minLoc << std::endl;
 
    if (!console) {
        // Draw a rectangle on input image where the template matches
        array marked_res = tile(disp_img, 1, 1, 3);
        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;
 
        af::Window wnd("Template Matching Demo");
 
        // Previews color image with green crosshairs
        while (!wnd.close()) {
            wnd.setColorMap(AF_COLORMAP_DEFAULT);
            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.setColorMap(AF_COLORMAP_HEAT);
            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 {
        af::setDevice(device);
        af::info();
        std::cout << "** ArrayFire template matching Demo **" << std::endl
                  << std::endl;
        templateMatchingDemo(console);
 
    } catch (af::exception& ae) {
        std::cerr << ae.what() << std::endl;
        throw;
    }
 
    return 0;
}