Opencv做mark點尋邊定位
通過mark點進行定位是很常見的項目，mark點就是在圖上或者工件上設置一個標志性的mark點，在這里以圓點為例，如圖：
這個原圖是一個很大的板子，然后四個角分別有一個黑色圓點，黑點就是mark點了，在這里，mark點的作用就是為了讓攝像頭在運動中通過mark點來確定板子的具體位置，然后根據mark點的位置確定整個板子的加工路徑。項目比較簡單，主要說一下實現方式。
第一步：檢測mark點存在的問題：
要能夠准確的提取到完整的mark點輪廓
圖中其他與mark點相似部分的干擾（如圖中卡通人物的眼睛）
環境變化導致的光線變化使閾值難以確定
第二步：設計解決問題的方案：
因為環境光具有不確定性，一旦光線發生變化，必然會影響mark點輪廓的提取，為此經過多次嘗試，最終制定了兩套可行方案。
1.利用圖像的直方圖來確定閾值，因為mark點一定是黑色，所以mark點的灰度閾值一般是圖像直方圖的第一個波峰，所以可以將直方圖的第一個波谷作為二值化的閾值，另外，在實際測試中有時會因為背景有過黑的物體導致閾值錯誤，因此還需設置一個最小閾值。
2.通過梯度提取輪廓，利用sobel算子計算圖像的梯度，然后對梯度圖進行二值化，這樣也有利於克服環境變換的影響，但是弊端在於相機與物體的距離極限要遠小於直接二值化，而且強光也會導致梯度斷裂，出現輪廓斷續不完整。
解決mark點與圖中其他相似點的方法也是通過直方圖和灰度像素來確定的，已知mark點周邊的像素必定是白色的所以mark點周邊的像素應該是接近直方圖的最后一個波峰，因為檢測mark點有兩種情況，一種是一定存在mark點，另一種是在機床行進中捕獲mark點，先針對一定存在mark點的，如果一定存在mark點，那么就直接尋找視野內周邊像素值最大的黑色圓點即可，如果是尋邊捕獲mark點，那就需要不斷地尋找黑色圓點且周圍像素值接近直方圖的最后一個波峰。
第三步：確定mark點所需參數：
因為檢測mark點時，相機已經固定，相機到板子的距離也就已經固定了，所以需要通過面積，樣式，半徑大小等方式來限制mark點，過濾掉過大或者過小的輪廓，可以提高准確率。
主要代碼解析：
這部分代碼主要是用來實現直方圖確定二值化閾值，獲取二值化圖像。
int histSize = 256;
cv::MatND hist;
float range[] = { 0, 255 };
const float *ranges = { range };
int threshNum = 100;
std::vector threshNums;
//計算直方圖
calcHist(&grayImg, 1, 0, cv::Mat(), hist, 1, &histSize, &ranges, true, false);
//找到第一個波谷
for (int i = 3; i < 253; i++) {
if (hist.at(i) > hist.at(i - 1) && hist.at(i) > hist.at(i + 1) && hist.at(i - 1) > hist.at(i - 2) && hist.at(i + 1) > hist.at(i + 2) && hist.at(i - 2) > hist.at(i - 3) && hist.at(i + 2) > hist.at(i + 3)) {
//std::cout << i << std::endl;
threshNums.push_back(i);
}
}
if (threshNums.size() >= 2) {
threshNum = (threshNums[0] + threshNums[1]) / 2;
}
//設置最小閾值
if (threshNum < 80) {
threshNum = 80;
}
//進行二值化
cv::threshold(grayImg, thresh1, threshNum, 255, cv::THRESH_BINARY);
如圖：這是二值化后的結果，mark點非常清晰。
這部分的代碼是通過sobel算出梯度圖並計算二值圖像。
bool_t sobelImage(cv::Mat src, cv::Mat &sobelMat)
{
if (src.empty()) {
printf(“sobelImage(): image empty!\r\n”);
return false;
}
cv::Mat srcGray;
if (src.channels() == 3) {
cv::cvtColor(src, srcGray, cv::COLOR_BGR2GRAY);
}
else {
srcGray = src.clone();
}
// 定義邊緣圖，水平及垂直
cv::Mat edgeMat, edgeXMat, edgeYMat, edgeMat2;
// 求x方向Sobel邊緣
cv::Sobel(srcGray, edgeXMat, CV_16S, 1, 0, 3, 1, 0, cv::BORDER_DEFAULT);
// 求y方向Sobel邊緣
cv::Sobel(srcGray, edgeYMat, CV_16S, 0, 1, 3, 1, 0, cv::BORDER_DEFAULT);
// 線性變換轉換輸入數組元素為8位無符號整型
convertScaleAbs(edgeXMat, edgeXMat);
convertScaleAbs(edgeYMat, edgeYMat);
// x與y方向邊緣疊加
addWeighted(edgeXMat, 0.5, edgeYMat, 0.5, 0, edgeMat);
edgeMat2 = edgeMat.clone();
for (int i = 0; i < edgeXMat.rows; i++) {
for (int j = 0; j < edgeXMat.cols; j++) {
uchar v1 = edgeXMat.at<uchar>(i, j);
uchar v2 = edgeYMat.at<uchar>(i, j);
int value = (int)sqrt(v1 * v1 + v2 * v2);
if (value > 255) value = 255;
edgeMat2.at<uchar>(i, j) = value;
}
}
cv::Mat mean_mat;
cv::meanStdDev(edgeMat2, mean_mat, cv::noArray(), cv::noArray());
cv::threshold(edgeMat2, sobelMat, 10 * mean_mat.at<double>(0), 255, 0);
cv::imshow("edgMat", sobelMat);
return true;
}
圖像如圖所示：mark的輪廓也很完整。
Mark點的檢測分兩步，第一步需要先獲取圖像中mark點的參數，這個參數需要手動獲取，在操作平台上用鼠標點擊一個mark點，即可獲得mark點的面積，半徑的閾值范圍。這部分代碼對應代碼中的getAreaAndP函數，mark點的檢測對應的imgMatch函數。
如果需要測距，請參考我的相機標定計算兩點距離的博客。
附上完整代碼：
// imageMatch.cpp : 此文件包含 “main” 函數。程序執行將在此處開始並結束。
//
#include <iostream>
#include <opencv.hpp>
#include <vector>
#include <ctime>
#include <string>
typedef bool bool_t;
bool_t imgMatch(bool_t isMark, cv::Mat img, double contScope[2], int findObj, double pointCrd[2], int minRadius, int maxRadius, std::vector<cv::Point>& markContours);
double aveImg(cv::Mat imgC);
bool_t getAreaAndP(cv::Mat img, cv::Point2f getPoints, int findObj, double& minArea, double& maxArea, int& minR, int& maxR);
bool_t findMarkCenter(bool_t isMark, cv::Mat img, cv::Mat grayImg, cv::Mat thresh, double contScope[2], int findObj, double pointCrd[2], int minRadius, int maxRadius, std::vector<cv::Point>& markContours, double minPix);
bool_t sobelImage(cv::Mat src, cv::Mat &sobelMat);
bool_t getAreaAndR(cv::Mat thresh, cv::Point2f getPoints, std::vector<cv::Point> &cont_1, int &flag_1);
bool_t sobelImage(cv::Mat src, cv::Mat &sobelMat)
{
if (src.empty()) {
printf("sobelImage(): image empty!\r\n");
return false;
}
cv::Mat srcGray;
if (src.channels() == 3) {
cv::cvtColor(src, srcGray, cv::COLOR_BGR2GRAY);
}
else {
srcGray = src.clone();
}
// 定義邊緣圖，水平及垂直
cv::Mat edgeMat, edgeXMat, edgeYMat, edgeMat2;
// 求x方向Sobel邊緣
cv::Sobel(srcGray, edgeXMat, CV_16S, 1, 0, 3, 1, 0, cv::BORDER_DEFAULT);
// 求y方向Sobel邊緣
cv::Sobel(srcGray, edgeYMat, CV_16S, 0, 1, 3, 1, 0, cv::BORDER_DEFAULT);
// 線性變換轉換輸入數組元素為8位無符號整型
convertScaleAbs(edgeXMat, edgeXMat);
convertScaleAbs(edgeYMat, edgeYMat);
// x與y方向邊緣疊加
addWeighted(edgeXMat, 0.5, edgeYMat, 0.5, 0, edgeMat);
edgeMat2 = edgeMat.clone();
for (int i = 0; i < edgeXMat.rows; i++) {
for (int j = 0; j < edgeXMat.cols; j++) {
uchar v1 = edgeXMat.at<uchar>(i, j);
uchar v2 = edgeYMat.at<uchar>(i, j);
int value = (int)sqrt(v1 * v1 + v2 * v2);
if (value > 255) value = 255;
edgeMat2.at<uchar>(i, j) = value;
}
}
cv::Mat mean_mat;
cv::meanStdDev(edgeMat2, mean_mat, cv::noArray(), cv::noArray());
cv::threshold(edgeMat2, sobelMat, 10 * mean_mat.at<double>(0), 255, 0);
cv::imshow("edgMat", sobelMat);
return true;
}
bool_t getAreaAndR(cv::Mat thresh, cv::Point2f getPoints, std::vector<cv::Point> &cont_1, int &flag_1) {
std::vector<std::vector<cv::Point>> contours_1;
std::vector<cv::Vec4i> hierachy_1;
cv::findContours(thresh, contours_1, hierachy_1, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE, cv::Point());
//尋找點所在的輪廓
for (int i = 0; i < contours_1.size(); i++) {
double tmp = cv::pointPolygonTest(contours_1[i], getPoints, true);
if (tmp >= 0) {
cont_1 = contours_1[i];
flag_1 = 0;
break;
}
}
return 1;
}
bool_t getAreaAndP(cv::Mat img, cv::Point2f getPoints, int findObj, double& minArea, double& maxArea, int& minR, int& maxR) {
cv::Point2f center;
cv::Mat FilterImg;
cv::Mat grayImg, thresh1, thresh2;
float radius;
cv::bilateralFilter(img, FilterImg, 2, 40, 40);
if (FilterImg.channels() == 3) {
cv::cvtColor(FilterImg, grayImg, cv::COLOR_RGB2GRAY);
}
else {
grayImg = FilterImg;
}
sobelImage(grayImg, thresh2);
int histSize = 256;
cv::MatND hist;
float range[] = { 0, 255 };
const float *ranges = { range };
int threshNum = 100;
std::vector<int> threshNums;
//計算直方圖
calcHist(&grayImg, 1, 0, cv::Mat(), hist, 1, &histSize, &ranges, true, false);
//找到第一個波谷
for (int i = 3; i < 253; i++) {
if (hist.at<float>(i) > hist.at<float>(i - 1) && hist.at<float>(i) > hist.at<float>(i + 1) && hist.at<float>(i - 1) > hist.at<float>(i - 2) && hist.at<float>(i + 1) > hist.at<float>(i + 2) && hist.at<float>(i - 2) > hist.at<float>(i - 3) && hist.at<float>(i + 2) > hist.at<float>(i + 3)) {
//std::cout << i << std::endl;
threshNums.push_back(i);
}
}
if (threshNums.size() >= 2) {
threshNum = (threshNums[0] + threshNums[1]) / 2;
}
//設置最小閾值
if (threshNum < 80) {
threshNum = 80;
}
//進行二值化
cv::threshold(grayImg, thresh1, threshNum, 255, cv::THRESH_BINARY);
cv::bitwise_not(thresh1, thresh1);
int flag_1 = 1;
int flag_2 = 1;
std::vector<cv::Point> cont_1, cont_2;
getAreaAndR(thresh1, getPoints, cont_1, flag_1);
getAreaAndR(thresh2, getPoints, cont_2, flag_2);
if (flag_1 || flag_2) {
return 0;
}
std::vector<std::vector<cv::Point>> contours_2;
contours_2.push_back(cont_1);
if (findObj == 0) {
cv::Mat image_1 = cv::Mat(img.rows, img.cols, CV_8UC3, cv::Scalar(255, 255, 255));
//畫出輪廓
cv::drawContours(image_1, contours_2, -1, (0, 0, 255), 1);
//灰度處理
cv::Mat gray_1;
if (image_1.channels() == 3) {
cv::cvtColor(image_1, gray_1, cv::COLOR_BGR2GRAY);
}
else {
gray_1 = image_1;
}
std::vector<cv::Vec3f> objects;
//檢測輪廓中的圓形
//cv::imshow("gray", gray_1);
cv::HoughCircles(gray_1, objects, cv::HOUGH_GRADIENT, 1, 50, 100, 20, 5, 200);
if (objects.size() == 1) {
minEnclosingCircle(cont_1, center, radius);
if (radius > 300) {
return 0;
}
//最小篩選面積
minArea = 0.7 * 3.14 * radius * radius;
//最大篩選面積
maxArea = 1.3 * 3.14 * radius * radius;
//最小檢測圓半徑
minR = radius - 10;
//最大檢測圓半徑
maxR = radius + 10;
// mark點周邊像素
std::cout << minArea << std::endl;
std::cout << maxArea << std::endl;
std::cout << minR << std::endl;
std::cout << maxR << std::endl;
}
else {
return 0;
}
}
if (findObj == 1) {
std::vector<cv::Point>approx(cont_1);
double epsilon = cv::arcLength(cont_1, true) * 0.01;
cv::approxPolyDP(cont_1, approx, epsilon, true);
if (approx.size() >= 12 && approx.size() <= 16) {
//擬合輪廓最小外接矩形
cv::RotatedRect rect1 = cv::minAreaRect(cont_1);
cv::Point2f P[4];
rect1.points(P);
//獲取輪廓面積
double resArea = cv::contourArea(cont_1);
//最小篩選面積
minArea = 0.8 * resArea;
//最大篩選面積
maxArea = 1.2 * resArea;
float x = (P[0].x + P[2].x) / 2;
float y = (P[0].y + P[2].y) / 2;
center = cv::Point2f(x, y);
double longX = P[0].x - x;
double longY = P[0].y - y;
//std::cout << minArea << std::endl;
//std::cout << maxArea << std::endl;
}
else {
return 0;
}
}
return 1;
}
double aveImg(cv::Mat imgC) {
double sum = 0.0, ave;
for (int i = 0; i < imgC.rows; i++)
{
for (int j = 0; j < imgC.cols; j++)
{
sum = sum + imgC.at<bool>(i, j);
}
}
ave = sum / (imgC.rows * imgC.cols);
return ave;
}
bool_t findMarkCenter(bool_t isMark, cv::Mat img, cv::Mat grayImg, cv::Mat thresh, double contScope[2], int findObj, double pointCrd[2], int minRadius, int maxRadius, std::vector<cv::Point> &markContours, double minPix){
std::vector<std::vector<cv::Point>> contours;
std::vector<cv::Vec4i> hierachy;
std::vector<std::vector<cv::Point>> contours1;
//尋找輪廓邊框
cv::findContours(thresh, contours1, hierachy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point());
//篩選邊框，過濾掉過大或過小的邊框
for (int i = 0; i < contours1.size(); i++) {
double contArea = cv::contourArea(contours1[i]);
if (contArea > contScope[0] && contArea < contScope[1]) {
//std::cout << "markArea :" << contArea << std::endl;
contours.push_back(contours1[i]);
}
}
//std::cout << "contours_size :" << contours.size() << std::endl;
cv::Mat image = cv::Mat(img.rows, img.cols, CV_8UC3, cv::Scalar(255, 255, 255));
//畫出輪廓
cv::drawContours(image, contours, -1, (0, 0, 255), 3);
//灰度處理
cv::Mat gray;
if (image.channels() == 3) {
cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
}
else {
gray = image;
}
int mark = -1;
cv::Mat imgCGray;
if (img.channels() == 3) {
cv::cvtColor(img, imgCGray, cv::COLOR_BGR2GRAY);
}
else {
imgCGray = img;
}
std::vector<double> somePs;
if (findObj == 0) {
std::vector<cv::Vec3f> objects;
//檢測輪廓中的圓形
cv::HoughCircles(gray, objects, cv::HOUGH_GRADIENT, 1, 50, 100, 20, minRadius/* 10 */, maxRadius/* 40 */);
if (objects.size() == 0) {
return 0;
}
/*for (int i = 0; i < objects.size(); i++) {
std::cout << objects[i] << std::endl;
}*/
//計算檢測到的圓形周邊的平均像素，取周圍平均像素最大的圓為mark點所在位置
for (int i = 0; i < objects.size(); i++) {
if (objects[i][0] <= objects[i][2] * 2 || objects[i][1] <= objects[i][2] * 2 || (image.cols - objects[i][0]) <= objects[i][2] * 2 || (image.rows - objects[i][1]) <= objects[i][2] * 2) {
continue;
}
std::vector<cv::Point2f> rectCnt;
for (int k = objects[i][0] - objects[i][2] * 2; k < objects[i][0] + objects[i][2] * 2; k++) {
rectCnt.push_back(cv::Point2f(k, (objects[i][1] - objects[i][2] * 2)));
rectCnt.push_back(cv::Point2f(k, (objects[i][1] + objects[i][2] * 2)));
}
for (int k = objects[i][1] - objects[i][2] * 2; k < objects[i][1] + objects[i][2] * 2; k++) {
rectCnt.push_back(cv::Point2f((objects[i][0] - objects[i][2] * 2), k));
rectCnt.push_back(cv::Point2f((objects[i][0] + objects[i][2] * 2), k));
}
double sumP = 0;
for (int i = 0; i < rectCnt.size(); i++) {
sumP = sumP + grayImg.at<bool>(rectCnt[i].y, rectCnt[i].x);
}
double kP = sumP / rectCnt.size();
//std::cout << "sideP :" << kP << std::endl;
somePs.push_back(kP);
}
if (isMark) {
if (somePs.size() > 0) {
double p1 = somePs[0];
for (int i = 0; i < somePs.size(); i++) {
if (somePs[i] >= p1) {
p1 = somePs[i];
mark = i;
}
}
}
}
else {
if (somePs.size() > 0) {
for (int i = 0; i < somePs.size(); i++) {
if (somePs[i] > minPix) {
minPix = somePs[i];
mark = i;
}
}
}
}
if (mark == -1) {
return 0;
}
//最終的mark點，包含圓心和半徑
pointCrd[0] = objects[mark][0];
pointCrd[1] = objects[mark][1];
//std::cout << "R :" << objects[mark][2] << std::endl;
//橢圓擬合
for (int i = 0; i < contours.size(); i++)
{
if (pointPolygonTest(contours[i], cv::Point2f(pointCrd[0], pointCrd[1]), true) > 0)
{
cv::RotatedRect box = fitEllipse(contours[i]);
pointCrd[0] = box.center.x;
pointCrd[1] = box.center.y;
markContours = contours[i];
//std::cout << box.center << std::endl;
//std::cout << markContours << std::endl;
break;
}
}
}
if (findObj == 1)
{
std::vector<std::vector<cv::Point>> approx(contours);
std::vector<std::vector<cv::Point>> conts;
std::vector<cv::Vec4f> objects;
//檢測圖像中的十字叉
//std::cout << contours.size() << std::endl;
for (int i = 0; i < contours.size(); i++) {
double epsilon = cv::arcLength(contours[i], true) * 0.01;
cv::approxPolyDP(contours[i], approx[i], epsilon, true);
//std::cout << approx[i].size() << std::endl;
if (approx[i].size() >= 12 && approx[i].size() <= 16) {
conts.push_back(contours[i]);
}
}
if (conts.size() == 0) {
return 0;
}
for (int i = 0; i < conts.size(); i++) {
cv::RotatedRect rect = minAreaRect(contours[i]);
cv::Point2f P[4];
rect.points(P);
float x = (P[0].x + P[2].x) / 2;
float y = (P[0].y + P[2].y) / 2;
objects.push_back(cv::Vec4f(x, y, abs(P[0].x - x) * 2, abs(P[0].y - y) * 2));
}
//計算檢測到的叉周邊的平均像素，取周圍平均像素最大的圓為mark點所在位置
for (int i = 0; i < objects.size(); i++) {
if (objects[i][0] <= 50 || objects[i][1] <= 50 || (image.cols - objects[i][0]) <= 50 || (image.rows - objects[i][1]) <= 50) {
continue;
}
cv::Mat imgC1, imgC2, imgC3, imgC4;
cv::Rect rect1(objects[i][0] - objects[i][2], objects[i][1] - objects[i][3] / 2, objects[i][2] / 2, objects[i][3]);
imgCGray(rect1).copyTo(imgC1);
double k1 = aveImg(imgC1);
cv::Rect rect2(objects[i][0] + objects[i][2] / 2, objects[i][1] - objects[i][3] / 2, objects[i][2] / 2, objects[i][3]);
imgCGray(rect2).copyTo(imgC2);
double k2 = aveImg(imgC2);
cv::Rect rect3(objects[i][0] - objects[i][2] / 2, objects[i][1] - objects[i][3], objects[i][2], objects[i][3] / 2);
imgCGray(rect3).copyTo(imgC3);
double k3 = aveImg(imgC3);
cv::Rect rect4(objects[i][0] - objects[i][2] / 2, objects[i][1] + objects[i][3] / 2, objects[i][2], objects[i][3] / 2);
imgCGray(rect4).copyTo(imgC4);
double k4 = aveImg(imgC4);
double kP = (k1 + k2 + k3 + k4) / 4;
somePs.push_back(kP);
}
if (isMark) {
if (somePs.size() > 0) {
double p1 = somePs[0];
for (int i = 0; i < somePs.size(); i++) {
if (somePs[i] >= p1) {
p1 = somePs[i];
mark = i;
}
}
}
}
else {
if (somePs.size() > 0) {
for (int i = 0; i < somePs.size(); i++) {
if (somePs[i] > minPix) {
minPix = somePs[i];
mark = i;
}
}
}
}
if (mark == -1) {
return 0;
}
//最終的mark點，包含中點和長寬
pointCrd[0] = objects[mark][0];
pointCrd[1] = objects[mark][1];
markContours = contours[mark];
//std::cout << pointCrd[0] << "," << pointCrd[1] << std::endl;
//std::cout << markContours << std::endl;
}
return true;
}
bool_t imgMatch(bool_t isMark, cv::Mat img, double contScope[2], int findObj, double pointCrd[2], int minRadius, int maxRadius, std::vector<cv::Point> &markContours)
{
cv::Mat FilterImg;
cv::Mat grayImg, thresh1, thresh2;
cv::Mat openImg;
cv::bilateralFilter(img, FilterImg, 2, 40, 40);
if (FilterImg.channels() == 3) {
cv::cvtColor(FilterImg, grayImg, cv::COLOR_RGB2GRAY);
}
else {
grayImg = FilterImg;
}
sobelImage(grayImg, thresh2);
int histSize = 256;
cv::MatND hist;
float range[] = { 0, 255 };
const float *ranges = { range };
double pointCrd1[2], pointCrd2[2];
int threshNum = 100;
std::vector<int> threshNums;
std::vector<cv::Point> markContours1, markContours2;
//計算直方圖
calcHist(&grayImg, 1, 0, cv::Mat(), hist, 1, &histSize, &ranges, true, false);
//找到波峰
for (int i = 3; i < 253; i++) {
if (hist.at<float>(i) > hist.at<float>(i - 1) && hist.at<float>(i) > hist.at<float>(i + 1) && hist.at<float>(i - 1) > hist.at<float>(i - 2) && hist.at<float>(i + 1) > hist.at<float>(i + 2) && hist.at<float>(i - 2) > hist.at<float>(i - 3) && hist.at<float>(i + 2) > hist.at<float>(i + 3)) {
//std::cout << i << std::endl;
threshNums.push_back(i);
}
}
if (threshNums.size() >= 2) {
threshNum = (threshNums[0] + threshNums[1]) / 2;
}
if (threshNum < 80) {
threshNum = 80;
}
double minPix = threshNums[threshNums.size() - 1] * 0.9;
//std::cout << "thresh :" << threshNum << std::endl;
cv::threshold(grayImg, thresh1, threshNum, 255, cv::THRESH_BINARY);
cv::bitwise_not(thresh1, thresh1);
cv::imshow("thresh", thresh1);
findMarkCenter(isMark, img, grayImg, thresh1, contScope, findObj, pointCrd1, minRadius, maxRadius, markContours1, minPix);
findMarkCenter(isMark, img, grayImg, thresh2, contScope, findObj, pointCrd2, minRadius, maxRadius, markContours2, minPix);
if (markContours1.size() == 0 || markContours2.size() == 0) {
return false;
}
//std::cout << pointCrd1[0] << "," << pointCrd1[1] << std::endl;
//std::cout << pointCrd2[0] << "," << pointCrd2[1] << std::endl;
if (abs(pointCrd1[0] - pointCrd2[0]) <= 1 && abs(pointCrd1[1] - pointCrd2[1]) <= 1) {
pointCrd[0] = (pointCrd1[0] + pointCrd2[0]) / 2;
pointCrd[1] = (pointCrd1[1] + pointCrd2[1]) / 2;
markContours = markContours1;
}
else {
return false;
}
std::cout << pointCrd[0] << "," << pointCrd[1] << std::endl;
return true;
}
int main()
{
long start = clock();
/*std::cout << time1 << std::endl;*/
//std::vector<cv::Mat> images;
//images.push_back(cv::imread("E:\\python\\opencv\\002\\10208.bmp"));
cv::Mat img = cv::imread("E:\\python\\opencv\\002\\10231.bmp");
//輪廓面積的最大值和最小值
double contScope[2] = { 500, 5000 };
//mark點周邊平均像素的最小閾值
double minPix = 135;
//選擇要檢測的形狀
int findObj = 0;
double pointCrd[2];
int minRadius = 10;
int maxRadius = 30;
bool_t isMark = true;
std::vector<cv::Point> markContours;
imgMatch(isMark, img, contScope, findObj, pointCrd, minRadius, maxRadius, markContours);
/*long end = clock();*/
//std::cout << end - start << std::endl;
cv::Point2f Points;
Points = cv::Point2f(1515, 806);
int minR, maxR;
double minArea, maxArea, resP;
getAreaAndP(img, Points, findObj, minArea, maxArea, minR, maxR);
cv::imshow("img", img);
cv::waitKey(0);
}