-define_opencv_module(calib3d opencv_core opencv_imgproc opencv_highgui)
+define_opencv_module(calib3d opencv_core opencv_imgproc opencv_highgui opencv_features2d)
+++ /dev/null
-/*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 ¶meters = 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> ¢ers) const;
-
- cv::Point2d computeGrayscaleCentroid(const cv::Mat &image, const std::vector<cv::Point> &contour) const;
-
- BlobDetectorParameters params;
-};
-
-#endif /* BLOBDETECTOR_HPP_ */
#include "precomp.hpp"
#include "circlesgrid.hpp"
-#include "blobdetector.hpp"
#include <stdarg.h>
//#define ENABLE_TRIM_COL_ROW
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;
for (int i = 0; i < attempts; i++)
{
centers.clear();
- CirclesGridFinder boxFinder(patternSize, keypoints, parameters);
+ CirclesGridFinder boxFinder(patternSize, points, parameters);
bool isFound = false;
try
{
{
if (centers.size() < minHomographyPoints)
break;
- H = CirclesGridFinder::rectifyGrid(boxFinder.getDetectedGridSize(), centers, keypoints, keypoints);
+ H = CirclesGridFinder::rectifyGrid(boxFinder.getDetectedGridSize(), centers, points, points);
}
}
#define CIRCLESGRID_HPP_
#include <fstream>
-#include <iostream>
-#include <string>
#include <set>
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/core/internal.hpp"
+#include "opencv2/features2d/features2d.hpp"
#endif
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 ¶meters = 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> ¢ers) const;
+
+ cv::Point2d computeGrayscaleCentroid(const cv::Mat &image, const std::vector<cv::Point> &contour) const;
+
+ Params params;
+};
+
class CV_EXPORTS DenseFeatureDetector : public FeatureDetector
{
public:
//
//M*/
-#include "blobdetector.hpp"
+#include "precomp.hpp"
using namespace cv;
-BlobDetectorParameters::BlobDetectorParameters()
+/*
+ * SimpleBlobDetector
+ */
+SimpleBlobDetector::Params::Params()
{
thresholdStep = 10;
minThreshold = 50;
maxCentersDist = 10;
defaultKeypointSize = 1;
minRepeatability = 2;
- filterByColor = true;
computeRadius = true;
+ filterByColor = true;
+ blobColor = 0;
isGrayscaleCentroid = false;
centroidROIMargin = 2;
minCircularity = 0.8f;
}
-BlobDetector::BlobDetector(const BlobDetectorParameters ¶meters) :
+SimpleBlobDetector::SimpleBlobDetector(const SimpleBlobDetector::Params ¶meters) :
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;
return centroid;
}
-void BlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, vector<Center> ¢ers) const
+void SimpleBlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, vector<Center> ¢ers) const
{
centers.clear();
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;
}
//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;
normalizer += centers[i][j].confidence;
}
sumPoint *= (1. / normalizer);
- keypoints.push_back(sumPoint);
+ KeyPoint kpt(sumPoint, params.defaultKeypointSize);
+ keypoints.push_back(kpt);
}
}