Moved BlobDetector to features2d

modules/calib3d/CMakeLists.txt

-define_opencv_module(calib3d opencv_core opencv_imgproc opencv_highgui)
+define_opencv_module(calib3d opencv_core opencv_imgproc opencv_highgui opencv_features2d)

modules/calib3d/src/blobdetector.hpp

-/*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*/
-
-#ifndef BLOBDETECTOR_HPP_
-#define BLOBDETECTOR_HPP_
-
-#include "precomp.hpp"
-
-struct BlobDetectorParameters
-{
-  BlobDetectorParameters();
-
-  float thresholdStep;
-  float minThreshold;
-  float maxThreshold;
-  float maxCentersDist;
-  int defaultKeypointSize;
-  size_t minRepeatability;
-  bool computeRadius;
-  bool isGrayscaleCentroid;
-  int centroidROIMargin;
-
-  bool filterByArea, filterByInertia, filterByCircularity, filterByColor, filterByConvexity;
-  float minArea;
-  float maxArea;
-  float minCircularity;
-  float minInertiaRatio;
-  float minConvexity;
-};
-
-class BlobDetector //: public cv::FeatureDetector
-{
-public:
-  BlobDetector(const BlobDetectorParameters &parameters = BlobDetectorParameters());
-  void detect(const cv::Mat& image, std::vector<cv::Point2f>& keypoints, const cv::Mat& mask = cv::Mat()) const;
-protected:
-  struct Center
-  {
-    cv::Point2d location;
-    double radius;
-    double confidence;
-  };
-
-  virtual void detectImpl(const cv::Mat& image, std::vector<cv::Point2f>& keypoints, const cv::Mat& mask = cv::Mat()) const;
-  virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
-
-  cv::Point2d computeGrayscaleCentroid(const cv::Mat &image, const std::vector<cv::Point> &contour) const;
-
-  BlobDetectorParameters params;
-};
-
-#endif /* BLOBDETECTOR_HPP_ */

modules/calib3d/src/calibinit.cpp

@@ -61,7 +61,6 @@
 
 #include "precomp.hpp"
 #include "circlesgrid.hpp"
-#include "blobdetector.hpp"
 #include <stdarg.h>
 
 //#define ENABLE_TRIM_COL_ROW
