generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move border type constants and Moments class to core module

Browse Source
This commit is contained in:
Andrey Kamaev
2013-04-10 15:54:14 +04:00
parent f4ae0cf19c
commit c98c246fc2
83 changed files with 541 additions and 639 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
modules/calib3d/src/calibinit.cpp
View File

@@ -60,6 +60,7 @@
\************************************************************************************/
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "circlesgrid.hpp"
#include <stdarg.h>

1
modules/calib3d/src/calibration.cpp
View File

@@ -41,6 +41,7 @@
//M*/
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include <stdio.h>
#include <iterator>

1
modules/calib3d/src/checkchessboard.cpp
View File

@@ -40,6 +40,7 @@
//M*/
#include "precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include <vector>
#include <algorithm>

2
modules/calib3d/src/circlesgrid.cpp
View File

@@ -1364,7 +1364,7 @@ void CirclesGridFinder::drawHoles(const Mat &srcImage, Mat &drawImage) const
const Scalar holeColor = Scalar(0, 255, 0);
if (srcImage.channels() == 1)
cvtColor(srcImage, drawImage, CV_GRAY2RGB);
cvtColor(srcImage, drawImage, COLOR_GRAY2RGB);
else
srcImage.copyTo(drawImage);

1
modules/calib3d/src/precomp.hpp
View File

@@ -44,7 +44,6 @@
#include "opencv2/calib3d.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/features2d.hpp"
#include "opencv2/core/utility.hpp"

135
modules/calib3d/src/quadsubpix.cpp
View File

