/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                           License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include "cvtest.h"
#include <string>
#include <iostream>
#include <iterator>
#include <fstream>
#include <numeric>
#include <algorithm>
#include <iterator>
#include "cvaux.h"

using namespace cv;
using namespace std;

class CV_DetectorsTest : public CvTest
{
public:
    CV_DetectorsTest();
    ~CV_DetectorsTest();    
protected:    
    void run(int);  
    template <class T> bool testDedector(const Mat& img, const T& detector, vector<KeyPoint>& expected);

    void LoadExpected(const string& file, vector<KeyPoint>& out);
};

CV_DetectorsTest::CV_DetectorsTest(): CvTest( "feature-detectors", "?" )
{
    support_testing_modes = CvTS::CORRECTNESS_CHECK_MODE;
}
CV_DetectorsTest::~CV_DetectorsTest() {}

void getRotation(const Mat& img, Mat& aff, Mat& out)
{
    Point center(img.cols/2, img.rows/2);
    aff = getRotationMatrix2D(center, 30, 1);
    warpAffine( img, out, aff, img.size());
}

void getZoom(const Mat& img, Mat& aff, Mat& out)
{
    const double mult = 1.2;

    aff.create(2, 3, CV_64F);
    double *data = aff.ptr<double>();
    data[0] = mult; data[1] =    0; data[2] = 0;
    data[3] =    0; data[4] = mult; data[5] = 0;
    
    warpAffine( img, out, aff, img.size());
}

void getBlur(const Mat& img, Mat& aff, Mat& out)
{        
    aff.create(2, 3, CV_64F);
    double *data = aff.ptr<double>();
    data[0] = 1; data[1] = 0; data[2] = 0;
    data[3] = 0; data[4] = 1; data[5] = 0;
        
    GaussianBlur(img, out, Size(5, 5), 2);    
}

void getBrightness(const Mat& img, Mat& aff, Mat& out)
{        
    aff.create(2, 3, CV_64F);
    double *data = aff.ptr<double>();
    data[0] = 1; data[1] = 0; data[2] = 0;
    data[3] = 0; data[4] = 1; data[5] = 0;
        
    add(img, Mat(img.size(), img.type(), Scalar(15)), out);    
}

void showOrig(const Mat& img, const vector<KeyPoint>& orig_pts)
{
      
    Mat img_color;
    cvtColor(img, img_color, CV_GRAY2BGR); 
    
    for(size_t i = 0; i < orig_pts.size(); ++i)    
        circle(img_color, orig_pts[i].pt, (int)orig_pts[i].size/2, CV_RGB(0, 255, 0));                        
    
    namedWindow("O"); imshow("O", img_color);     
}

void show(const string& name, const Mat& new_img, const vector<KeyPoint>& new_pts, const vector<KeyPoint>& transf_pts)
{
      
    Mat new_img_color;    
    cvtColor(new_img, new_img_color, CV_GRAY2BGR); 

    for(size_t i = 0; i < transf_pts.size(); ++i)
        circle(new_img_color, transf_pts[i].pt, (int)transf_pts[i].size/2, CV_RGB(255, 0, 0));

    for(size_t i = 0; i < new_pts.size(); ++i)    
        circle(new_img_color, new_pts[i].pt, (int)new_pts[i].size/2, CV_RGB(0, 0, 255));
    
    namedWindow(name + "_T"); imshow(name + "_T", new_img_color); 
}

struct WrapPoint
{
    const double* R;
    WrapPoint(const Mat& rmat) : R(rmat.ptr<double>()) { };
    
    KeyPoint operator()(const KeyPoint& kp) const 
    {                
        KeyPoint res = kp;
        res.pt.x = static_cast<float>(kp.pt.x * R[0] + kp.pt.y * R[1] + R[2]);
        res.pt.y = static_cast<float>(kp.pt.x * R[3] + kp.pt.y * R[4] + R[5]);                
        return res;                             
    }
};

struct sortByR { bool operator()(const KeyPoint& kp1, const KeyPoint& kp2) { return norm(kp1.pt) < norm(kp2.pt); } };