@@ -1938,10 +1937,15 @@ void drawChessboardCorners( Mat& image, Size patternSize,
 bool findCirclesGrid( const Mat& image, Size patternSize,
                       vector<Point2f>& centers, int )
 {
-    Ptr<BlobDetector> detector = new BlobDetector();
+    Ptr<SimpleBlobDetector> detector = new SimpleBlobDetector();
     //Ptr<FeatureDetector> detector = new MserFeatureDetector();
-    vector<Point2f> keypoints;
+    vector<KeyPoint> keypoints;
     detector->detect(image, keypoints);
+    vector<Point2f> points;
+    for (size_t i = 0; i < keypoints.size(); i++)
+    {
+        points.push_back (keypoints[i].pt);
+    }
 
     CirclesGridFinderParameters parameters;
     parameters.vertexPenalty = -0.6f;
@@ -1956,7 +1960,7 @@ bool findCirclesGrid( const Mat& image, Size patternSize,
     for (int i = 0; i < attempts; i++)
     {
       centers.clear();
-      CirclesGridFinder boxFinder(patternSize, keypoints, parameters);
+      CirclesGridFinder boxFinder(patternSize, points, parameters);
       bool isFound = false;
       try
       {
@@ -1984,7 +1988,7 @@ bool findCirclesGrid( const Mat& image, Size patternSize,
       {
         if (centers.size() < minHomographyPoints)
           break;
-        H = CirclesGridFinder::rectifyGrid(boxFinder.getDetectedGridSize(), centers, keypoints, keypoints);
+        H = CirclesGridFinder::rectifyGrid(boxFinder.getDetectedGridSize(), centers, points, points);
       }
     }
 

modules/calib3d/src/circlesgrid.hpp

@@ -44,8 +44,6 @@
 #define CIRCLESGRID_HPP_
 
 #include <fstream>
-#include <iostream>
-#include <string>
 #include <set>
 
 #include "precomp.hpp"

modules/calib3d/src/precomp.hpp

@@ -54,5 +54,6 @@
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/imgproc/imgproc_c.h"
 #include "opencv2/core/internal.hpp"
+#include "opencv2/features2d/features2d.hpp"
 
 #endif

modules/features2d/include/opencv2/features2d/features2d.hpp

@@ -1333,6 +1333,48 @@ protected:
     SURF surf;
 };
 
+class CV_EXPORTS SimpleBlobDetector : public cv::FeatureDetector
+{
+public:
+  struct CV_EXPORTS Params
+  {
+      Params();
+      float thresholdStep;
+      float minThreshold;
+      float maxThreshold;
+      float maxCentersDist;
+      int defaultKeypointSize;
+      size_t minRepeatability;
+      bool computeRadius;
+      bool isGrayscaleCentroid;
+      int centroidROIMargin;
+
+      bool filterByArea, filterByInertia, filterByCircularity, filterByColor, filterByConvexity;
+      float minArea;
+      float maxArea;
+      float minCircularity;
+      float minInertiaRatio;
+      float minConvexity;
+      uchar blobColor;
+  };
+
+  SimpleBlobDetector(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params());
+protected:
+  struct CV_EXPORTS Center
+  {
+    cv::Point2d location;
+    double radius;
+    double confidence;
+  };
+
+  virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
+  virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
+
+  cv::Point2d computeGrayscaleCentroid(const cv::Mat &image, const std::vector<cv::Point> &contour) const;
+
+  Params params;
+};
+
 class CV_EXPORTS DenseFeatureDetector : public FeatureDetector
 {
 public:

modules/calib3d/src/blobdetector.cpp → modules/features2d/src/blobdetector.cpp

@@ -40,11 +40,14 @@
 //
 //M*/
 
-#include "blobdetector.hpp"
+#include "precomp.hpp"
 
 using namespace cv;
 
-BlobDetectorParameters::BlobDetectorParameters()
+/*
+ *  SimpleBlobDetector
+ */
+SimpleBlobDetector::Params::Params()
 {
   thresholdStep = 10;
   minThreshold = 50;
@@ -52,8 +55,9 @@ BlobDetectorParameters::BlobDetectorParameters()
   maxCentersDist = 10;
   defaultKeypointSize = 1;
   minRepeatability = 2;
-  filterByColor = true;
   computeRadius = true;
+  filterByColor = true;
+  blobColor = 0;
 
   isGrayscaleCentroid = false;
   centroidROIMargin = 2;
@@ -74,17 +78,12 @@ BlobDetectorParameters::BlobDetectorParameters()
   minCircularity = 0.8f;
 }
 
-BlobDetector::BlobDetector(const BlobDetectorParameters &parameters) :
+SimpleBlobDetector::SimpleBlobDetector(const SimpleBlobDetector::Params &parameters) :
   params(parameters)
 {
 }
 
-void BlobDetector::detect(const cv::Mat& image, vector<cv::Point2f>& keypoints, const cv::Mat& mask) const
-{
-  detectImpl(image, keypoints, mask);
-}
-
-Point2d BlobDetector::computeGrayscaleCentroid(const Mat &image, const vector<Point> &contour) const
+Point2d SimpleBlobDetector::computeGrayscaleCentroid(const Mat &image, const vector<Point> &contour) const
 {
   Rect rect = boundingRect(Mat(contour));
   rect.x -= params.centroidROIMargin;
@@ -113,7 +112,7 @@ Point2d BlobDetector::computeGrayscaleCentroid(const Mat &image, const vector<Po
   return centroid;
 }
 
-void BlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, vector<Center> &centers) const
+void SimpleBlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, vector<Center> &centers) const
 {
   centers.clear();
 
@@ -195,7 +194,7 @@ void BlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, v
 
     if (params.filterByColor)
     {
-      if (binaryImage.at<uchar> (cvRound(center.location.y), cvRound(center.location.x)) == 255)
+      if (binaryImage.at<uchar> (cvRound(center.location.y), cvRound(center.location.x)) != params.blobColor)
         continue;
     }
 
@@ -219,7 +218,7 @@ void BlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, v
   //waitKey();
 }
 
-void BlobDetector::detectImpl(const cv::Mat& image, std::vector<cv::Point2f>& keypoints, const cv::Mat& mask) const
+void SimpleBlobDetector::detectImpl(const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints, const cv::Mat& mask) const
 {
   keypoints.clear();
   Mat grayscaleImage;
@@ -282,6 +281,7 @@ void BlobDetector::detectImpl(const cv::Mat& image, std::vector<cv::Point2f>& ke
       normalizer += centers[i][j].confidence;
     }
     sumPoint *= (1. / normalizer);
-    keypoints.push_back(sumPoint);
+    KeyPoint kpt(sumPoint, params.defaultKeypointSize);
+    keypoints.push_back(kpt);
   }
 }