@@ -47,40 +47,8 @@
#include <math.h>
//#define _SUBPIX_VERBOSE
#undef max
namespace cv {
// static void drawCircles(Mat& img, const std::vector<Point2f>& corners, const std::vector<float>& radius)
// {
// for(size_t i = 0; i < corners.size(); i++)
// {
// circle(img, corners[i], cvRound(radius[i]), CV_RGB(255, 0, 0));
// }
// }
// static int histQuantile(const Mat& hist, float quantile)
// {
// if(hist.dims > 1) return -1; // works for 1D histograms only
// float cur_sum = 0;
// float total_sum = (float)sum(hist).val[0];
// float quantile_sum = total_sum*quantile;
// for(int j = 0; j < hist.size[0]; j++)
// {
// cur_sum += (float)hist.at<float>(j);
// if(cur_sum > quantile_sum)
// {
// return j;
// }
// }
// return hist.size[0] - 1;
// }
inline bool is_smaller(const std::pair<int, float>& p1, const std::pair<int, float>& p2)
{
return p1.second < p2.second;
@@ -124,29 +92,6 @@ static void findLinesCrossPoint(Point2f origin1, Point2f dir1, Point2f origin2,
cross_point = origin1 + dir1*alpha;
}
// static void findCorner(const std::vector<Point>& contour, Point2f point, Point2f& corner)
// {
// // find the nearest point
// double min_dist = std::numeric_limits<double>::max();
// int min_idx = -1;
// // find corner idx
// for(size_t i = 0; i < contour.size(); i++)
// {
// double dist = norm(Point2f((float)contour[i].x, (float)contour[i].y) - point);
// if(dist < min_dist)
// {
// min_dist = dist;
// min_idx = (int)i;
// }
// }
// assert(min_idx >= 0);
// // temporary solution, have to make something more precise
// corner = contour[min_idx];
// return;
// }
static void findCorner(const std::vector<Point2f>& contour, Point2f point, Point2f& corner)
{
// find the nearest point
@@ -173,13 +118,7 @@ static void findCorner(const std::vector<Point2f>& contour, Point2f point, Point
static int segment_hist_max(const Mat& hist, int& low_thresh, int& high_thresh)
{
Mat bw;
//const double max_bell_width = 20; // we expect two bells with width bounded above
//const double min_bell_width = 5; // and below
double total_sum = sum(hist).val[0];
//double thresh = total_sum/(2*max_bell_width)*0.25f; // quarter of a bar inside a bell
// threshold(hist, bw, thresh, 255.0, CV_THRESH_BINARY);
double quantile_sum = 0.0;
//double min_quantile = 0.2;
@@ -233,12 +172,6 @@ bool cv::find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size
const float* _ranges = ranges;
Mat hist;
#if defined(_SUBPIX_VERBOSE)
std::vector<float> radius;
radius.assign(corners.size(), 0.0f);
#endif //_SUBPIX_VERBOSE
Mat black_comp, white_comp;
for(int i = 0; i < ncorners; i++)
{
@@ -248,39 +181,20 @@ bool cv::find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size
Mat img_roi = img(roi);
calcHist(&img_roi, 1, &channels, Mat(), hist, 1, &nbins, &_ranges);
#if 0
int black_thresh = histQuantile(hist, 0.45f);
int white_thresh = histQuantile(hist, 0.55f);
#else
int black_thresh = 0, white_thresh = 0;
segment_hist_max(hist, black_thresh, white_thresh);
#endif
threshold(img, black_comp, black_thresh, 255.0, CV_THRESH_BINARY_INV);
threshold(img, white_comp, white_thresh, 255.0, CV_THRESH_BINARY);
threshold(img, black_comp, black_thresh, 255.0, THRESH_BINARY_INV);
threshold(img, white_comp, white_thresh, 255.0, THRESH_BINARY);
const int erode_count = 1;
erode(black_comp, black_comp, Mat(), Point(-1, -1), erode_count);
erode(white_comp, white_comp, Mat(), Point(-1, -1), erode_count);
#if defined(_SUBPIX_VERBOSE)
namedWindow("roi", 1);
imshow("roi", img_roi);
imwrite("test.jpg", img);
namedWindow("black", 1);
imshow("black", black_comp);
namedWindow("white", 1);
imshow("white", white_comp);
cvWaitKey(0);
imwrite("black.jpg", black_comp);
imwrite("white.jpg", white_comp);
#endif
std::vector<std::vector<Point> > white_contours, black_contours;
std::vector<Vec4i> white_hierarchy, black_hierarchy;
findContours(black_comp, black_contours, black_hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
findContours(white_comp, white_contours, white_hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
findContours(black_comp, black_contours, black_hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
findContours(white_comp, white_contours, white_hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
if(black_contours.size() < 5 || white_contours.size() < 5) continue;
@@ -302,15 +216,11 @@ bool cv::find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size
Point2f quad_corners[4];
for(int k = 0; k < 4; k++)
{
#if 1
std::vector<Point2f> temp;
for(size_t j = 0; j < quads[k]->size(); j++) temp.push_back((*quads[k])[j]);
approxPolyDP(Mat(temp), quads_approx[k], 0.5, true);
findCorner(quads_approx[k], corners[i], quad_corners[k]);
#else
findCorner(*quads[k], corners[i], quad_corners[k]);
#endif
quad_corners[k] += Point2f(0.5f, 0.5f);
}
@@ -323,44 +233,7 @@ bool cv::find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size
if(cvIsNaN(angle) || cvIsInf(angle) || angle < 0.5 || angle > CV_PI - 0.5) continue;
findLinesCrossPoint(origin1, dir1, origin2, dir2, corners[i]);
#if defined(_SUBPIX_VERBOSE)
radius[i] = norm(corners[i] - ground_truth_corners[ground_truth_idx])*6;
#if 1
Mat test(img.size(), CV_32FC3);
cvtColor(img, test, CV_GRAY2RGB);
// line(test, quad_corners[0] - corners[i] + Point2f(30, 30), quad_corners[1] - corners[i] + Point2f(30, 30), cvScalar(0, 255, 0));
// line(test, quad_corners[2] - corners[i] + Point2f(30, 30), quad_corners[3] - corners[i] + Point2f(30, 30), cvScalar(0, 255, 0));
std::vector<std::vector<Point> > contrs;
contrs.resize(1);
for(int k = 0; k < 4; k++)
{
//contrs[0] = quads_approx[k];
contrs[0].clear();
for(size_t j = 0; j < quads_approx[k].size(); j++) contrs[0].push_back(quads_approx[k][j]);
drawContours(test, contrs, 0, CV_RGB(0, 0, 255), 1, 1, std::vector<Vec4i>(), 2);
circle(test, quad_corners[k], 0.5, CV_RGB(255, 0, 0));
}
Mat test1 = test(Rect(corners[i].x - 30, corners[i].y - 30, 60, 60));
namedWindow("1", 1);
imshow("1", test1);
imwrite("test.jpg", test);
waitKey(0);
#endif
#endif //_SUBPIX_VERBOSE
}
#if defined(_SUBPIX_VERBOSE)
Mat test(img.size(), CV_32FC3);
cvtColor(img, test, CV_GRAY2RGB);
drawCircles(test, corners, radius);
namedWindow("corners", 1);
imshow("corners", test);
waitKey();
#endif //_SUBPIX_VERBOSE
return true;
}