template <class T> bool CV_DetectorsTest::testDedector(const Mat& img, const T& detector, vector<KeyPoint>& exp)
{
    vector<KeyPoint> orig_kpts;
    detector(img, orig_kpts);

    typedef void (*TransfFunc )(const Mat&, Mat&, Mat& FransfFunc);    
    const TransfFunc transfFunc[] = { getRotation, getZoom, getBlur, getBrightness };
    //const string names[] =  { "Rotation", "Zoom", "Blur", "Brightness" };
    const size_t case_num = sizeof(transfFunc)/sizeof(transfFunc[0]);

    vector<Mat> affs(case_num);
    vector<Mat> new_imgs(case_num);

    vector< vector<KeyPoint> > new_kpts(case_num);
    vector< vector<KeyPoint> > transf_kpts(case_num);

    //showOrig(img, orig_kpts);
    for(size_t i = 0; i < case_num; ++i)   
    {
        transfFunc[i](img, affs[i], new_imgs[i]);
        detector(new_imgs[i], new_kpts[i]);
        transform(orig_kpts.begin(), orig_kpts.end(), back_inserter(transf_kpts[i]), WrapPoint(affs[i]));
        //show(names[i], new_imgs[i], new_kpts[i], transf_kpts[i]);
    }

    const float thres = 3;
    const float nthres = 3;

    vector<KeyPoint> result;
    for(size_t i = 0; i < orig_kpts.size(); ++i)
    {
        const KeyPoint& okp = orig_kpts[i];
        int foundCounter = 0;
        for(size_t j = 0; j < case_num; ++j)
        {            
            const KeyPoint& tkp = transf_kpts[j][i];

            size_t k = 0;
            
            for(; k < new_kpts[j].size(); ++k)
                if (norm(new_kpts[j][k].pt - tkp.pt) < nthres && fabs(new_kpts[j][k].size - tkp.size) < thres)
                    break;

            if (k != new_kpts[j].size())
                ++foundCounter;

        }
        if (foundCounter == (int)case_num)
            result.push_back(okp);
    }

    sort(result.begin(), result.end(), sortByR());
    sort(exp.begin(), exp.end(), sortByR());    

    int foundCounter1 = 0;
    for(size_t i = 0; i < exp.size(); ++i)
    {
        const KeyPoint& e = exp[i];                
        size_t j = 0;
        for(; j < result.size(); ++j)
        {
            const KeyPoint& r = result[i];
            if (norm(r.pt-e.pt) < nthres && fabs(r.size - e.size) < thres)
                break;
        }
        if (j != result.size())
            ++foundCounter1;
    }

    int foundCounter2 = 0;
    for(size_t i = 0; i < result.size(); ++i)
    {
        const KeyPoint& r = result[i];                
        size_t j = 0;
        for(; j < exp.size(); ++j)
        {
            const KeyPoint& e = exp[i];
            if (norm(r.pt-e.pt) < nthres && fabs(r.size - e.size) < thres)
                break;
        }
        if (j != exp.size())
            ++foundCounter2;
    }
    //showOrig(img, result); waitKey();

    const float errorRate = 0.9f;
    if (float(foundCounter1)/exp.size() < errorRate || float(foundCounter2)/result.size() < errorRate)
    {
        ts->set_failed_test_info( CvTS::FAIL_MISMATCH);
        return false;
    }
    return true;        
}

struct SurfNoMaskWrap 
{
    const SURF& detector;
    SurfNoMaskWrap(const SURF& surf) : detector(surf) {}
    SurfNoMaskWrap& operator=(const SurfNoMaskWrap&);
    void operator()(const Mat& img, vector<KeyPoint>& kpts) const { detector(img, Mat(), kpts); }
};

void CV_DetectorsTest::LoadExpected(const string& file, vector<KeyPoint>& out)
{     
    Mat mat_exp;
    FileStorage fs(file, FileStorage::READ);    
    if (fs.isOpened())
    {
        read( fs["ResultVectorData"], mat_exp, Mat() );           
        out.resize(mat_exp.cols / sizeof(KeyPoint));
        copy(mat_exp.ptr<KeyPoint>(), mat_exp.ptr<KeyPoint>() + out.size(), out.begin());            
    }
    else
    {
        ts->set_failed_test_info( CvTS::FAIL_INVALID_TEST_DATA);
        out.clear();
    }    
}

void CV_DetectorsTest::run( int /*start_from*/ )
{	         
    Mat img = imread(string(ts->get_data_path()) + "shared/graffiti.png", 0);

    if (img.empty())
    {
        ts->set_failed_test_info( CvTS::FAIL_INVALID_TEST_DATA );
        return;
    }
            
    Mat to_test(img.size() * 2, img.type(), Scalar(0));
    Mat roi = to_test(Rect(img.rows/2, img.cols/2, img.cols, img.rows));
    img.copyTo(roi);
    GaussianBlur(to_test, to_test, Size(3, 3), 1.5);
        
    vector<KeyPoint> exp;
    LoadExpected(string(ts->get_data_path()) + "detectors/surf.xml", exp);        
    if (exp.empty())
        return;

    if (!testDedector(to_test, SurfNoMaskWrap(SURF(1536+512+512, 2)), exp))
        return;
    
    LoadExpected(string(ts->get_data_path()) + "detectors/star.xml", exp);
    if (exp.empty())
        return;

    if (!testDedector(to_test, StarDetector(45, 30, 10, 8, 5), exp))
        return;

    ts->set_failed_test_info( CvTS::OK);		   
}


CV_DetectorsTest Detectors_test;



