5.11实例应用

5.11.1 颜色圆检测

RGB:

RGBA（Alpha），A用于描述三原色的透明度！

单通道：

俗称灰度图，每个像素点只能有一个值表示颜色，它的像素值在0到255之间，0是黑色，255是白色，中间值是一些不同等级的灰色，可以说灰度是黑与白之间的过渡色！

多通道：

多通道也就是RGB三原色，每个像素点有三个字节来表示（RGB），分别最大取值范围是0-255，可以组合成千万种颜色。

所以三通道想要组合成黑白色(灰度)必须三原色值相同。也就是说灰度图不一定是单通道，但是单通道一定是灰度图！

色调、饱和度、亮度（Hue, Saturation, Value）：

色调（偏向）：

色调决定一个像素点中的颜色更偏向于哪一方(RGB)：

饱和度（深浅）：

饱和度决定了颜色空间中颜色分量，饱和度越高，说明颜色越深，饱和度越低，说明颜色越浅！

亮度（明暗）：

亮度决定颜色空间中颜色的明暗程度！

RGB和HSV关系：

其实色调，饱和度，亮度都是通过特定的算法经过计算修改RGB三色而达到的控制颜色效果！

• 色调（H：hue）：用角度度量，取值范围为0°～360°，从红色开始按逆时针方向计算，红色为0°，绿色为120°,蓝色为240°。它们的补色是：黄色为60°，青色为180°,品红为300°；
• 饱和度（S：saturation）：取值范围为0.0～1.0，值越大，颜色越饱和。
• 亮度（V：value）：取值范围为0(黑色)～255(白色)。

参考：

https://blog.csdn.net/bjbz_cxy/article/details/79701006

