Merge pull request #162 from cbalint13/agast

Add AGAST detector

modules/xfeatures2d/doc/xfeatures2d.bib

@@ -45,6 +45,15 @@
   organization={Ieee}
 }
 
+@inproceedings{mair2010_agast,
+   title={Adaptive and Generic Corner Detection Based on the Accelerated Segment Test"},
+   author={"Elmar Mair and Gregory D. Hager and Darius Burschka and Michael Suppa and Gerhard Hirzinger"},
+   year={"2010"},
+   month={"September"},
+   booktitle={"European Conference on Computer Vision (ECCV'10)"},
+   url={"http://www6.in.tum.de/Main/ResearchAgast"
+}
+
 @incollection{LUCID,
   title={Locally uniform comparison image descriptor},
   author={Ziegler, Andrew, Eric Christiansen, David Kriegman, and Serge J. Belongie}

modules/xfeatures2d/include/opencv2/xfeatures2d.hpp

@@ -129,6 +129,52 @@ public:
     static Ptr<BriefDescriptorExtractor> create( int bytes = 32 );
 };
 
+/** @overload */
+CV_EXPORTS void AGAST( InputArray image, CV_OUT std::vector<KeyPoint>& keypoints,
+                      int threshold, bool nonmaxSuppression=true );
+
+/** @brief Detects corners using the AGAST algorithm
+
+@param image grayscale image where keypoints (corners) are detected.
+@param keypoints keypoints detected on the image.
+@param threshold threshold on difference between intensity of the central pixel and pixels of a
+circle around this pixel.
+@param nonmaxSuppression if true, non-maximum suppression is applied to detected corners
+(keypoints).
+@param type one of the four neighborhoods as defined in the paper:
+AgastFeatureDetector::AGAST_5_8, AgastFeatureDetector::AGAST_7_12d,
+AgastFeatureDetector::AGAST_7_12s, AgastFeatureDetector::OAST_9_16
+
+Detects corners using the AGAST algorithm by @cite mair2010_agast .
+
+ */
+CV_EXPORTS void AGAST( InputArray image, CV_OUT std::vector<KeyPoint>& keypoints,
+                      int threshold, bool nonmaxSuppression, int type );
+
+/** @brief Wrapping class for feature detection using the AGAST method. :
+ */
+class CV_EXPORTS_W AgastFeatureDetector : public Feature2D
+{
+public:
+    enum
+    {
+        AGAST_5_8 = 0, AGAST_7_12d = 1, AGAST_7_12s = 2, OAST_9_16 = 3,
+        THRESHOLD = 10000, NONMAX_SUPPRESSION = 10001,
+    };
+
+    CV_WRAP static Ptr<AgastFeatureDetector> create( int threshold=10,
+                                                     bool nonmaxSuppression=true,
+                                                     int type=AgastFeatureDetector::OAST_9_16 );
+
+    CV_WRAP virtual void setThreshold(int threshold) = 0;
+    CV_WRAP virtual int getThreshold() const = 0;
+
+    CV_WRAP virtual void setNonmaxSuppression(bool f) = 0;
+    CV_WRAP virtual bool getNonmaxSuppression() const = 0;
+
+    CV_WRAP virtual void setType(int type) = 0;
+    CV_WRAP virtual int getType() const = 0;
+};
 
 /** @brief Class implementing the locally uniform comparison image descriptor, described in @cite LUCID
 

modules/xfeatures2d/perf/perf_agast.cpp

@@ -0,0 +1,41 @@
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::xfeatures2d;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+CV_ENUM(AgastType, AgastFeatureDetector::AGAST_5_8, AgastFeatureDetector::AGAST_7_12d,
+                   AgastFeatureDetector::AGAST_7_12s, AgastFeatureDetector::OAST_9_16)
+
+typedef std::tr1::tuple<string, AgastType> File_Type_t;
+typedef perf::TestBaseWithParam<File_Type_t> agast;
+
+#define AGAST_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(agast, detect, testing::Combine(
+                            testing::Values(AGAST_IMAGES),
+                            AgastType::all()
+                          ))
+{
+    string filename = getDataPath(get<0>(GetParam()));
+    int type = get<1>(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+
+    if (frame.empty())
+        FAIL() << "Unable to load source image " << filename;
+
+    declare.in(frame);
+
+    Ptr<FeatureDetector> fd = AgastFeatureDetector::create(20, true, type);
+    ASSERT_FALSE( fd.empty() );
+    vector<KeyPoint> points;
+
+    TEST_CYCLE() fd->detect(frame, points);
+
+    SANITY_CHECK_KEYPOINTS(points);
+}

modules/xfeatures2d/src/agast_score.hpp

@@ -0,0 +1,65 @@
+/* This is AGAST and OAST, an optimal and accelerated corner detector
+              based on the accelerated segment tests
+   Below is the original copyright and the references */
+
+/*
+Copyright (C) 2010  Elmar Mair
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions 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.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may 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 COPYRIGHT OWNER 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.
+*/
+
+/*
+The references are:
+ * Adaptive and Generic Corner Detection Based on the Accelerated Segment Test,
+   Elmar Mair and Gregory D. Hager and Darius Burschka
+   and Michael Suppa and Gerhard Hirzinger ECCV 2010
+   URL: http://www6.in.tum.de/Main/ResearchAgast
+*/
+
+
+#ifndef __OPENCV_FEATURES_2D_AGAST_HPP__
+#define __OPENCV_FEATURES_2D_AGAST_HPP__
+
+#ifdef __cplusplus
+
+#include "precomp.hpp"
+namespace cv
+{
+namespace xfeatures2d
+{
+
+void makeAgastOffsets(int pixel[16], int row_stride, int type);
+
+template<int type>
+int agast_cornerScore(const uchar* ptr, const int pixel[], int threshold);
+
+}
+}
+#endif
+#endif

modules/xfeatures2d/test/test_agast.cpp

@@ -0,0 +1,138 @@
+/*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 "test_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::xfeatures2d;
+
+class CV_AgastTest : public cvtest::BaseTest
+{
+public:
+    CV_AgastTest();
+    ~CV_AgastTest();
+protected:
+    void run(int);
+};
+
+CV_AgastTest::CV_AgastTest() {}
+CV_AgastTest::~CV_AgastTest() {}
+
+void CV_AgastTest::run( int )
+{
+  for(int type=0; type <= 2; ++type) {
+    Mat image1 = imread(string(ts->get_data_path()) + "inpaint/orig.png");
+    Mat image2 = imread(string(ts->get_data_path()) + "cameracalibration/chess9.png");
+    string xml = string(ts->get_data_path()) + format("agast/result%d.xml", type);
+
+    if (image1.empty() || image2.empty())
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+        return;
+    }
+
+    Mat gray1, gray2;
+    cvtColor(image1, gray1, COLOR_BGR2GRAY);
+    cvtColor(image2, gray2, COLOR_BGR2GRAY);
+
+    vector<KeyPoint> keypoints1;
+    vector<KeyPoint> keypoints2;
+    AGAST(gray1, keypoints1, 30, true, type);
+    AGAST(gray2, keypoints2, (type > 0 ? 30 : 20), true, type);
+
+    for(size_t i = 0; i < keypoints1.size(); ++i)
+    {
+        const KeyPoint& kp = keypoints1[i];
+        cv::circle(image1, kp.pt, cvRound(kp.size/2), Scalar(255, 0, 0));
+    }
+
+    for(size_t i = 0; i < keypoints2.size(); ++i)
+    {
+        const KeyPoint& kp = keypoints2[i];
+        cv::circle(image2, kp.pt, cvRound(kp.size/2), Scalar(255, 0, 0));
+    }
+
+    Mat kps1(1, (int)(keypoints1.size() * sizeof(KeyPoint)), CV_8U, &keypoints1[0]);
+    Mat kps2(1, (int)(keypoints2.size() * sizeof(KeyPoint)), CV_8U, &keypoints2[0]);
+
+    FileStorage fs(xml, FileStorage::READ);
+    if (!fs.isOpened())
+    {
+        fs.open(xml, FileStorage::WRITE);
+        if (!fs.isOpened())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+        fs << "exp_kps1" << kps1;
+        fs << "exp_kps2" << kps2;
+        fs.release();
+        fs.open(xml, FileStorage::READ);
+        if (!fs.isOpened())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+    }
+
+    Mat exp_kps1, exp_kps2;
+    read( fs["exp_kps1"], exp_kps1, Mat() );
+    read( fs["exp_kps2"], exp_kps2, Mat() );
+    fs.release();
+
+     if ( exp_kps1.size != kps1.size || 0 != cvtest::norm(exp_kps1, kps1, NORM_L2) ||
+          exp_kps2.size != kps2.size || 0 != cvtest::norm(exp_kps2, kps2, NORM_L2))
+    {
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        return;
+    }
+
+    /*cv::namedWindow("Img1"); cv::imshow("Img1", image1);
+    cv::namedWindow("Img2"); cv::imshow("Img2", image2);
+    cv::waitKey(0);*/
+  }
+
+  ts->set_failed_test_info(cvtest::TS::OK);
+}
+
+TEST(Features2d_AGAST, regression) { CV_AgastTest test; test.safe_run(); }