基于opencv华为杯识别红蓝牌箭头方向

好久没更博客了, 借此机会复习一下之前学过的东西

话不多说, 先看要识别的图片

 

 

 

 

 

 

 红色和蓝色的差不多, 只要调好hsv色域就行(创建滑动条), 本程序就以蓝色的为例

牌反光后无法识别的问题并没有解决

程序思路

1. 进行二值化和多次腐蚀操作后找到牌的轮廓和所有点的轮廓, 利用sort()函数对轮廓进行从大到小的排序, 面积最大的轮廓为牌的轮廓, 其余的为孔的轮廓, 并绘制出牌的外边框(寻找最小旋转矩形)
2. 对外边界的矩形顶点进行编号(编好号的顺序短边必定为03和12且03一直位于12的下方, 并以逆时针顺序排序), 利用已经编好号的四个顶点确定矩形平行于长边的中线L, 和编号0,3组成的短边M 
3. 将所有孔的轮廓转换为最小旋转矩形(为得到所有孔的中心点), 随意找一个点(我直接用的轮廓排序后的第一个点), 并找到与之最近的点, 分别判断两点到中线L的距离, 得到远离中线的点b和接近中线的点a
4. 
   
5. 判断点a, b到短边M的距离, 若点a到M的距离小于点b到M的距离, 则箭头朝下, 反之朝上
6. 根据当前数据进行三次判断才会显示最终结果, 否则显示none

程序

#include <iostream>
#include <opencv2/opencv.hpp>
#include <vector>

using namespace cv;
using namespace std;

Mat src, hsv, n_erode, edge, element;

int h_max = 179, s_max = 255, v_max = 255;
int h_min = 90, s_min = 110, v_min = 110;

typedef struct line_normal{
    double line_a;
    double line_b;
    double line_c;
}Normalline;

//滑动条回调函数
void on_callback(int, void*);

//获取直线一般式的ABC
void get_line_normal(Point point1, Point point2, Normalline &n_line);

//点到直线的距离
double get_pointline_distance(Point n_point, Normalline n_line);

//用于sort的比较函数
static inline bool ContoursSortFun(vector<cv::Point> contourone,vector<cv::Point> contourtwo)
{
    return (contourone.size() > contourtwo.size());
}