OpenCV下有个函数可以直接将RGB模型转换为HSV模型，注意的是OpenCV中H∈ [0, 180）， S ∈ [0, 255]， V ∈ [0, 255]。 

HoughCircles()使用比较关键是参数的设置

////////////https://blog.csdn.net/piaoxuezhong/article/details/60757278
////////找出圆绘制圆心和外圆
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{

    Mat srcImage = imread("D:\1块硬币.jpg");
    Mat midImage, dstImage;
    imshow("【原始图】", srcImage);

    cvtColor(srcImage, midImage, CV_BGR2GRAY);//转化边缘检测后的图为灰度图
    GaussianBlur(midImage, midImage, Size(9, 9), 2, 2);
    vector<Vec3f> circles;
    HoughCircles(midImage, circles, CV_HOUGH_GRADIENT, 1, midImage.rows / 20, 100, 100, 0, 0);
    //依次在图中绘制出圆
    for (size_t i = 0; i < circles.size(); i++)
    {
        Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
        int radius = cvRound(circles[i][2]);
        //绘制圆心
        circle(srcImage, center, 3, Scalar(0, 255, 0), -1, 8, 0);
        //绘制圆轮廓
        circle(srcImage, center, radius, Scalar(155, 50, 255), 3, 8, 0);
    }

    imshow("【效果图】", srcImage);
    waitKey(0);
    return 0;
}

第1张图片：

第2张图片：

参考：https://blog.csdn.net/piaoxuezhong/article/details/60757278

////////https://blog.csdn.net/linqianbi/article/details/78936612
#include<opencv2highguihighgui.hpp>
#include<opencv2imgprocimgproc.hpp>
#include<iostream>
#include<vector>
using namespace cv;
using namespace std;
int main()
{
    Mat srcImage = imread("D:\颜色圆.jpg");
    if (!srcImage.data)
    {
        printf("could not load image...
");
        return -1;
    }
    imshow("srcImage", srcImage);
    Mat resultImag = srcImage.clone();
    //中值滤波
    medianBlur(srcImage, srcImage, 3);
    //转换成HSV颜色空间
    Mat hsvImage;
    cvtColor(srcImage, hsvImage, CV_BGR2HSV);
    imshow("hsvImage", hsvImage);
    //颜色阈值化处理
    //定义高低阈值
    Mat lowMat;
    Mat upperMat;
    //红色H的范围是[0,10]  [160,180]
    inRange(hsvImage, Scalar(0, 100, 100), Scalar(10, 255, 255), lowMat);
    inRange(hsvImage, Scalar(160, 100, 100), Scalar(179, 255, 255), upperMat);
    imshow("lowMat", lowMat);
    imshow("upperMat", upperMat);
    //将高低阈值合并
    Mat redMat;
    addWeighted(lowMat, 1, upperMat, 1, 0, redMat);
    imshow("redMat", redMat);
    //高斯滤波
    GaussianBlur(redMat, redMat, Size(9, 9), 2, 2);
    //霍夫圆加测
    vector<Vec3f>  circles;
    HoughCircles(redMat, circles, CV_HOUGH_GRADIENT, 1, redMat.rows / 8, 100, 50, 0, 0);
    //如果没有检测到圆
    if (circles.size() == 0)
        return -1;
    for (int i = 0; i < circles.size(); i++)
    {
        //求出圆心的位置和圆半径的大小
        Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
        int radius = cvRound(circles[i][2]);
        circle(resultImag, center, radius, Scalar(0, 255, 0), 5);
    }
    imshow("resultImag", resultImag);
    waitKey(0);
    return 0;
}

1.将原始图片的BGR颜色空间转换到HSV色彩空间

2.根据红色在HSV中的范围，对图像进行阈值分割，红色的圆被保留（白色）,其他的变成黑色

3.对步骤二检测到的高低阈值的颜色圆进行合并，找出属于红色的圆

4.利用霍夫圆检测算法找出步骤3中的圆

 

拓展：

如果要选中找出蓝色圆：

需要一个取色和调色小工具，这个小工具支持HSV空间的取色。不过不管是这个小工具还是PS中,H的范围都是0~360,S的范围是0到百分之百，V的范围也是0到百度分之百，这个也和百科上的解释是一致的。所以你在具体使用的时候要按比例转化一下哦！比如车牌蓝在标准HSV中是（225，100%，81%）那么转换到OpenCV中就是（225/360*180，255*100%，255*81%）！

参考：https://blog.csdn.net/wenhao_ir/article/details/51850948 

下面是用HoughCircles函数进行霍夫变换圆检测的实例。由于HoughCircles函数内是调用Canny函数进行边缘检测，opencv的Canny函数是不包括平滑滤波这一步的，因此为了增强抗干扰能力，在使用HoughCircles函数之前，我们先对原图进行滤波处理，我们使用的是高斯模糊方法。 

 参考：

https://blog.csdn.net/piaoxuezhong/article/details/60757278

https://blog.csdn.net/linqianbi/article/details/78936612

https://blog.csdn.net/poem_qianmo/article/details/26977557

https://blog.csdn.net/yanxiaolx/article/details/62889943

未研究：https://blog.csdn.net/taily_duan/article/details/51886019 

http://www.opencv.org.cn/forum.php?mod=viewthread&tid=34096

5.11.2 车牌区域检测

////////https://blog.csdn.net/z827997640/article/details/80527581

#include <iostream>
#include <vector>
#include <stdint.h>
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/features2d/features2d.hpp"
// 提取竖直的sobel边缘
bool SobelVerEdge(cv::Mat srcImage, cv::Mat& resultImage)
{
    CV_Assert(srcImage.channels() == 1);
    srcImage.convertTo(srcImage, CV_32FC1);
    // 水平方向的 Sobel 算子
    cv::Mat sobelx = (cv::Mat_<float>(3, 3) << -0.125, 0, 0.125,
        -0.25, 0, 0.25,
        -0.125, 0, 0.125);
    cv::Mat ConResMat;
    // 卷积运算
    cv::filter2D(srcImage, ConResMat, srcImage.type(), sobelx);
    // 计算梯度的幅度
    cv::Mat graMagMat;
    cv::multiply(ConResMat, ConResMat, graMagMat);
    // 根据梯度幅度及参数设置阈值
    int scaleVal = 4;
    double thresh = scaleVal * cv::mean(graMagMat).val[0];
    cv::Mat resultTempMat = cv::Mat::zeros(
        graMagMat.size(), graMagMat.type());
    float* pDataMag = (float*)graMagMat.data;
    float* pDataRes = (float*)resultTempMat.data;
    const int nRows = ConResMat.rows;
    const int nCols = ConResMat.cols;
    for (int i = 1; i != nRows - 1; ++i) {
        for (int j = 1; j != nCols - 1; ++j) {
            // 计算该点梯度与水平或垂直梯度值大小比较结果
            bool b1 = (pDataMag[i * nCols + j] > pDataMag[i *
                nCols + j - 1]);
            bool b2 = (pDataMag[i * nCols + j] > pDataMag[i *
                nCols + j + 1]);
            bool b3 = (pDataMag[i * nCols + j] > pDataMag[(i - 1)
                * nCols + j]);
            bool b4 = (pDataMag[i * nCols + j] > pDataMag[(i + 1)
                * nCols + j]);
            // 判断邻域梯度是否满足大于水平或垂直梯度
            // 并根据自适应阈值参数进行二值化
            pDataRes[i * nCols + j] = 255 * ((pDataMag[i *
                nCols + j] > thresh) &&
                ((b1 && b2) || (b3 && b4)));
        }
    }
    resultTempMat.convertTo(resultTempMat, CV_8UC1);
    resultImage = resultTempMat.clone();
    return true;
}
// 疑似区域提取
cv::Mat getPlateArea(cv::Mat srcImage, cv::Mat sobelMat)
{
    // 转换成hsv 
    cv::Mat img_h, img_s, img_v, imghsv;
    std::vector<cv::Mat> hsv_vec;
    cv::cvtColor(srcImage, imghsv, CV_BGR2HSV);
    cv::imshow("hsv", imghsv);
    cv::waitKey(0);
    // 分割hsv通道
    cv::split(imghsv, hsv_vec);
    img_h = hsv_vec[0];
    img_s = hsv_vec[1];
    img_v = hsv_vec[2];
    img_h.convertTo(img_h, CV_32F);
    img_s.convertTo(img_s, CV_32F);
    img_v.convertTo(img_v, CV_32F);
    double max_s, max_h, max_v;
    cv::minMaxIdx(img_h, 0, &max_h);
    cv::minMaxIdx(img_s, 0, &max_s);
    cv::minMaxIdx(img_v, 0, &max_v);
    // 各个通道归一化
    img_h /= max_h;
    img_s /= max_s;
    img_v /= max_v;
    // hsv 限定范围元素提取
    cv::Mat bw_blue = ((img_h>0.45) &
        (img_h<0.75) &
        (img_s>0.15) &
        (img_v>0.25));
    int height = bw_blue.rows;
    int width = bw_blue.cols;
    cv::Mat bw_blue_edge = cv::Mat::zeros(bw_blue.size(), bw_blue.type());
    cv::imshow("bw_blue", bw_blue);
    cv::waitKey(0);
    // 车牌疑似区域提取
    for (int k = 1; k != height - 2; ++k)
    {
        for (int l = 1; l != width - 2; ++l)
        {
            cv::Rect rct;
            rct.x = l - 1;
            rct.y = k - 1;
            rct.height = 3;
            rct.width = 3;
            if ((sobelMat.at<uchar>(k, l) == 255) && (cv::countNonZero(bw_blue(rct)) >= 1))
                bw_blue_edge.at<uchar>(k, l) = 255;
        }
    }
    // 形态学闭操作
    cv::Mat morph;
    cv::morphologyEx(bw_blue_edge, morph, cv::MORPH_CLOSE,
        cv::Mat::ones(2, 25, CV_8UC1));
    cv::Mat imshow5;
    cv::resize(bw_blue_edge, imshow5, cv::Size(), 1, 1);
    cv::imshow("morphology_bw_blue_edge", imshow5);
    cv::waitKey(0);
    // 连通区域提取
    cv::imshow("morph", morph);
    std::vector<std::vector<cv::Point> > region_contours;
    cv::findContours(morph.clone(), region_contours,
        CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0));
    std::vector<cv::Rect> candidates;
    std::vector<cv::Mat> candidates_img;
    cv::Mat result;
    for (size_t n = 0; n != region_contours.size(); ++n)
    {
        // 去除高度宽度不符合条件区域
        cv::Rect rect = cv::boundingRect(region_contours[n]);
        int sub = cv::countNonZero(morph(rect));
        double ratio = double(sub) / rect.area();
        double wh_ratio = double(rect.width) / rect.height;
        if (ratio > 0.5 && wh_ratio > 2 && wh_ratio < 5 &&
            rect.height > 12 && rect.width > 60)
        {
            cv::Mat small = bw_blue_edge(rect);
            result = srcImage(rect);
            cv::imshow("rect", srcImage(rect));
            cv::waitKey(0);
        }
    }
    return result;
}
int main()
{
    cv::Mat srcImage = cv::imread("D:\车辆4.jpg");
    if (!srcImage.data)
        return 1;
    cv::Mat srcGray;
    cv::cvtColor(srcImage, srcGray, CV_RGB2GRAY);
    cv::imshow("srcImage", srcImage);
    // sobel 提取边缘
    cv::Mat sobelMat;
    SobelVerEdge(srcGray, sobelMat);
    cv::imshow("Sobel", sobelMat);
    // 疑似区域提取
    cv::Mat result = getPlateArea(srcImage, sobelMat);
    cv::imshow("result", result);
    return 0;
}

////////https://blog.csdn.net/hust_bochu_xuchao/article/details/52230694
////////第4章图片“车辆4”才识别出车牌
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/features2d.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
// Mser车牌目标检测
std::vector<cv::Rect> mserGetPlate(cv::Mat srcImage)
{
    // HSV空间转换
    cv::Mat gray, gray_neg;
    cv::Mat hsi;
    cv::cvtColor(srcImage, hsi, CV_BGR2HSV);
    // 通道分离
    std::vector<cv::Mat> channels;
    cv::split(hsi, channels);
    // 提取h通道
    gray = channels[1];
    cv::imshow("提取h通道", gray);
    // 灰度转换 
    cv::cvtColor(srcImage, gray, CV_BGR2GRAY);
    // 取反值灰度
    gray_neg = 255 - gray;
    std::vector<std::vector<cv::Point> > regContours;
    std::vector<std::vector<cv::Point> > charContours;

    // 创建MSER对象
    cv::Ptr<cv::MSER> mesr1 = cv::MSER::create(2, 10, 5000, 0.5, 0.3);
    cv::Ptr<cv::MSER> mesr2 = cv::MSER::create(2, 2, 400, 0.1, 0.3);


    std::vector<cv::Rect> bboxes1;
    std::vector<cv::Rect> bboxes2;
    // MSER+ 检测
    mesr1->detectRegions(gray, regContours, bboxes1);
    // MSER-操作
    mesr2->detectRegions(gray_neg, charContours, bboxes2);

    cv::Mat mserMapMat = cv::Mat::zeros(srcImage.size(), CV_8UC1);
    cv::Mat mserNegMapMat = cv::Mat::zeros(srcImage.size(), CV_8UC1);

    for (int i = (int)regContours.size() - 1; i >= 0; i--)
    {
        // 根据检测区域点生成mser+结果
        const std::vector<cv::Point>& r = regContours[i];
        for (int j = 0; j < (int)r.size(); j++)
        {
            cv::Point pt = r[j];
            mserMapMat.at<unsigned char>(pt) = 255;
        }
    }
    // MSER- 检测
    for (int i = (int)charContours.size() - 1; i >= 0; i--)
    {
        // 根据检测区域点生成mser-结果
        const std::vector<cv::Point>& r = charContours[i];
        for (int j = 0; j < (int)r.size(); j++)
        {
            cv::Point pt = r[j];
            mserNegMapMat.at<unsigned char>(pt) = 255;
        }
    }
    // mser结果输出
    cv::Mat mserResMat;
    // mser+与mser-位与操作
    mserResMat = mserMapMat & mserNegMapMat;
    cv::imshow("mserMapMat", mserMapMat);
    cv::imshow("mserNegMapMat", mserNegMapMat);
    cv::imshow("mserResMat", mserResMat);
    // 闭操作连接缝隙
    cv::Mat mserClosedMat;
    cv::morphologyEx(mserResMat, mserClosedMat,
        cv::MORPH_CLOSE, cv::Mat::ones(1, 20, CV_8UC1));
    cv::imshow("mserClosedMat", mserClosedMat);
    // 寻找外部轮廓
    std::vector<std::vector<cv::Point> > plate_contours;
    cv::findContours(mserClosedMat, plate_contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0));
    // 候选车牌区域判断输出
    std::vector<cv::Rect> candidates;
    for (size_t i = 0; i != plate_contours.size(); ++i)
    {
        // 求解最小外界矩形
        cv::Rect rect = cv::boundingRect(plate_contours[i]);
        // 宽高比例
        double wh_ratio = rect.width / double(rect.height);
        // 不符合尺寸条件判断
        if (rect.height > 20 && wh_ratio > 4 && wh_ratio < 7)
            candidates.push_back(rect);
    }
    return  candidates;
}
int main()
{
    cv::Mat srcImage = cv::imread("D:\车辆4.jpg");
    if (srcImage.empty())
        return-1;
    cv::imshow("src Image", srcImage);
    // 候选车牌区域检测
    std::vector<cv::Rect> candidates;
    candidates = mserGetPlate(srcImage);
    // 车牌区域显示
    for (int i = 0; i < candidates.size(); ++i)
    {
        cv::imshow("rect", srcImage(candidates[i]));
        cv::waitKey();
    }
    cv::waitKey(0);
    return 0;
}