gpu::createMinEigenValCorner(src.type(), blockSize, ksize, borderType)->compute(src, dst, stream);
}
-////////////////////////// Feature Detection ///////////////////////////
+////////////////////////// Corners Detection ///////////////////////////
-class CV_EXPORTS GoodFeaturesToTrackDetector_GPU
+class CV_EXPORTS CornersDetector : public Algorithm
{
public:
- explicit GoodFeaturesToTrackDetector_GPU(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0,
- int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04);
-
//! return 1 rows matrix with CV_32FC2 type
- void operator ()(const GpuMat& image, GpuMat& corners, const GpuMat& mask = GpuMat());
-
- int maxCorners;
- double qualityLevel;
- double minDistance;
-
- int blockSize;
- bool useHarrisDetector;
- double harrisK;
-
- void releaseMemory()
- {
- Dx_.release();
- Dy_.release();
- buf_.release();
- eig_.release();
- minMaxbuf_.release();
- tmpCorners_.release();
- }
-
-private:
- GpuMat Dx_;
- GpuMat Dy_;
- GpuMat buf_;
- GpuMat eig_;
- GpuMat minMaxbuf_;
- GpuMat tmpCorners_;
+ virtual void detect(InputArray image, OutputArray corners, InputArray mask = noArray()) = 0;
};
-inline GoodFeaturesToTrackDetector_GPU::GoodFeaturesToTrackDetector_GPU(int maxCorners_, double qualityLevel_, double minDistance_,
- int blockSize_, bool useHarrisDetector_, double harrisK_)
-{
- maxCorners = maxCorners_;
- qualityLevel = qualityLevel_;
- minDistance = minDistance_;
- blockSize = blockSize_;
- useHarrisDetector = useHarrisDetector_;
- harrisK = harrisK_;
-}
+CV_EXPORTS Ptr<CornersDetector> createGoodFeaturesToTrackDetector(int srcType, int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0,
+ int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04);
///////////////////////////// Mean Shift //////////////////////////////
using namespace cv;
using namespace cv::gpu;
-#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
+#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_GPUARITHM)
-void cv::gpu::GoodFeaturesToTrackDetector_GPU::operator ()(const GpuMat&, GpuMat&, const GpuMat&) { throw_no_cuda(); }
+Ptr<gpu::CornersDetector> cv::gpu::createGoodFeaturesToTrackDetector(int, int, double, double, int, bool, double) { throw_no_cuda(); return Ptr<gpu::CornersDetector>(); }
#else /* !defined (HAVE_CUDA) */
}
}}}
-void cv::gpu::GoodFeaturesToTrackDetector_GPU::operator ()(const GpuMat& image, GpuMat& corners, const GpuMat& mask)
+namespace
{
-#ifndef HAVE_OPENCV_GPUARITHM
- (void) image;
- (void) corners;
- (void) mask;
- throw_no_cuda();
-#else
- using namespace cv::gpu::cudev::gfft;
+ class GoodFeaturesToTrackDetector : public CornersDetector
+ {
+ public:
+ GoodFeaturesToTrackDetector(int srcType, int maxCorners, double qualityLevel, double minDistance,
+ int blockSize, bool useHarrisDetector, double harrisK);
+
+ void detect(InputArray image, OutputArray corners, InputArray mask = noArray());
+
+ private:
+ int maxCorners_;
+ double qualityLevel_;
+ double minDistance_;
+
+ Ptr<gpu::CornernessCriteria> cornerCriteria_;
+
+ GpuMat Dx_;
+ GpuMat Dy_;
+ GpuMat buf_;
+ GpuMat eig_;
+ GpuMat minMaxbuf_;
+ GpuMat tmpCorners_;
+ };
+
+ GoodFeaturesToTrackDetector::GoodFeaturesToTrackDetector(int srcType, int maxCorners, double qualityLevel, double minDistance,
+ int blockSize, bool useHarrisDetector, double harrisK) :
+ maxCorners_(maxCorners), qualityLevel_(qualityLevel), minDistance_(minDistance)
+ {
+ CV_Assert( qualityLevel_ > 0 && minDistance_ >= 0 && maxCorners_ >= 0 );
- CV_Assert(qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0);
- CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()));
+ cornerCriteria_ = useHarrisDetector ?
+ gpu::createHarrisCorner(srcType, blockSize, 3, harrisK) :
+ gpu::createMinEigenValCorner(srcType, blockSize, 3);
+ }
- ensureSizeIsEnough(image.size(), CV_32F, eig_);
+ void GoodFeaturesToTrackDetector::detect(InputArray _image, OutputArray _corners, InputArray _mask)
+ {
+ using namespace cv::gpu::cudev::gfft;
- Ptr<gpu::CornernessCriteria> cornerCriteria =
- useHarrisDetector ?
- gpu::createHarrisCorner(image.type(), blockSize, 3, harrisK) :
- gpu::createMinEigenValCorner(image.type(), blockSize, 3);
+ GpuMat image = _image.getGpuMat();
+ GpuMat mask = _mask.getGpuMat();
- cornerCriteria->compute(image, eig_);
+ CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()) );
- double maxVal = 0;
- gpu::minMax(eig_, 0, &maxVal, GpuMat(), minMaxbuf_);
+ ensureSizeIsEnough(image.size(), CV_32FC1, eig_);
+ cornerCriteria_->compute(image, eig_);
- ensureSizeIsEnough(1, std::max(1000, static_cast<int>(image.size().area() * 0.05)), CV_32FC2, tmpCorners_);
+ double maxVal = 0;
+ gpu::minMax(eig_, 0, &maxVal, noArray(), minMaxbuf_);
- int total = findCorners_gpu(eig_, static_cast<float>(maxVal * qualityLevel), mask, tmpCorners_.ptr<float2>(), tmpCorners_.cols);
+ ensureSizeIsEnough(1, std::max(1000, static_cast<int>(image.size().area() * 0.05)), CV_32FC2, tmpCorners_);
- if (total == 0)
- {
- corners.release();
- return;
- }
+ int total = findCorners_gpu(eig_, static_cast<float>(maxVal * qualityLevel_), mask, tmpCorners_.ptr<float2>(), tmpCorners_.cols);
- sortCorners_gpu(eig_, tmpCorners_.ptr<float2>(), total);
+ if (total == 0)
+ {
+ _corners.release();
+ return;
+ }
- if (minDistance < 1)
- tmpCorners_.colRange(0, maxCorners > 0 ? std::min(maxCorners, total) : total).copyTo(corners);
- else
- {
- std::vector<Point2f> tmp(total);
- Mat tmpMat(1, total, CV_32FC2, (void*)&tmp[0]);
- tmpCorners_.colRange(0, total).download(tmpMat);
+ sortCorners_gpu(eig_, tmpCorners_.ptr<float2>(), total);
- std::vector<Point2f> tmp2;
- tmp2.reserve(total);
+ if (minDistance_ < 1)
+ {
+ tmpCorners_.colRange(0, maxCorners_ > 0 ? std::min(maxCorners_, total) : total).copyTo(_corners);
+ }
+ else
+ {
+ std::vector<Point2f> tmp(total);
+ Mat tmpMat(1, total, CV_32FC2, (void*)&tmp[0]);
+ tmpCorners_.colRange(0, total).download(tmpMat);
- const int cell_size = cvRound(minDistance);
- const int grid_width = (image.cols + cell_size - 1) / cell_size;
- const int grid_height = (image.rows + cell_size - 1) / cell_size;
+ std::vector<Point2f> tmp2;
+ tmp2.reserve(total);
- std::vector< std::vector<Point2f> > grid(grid_width * grid_height);
+ const int cell_size = cvRound(minDistance_);
+ const int grid_width = (image.cols + cell_size - 1) / cell_size;
+ const int grid_height = (image.rows + cell_size - 1) / cell_size;
- for (int i = 0; i < total; ++i)
- {
- Point2f p = tmp[i];
+ std::vector< std::vector<Point2f> > grid(grid_width * grid_height);
- bool good = true;
+ for (int i = 0; i < total; ++i)
+ {
+ Point2f p = tmp[i];
- int x_cell = static_cast<int>(p.x / cell_size);
- int y_cell = static_cast<int>(p.y / cell_size);
+ bool good = true;
- int x1 = x_cell - 1;
- int y1 = y_cell - 1;
- int x2 = x_cell + 1;
- int y2 = y_cell + 1;
+ int x_cell = static_cast<int>(p.x / cell_size);
+ int y_cell = static_cast<int>(p.y / cell_size);
- // boundary check
- x1 = std::max(0, x1);
- y1 = std::max(0, y1);
- x2 = std::min(grid_width - 1, x2);
- y2 = std::min(grid_height - 1, y2);
+ int x1 = x_cell - 1;
+ int y1 = y_cell - 1;
+ int x2 = x_cell + 1;
+ int y2 = y_cell + 1;
- for (int yy = y1; yy <= y2; yy++)
- {
- for (int xx = x1; xx <= x2; xx++)
- {
- std::vector<Point2f>& m = grid[yy * grid_width + xx];
+ // boundary check
+ x1 = std::max(0, x1);
+ y1 = std::max(0, y1);
+ x2 = std::min(grid_width - 1, x2);
+ y2 = std::min(grid_height - 1, y2);
- if (!m.empty())
+ for (int yy = y1; yy <= y2; yy++)
+ {
+ for (int xx = x1; xx <= x2; xx++)
{
- for(size_t j = 0; j < m.size(); j++)
- {
- float dx = p.x - m[j].x;
- float dy = p.y - m[j].y;
+ std::vector<Point2f>& m = grid[yy * grid_width + xx];
- if (dx * dx + dy * dy < minDistance * minDistance)
+ if (!m.empty())
+ {
+ for(size_t j = 0; j < m.size(); j++)
{
- good = false;
- goto break_out;
+ float dx = p.x - m[j].x;
+ float dy = p.y - m[j].y;
+
+ if (dx * dx + dy * dy < minDistance_ * minDistance_)
+ {
+ good = false;
+ goto break_out;
+ }
}
}
}
}
- }
- break_out:
+ break_out:
- if(good)
- {
- grid[y_cell * grid_width + x_cell].push_back(p);
+ if(good)
+ {
+ grid[y_cell * grid_width + x_cell].push_back(p);
- tmp2.push_back(p);
+ tmp2.push_back(p);
- if (maxCorners > 0 && tmp2.size() == static_cast<size_t>(maxCorners))
- break;
+ if (maxCorners_ > 0 && tmp2.size() == static_cast<size_t>(maxCorners_))
+ break;
+ }
}
- }
- corners.upload(Mat(1, static_cast<int>(tmp2.size()), CV_32FC2, &tmp2[0]));
+ _corners.create(1, static_cast<int>(tmp2.size()), CV_32FC2);
+ GpuMat corners = _corners.getGpuMat();
+
+ corners.upload(Mat(1, static_cast<int>(tmp2.size()), CV_32FC2, &tmp2[0]));
+ }
}
-#endif
+}
+
+Ptr<gpu::CornersDetector> cv::gpu::createGoodFeaturesToTrackDetector(int srcType, int maxCorners, double qualityLevel, double minDistance,
+ int blockSize, bool useHarrisDetector, double harrisK)
+{
+ return new GoodFeaturesToTrackDetector(srcType, maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, harrisK);
}
#endif /* !defined (HAVE_CUDA) */
projects / platform / upstream / opencv.git / commitdiff