int main() {
    VideoCapture video(0);
    char key;
    //判断方向结果累加
    int up_count = 0, down_count = 0;
    //中线一般式
    Normalline midline = {0,0,0};
    //边界线一般式
    Normalline borderline = {0, 0, 0};

    while(1){
        video >> src;
        //文字定义
        string text;
        int baseline;
        Size text_size = getTextSize(text, FONT_HERSHEY_PLAIN, 2,  2, &baseline);
        Point origin((src.cols - text_size.width) / 2, text_size.height);

        //进行颜色转换
        cvtColor(src, hsv, COLOR_BGR2HSV);

        //创建滑动条
        createTrackbar("H最大值", "二值图", &h_max, 179, on_callback);
        createTrackbar("H最小值", "二值图", &h_min, 179, on_callback);
        createTrackbar("S最大值", "二值图", &s_max, 255, on_callback);
        createTrackbar("S最小值", "二值图", &s_min, 255, on_callback);
        createTrackbar("V最大值", "二值图", &v_max, 255, on_callback);
        createTrackbar("V最小值", "二值图", &v_min, 255, on_callback);

        on_callback(0, 0);
        /************************寻找轮廓************************/
        vector<vector<Point>>contours;
        vector<Vec4i> hierarchy;

        //轮廓内所有的孔
        vector<RotatedRect> hole;
        //找到所有轮廓
        findContours(n_erode, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE);
        if(contours.empty() || hierarchy.empty() || contours.size() == 0 || hierarchy.size() == 0) {
            waitKey(CAP_PROP_FPS);
            continue;
        }
        //对所有轮廓进行排序(最大的那个轮廓为外轮廓)
        std::sort(contours.begin(), contours.end(), ContoursSortFun);

        //找到最大轮廓的最小旋转矩形
        RotatedRect rrect;
        rrect = minAreaRect(contours[0]);

        //读取最小外接矩形的4个顶点
        Point2f  points[4];
        rrect.points(points);
        //绘制矩形
        for(int j = 0; j < 4; ++j){
            line(src, points[j], points[(j + 1) % 4], Scalar(255, 0, 0), 2, 8, 0);
        }
        /****************************给外边界矩形进行编号****************************/
        //绘制顶点
        for(int i = 0; i < 4; ++i){
            circle(src, points[i], 5, Scalar(0, 0, 255), 2);
        }
        //计算边长比较出长边，一次while只运行一次, 对顶点进行编号
        double border = 0;
        int num1 = 0, num2 = 0, num3 = 0, num4 = 0; //储存点在数据中的序号
        for (int j = 0; j < 4; j++) {
            //a2+b2方法比较长度
            double border1 = pow((points[j % 4].x - points[(j + 1) % 4].x), 2) + pow((points[j % 4].y - points[(j + 1) % 4].y), 2);
            //比较前两次，后两次长边
            if (border <= border1) {
                if (j <= 1) {
                    num1 = j % 4;
                    num2 = (j + 1) % 4;
                    border = border1;
                }
                else{
                    num3 = j % 4;
                    num4 = (j + 1) % 4;
                    border = border1;
                }
            }
        }
        //获取短边边界
        get_line_normal(points[num1], points[num4], borderline);
        Point mid1 = Point ((points[num1].x + points[num4].x) / 2, (points[num1].y + points[num4].y) / 2);
        Point mid2 = Point ((points[num2].x + points[num3].x) / 2, (points[num2].y + points[num3].y) / 2);
        line(src, mid1, mid2, Scalar(128,0,0), 2, 8);
        //获取中线信息
        get_line_normal(mid1, mid2, midline);
        /****************************寻找轮廓内的点****************************/
        //所有孔化为最小旋转矩形(contours[0]为牌的外轮廓)
        for (int i = 1; i < contours.size(); ++i) {
            hole.push_back(minAreaRect(contours[i]));
        }
        if(hole.empty() || hole.size() == 0) {
            waitKey(CAP_PROP_FPS);
            continue;
        }
        int point_dis = 1000;
        int inner1 = 0, inner2 = 0;
        //找到距离最小的两个点
        for(int j = 0; j < hole.size(); ++j){
            int tmp_dis = pow(hole[inner1].center.x - hole[j].center.x, 2) + pow(hole[inner1].center.y - hole[j].center.y, 2);
            if(tmp_dis < point_dis && inner1 != j){
                point_dis = tmp_dis;
                inner2 = j;
            }
        }

        //计算内部点到直线的距离
        double pointd1 = get_pointline_distance(hole[inner1].center, midline);
        double pointd2 = get_pointline_distance(hole[inner2].center, midline);

        //保证点2一定是离中线最远的点
        if(pointd1 < pointd2){
            int t = inner1;
            inner1 = inner2;
            inner2 = t;
        }

        //圈出距离最小的两个点
        circle(src, hole[inner1].center, 5, Scalar(255, 255, 0), 2);
        circle(src, hole[inner2].center, 5, Scalar(0, 255, 255), 2);

        /***************找到远离中线的点和近中线的点到某一短边的距离,并进行比较****************/
        int innerd1 = (int)get_pointline_distance(hole[inner1].center, borderline);
        int innerd2 = (int)get_pointline_distance(hole[inner2].center, borderline);
        if(innerd1 > innerd2) {up_count = 0;text = "down"; down_count++;}
        else {down_count = 0;text = "up"; up_count++;}

        //累计三次结果一样才会显示方向
        if(up_count < 3 && down_count < 3) {
            text = "none";
        }

        putText(src, text, origin, FONT_HERSHEY_PLAIN, 2, Scalar(0, 255, 0), 2, 8);
        cout << CAP_PROP_FPS << endl;
        imshow("效果图", src);
        key = (char) waitKey(CAP_PROP_FPS);
        if(key == 27) break;
    }
    return 0;
}

//滑动条回调函数
void on_callback(int, void*){
    inRange(hsv, Scalar(h_min, s_min, v_min), Scalar(h_max, s_max, v_max), hsv);
    //获取自定义内核
    element = getStructuringElement(MORPH_ELLIPSE,Size(3, 3));

    erode(hsv, n_erode, element);
    erode(n_erode, n_erode, element);
    erode(n_erode, n_erode, element);

    imshow("腐蚀膨胀图", n_erode);
    imshow("二值图", hsv);
}

//获取直线一般式的ABC
void get_line_normal(Point point1, Point point2, Normalline &n_line){
    n_line.line_a = point2.y - point1.y;
    n_line.line_b = point1.x - point2.x;
    n_line.line_c = point2.x * point1.y - point1.x * point2.y;
}

//点到直线的距离
double get_pointline_distance(Point n_point, Normalline n_line){
    return fabs((n_line.line_a * n_point.x + n_line.line_b * n_point.y + n_line.line_c)/
    sqrt(pow(n_line.line_a, 2) + pow(n_line.line_b, 2)));
}

最终效果

 

 本程序遍历次数太多, 有些地方还不精简, 帧率提不上来

菜鸡一枚, 还请多多指教