OpenCV 和 C++ - 形状和道路标志检测答案

【问题标题】：OpenCV and C++ - Shape and road signs detectionOpenCV 和 C++ - 形状和道路标志检测
【发布时间】：2018-12-07 09:30:55
【问题描述】：

我必须编写一个程序来检测 3 种类型的道路标志（限速、禁止停车和警告）。我知道如何使用 HoughCircles 检测圆，但我有几张图像，并且 HoughCircles 的参数对于每张图像都不同。有没有一种通用的方法可以在不更改每张图像的参数的情况下检测圆圈？

此外，我需要检测三角形（警告标志），因此我正在寻找通用形状检测器。你有什么建议/代码可以帮助我完成这项任务吗？

最后，为了检测限速标志上的数字，我想使用 SIFT 并将图像与一些模板进行比较，以识别标志上的数字。会不会是个好办法？

谢谢你的回答！

【问题讨论】：

标签： c++ opencv shape object-detection

【解决方案1】：

也许您应该尝试实施 ransac 算法，如果您使用的是彩色图像，最好只获得红色通道（如果您在欧洲），因为速度限制被红色的 cricle（或我也认为是薄的白色）。

为此，您需要过滤图像以获得边缘，（canny 过滤器）。

这里有一些有用的链接：

OpenCV detect partial circle with noise

https://hal.archives-ouvertes.fr/hal-00982526/document

最后对于数字检测，我认为还可以。其他方法是使用 Viola-Jones 算法之类的方法来检测信号，并使用预先训练的现有模型......这取决于你！

【讨论】：

【解决方案2】：

我知道这是一个很老的问题，但我也遇到过同样的问题，现在我向您展示我是如何解决它的。下图显示了 opencv 程序显示的一些最准确的结果。在下图中，检测到的路标用三种不同的颜色圈出，以区分三种路标（警告、禁止停车、限速）。

红色表示警告标志
蓝色表示禁止停车标志
限速标志的紫红色

限速标志上方用绿色写成限速值

[![example][1]][1]
[![example][2]][2]
[![example][3]][3]
[![example][4]][4]

如您所见，该程序的性能相当不错，它能够检测和区分三种标志，并在限速标志的情况下识别限速值。一切都是在没有计算太多误报的情况下完成的，例如，当图像中有一些不属于三个类别之一的标志时。为了达到这个结果，软件通过三个主要步骤计算检测。第一步涉及基于颜色的方法，其中检测图像中的红色对象并提取它们的区域以进行分析。这一步对于防止检测到误报特别有用，因为只处理了图像的一小部分。第二步使用机器学习算法：特别是我们使用级联分类器来计算检测。该操作首先需要训练分类器，然后在稍后阶段使用它们来检测标志。在最后一步中，读取限速标志内的限速值，在这种情况下也是通过机器学习算法但使用 k-最近邻算法。现在我们将详细了解每个步骤。

基于颜色的步骤

由于路牌总是用红色框圈起来，我们可以只取出并分析检测到红色物体的区域。为了选择红色对象，我们考虑了红色的所有范围：即使这可能会产生一些误报，它们也很容易在接下来的步骤中被丢弃。

inRange(image, Scalar(0, 70, 50), Scalar(10, 255, 255), mask1);
inRange(image, Scalar(170, 70, 50), Scalar(180, 255, 255), mask2);

在下图中，我们可以看到使用此方法检测到的红色物体的示例。

找到红色像素后，我们可以收集它们以使用聚类算法找到区域，我使用该方法

partition(<#_ForwardIterator __first#>, _ForwardIterator __last, <#_Predicate __pred#>)

执行此方法后，我们可以将同一簇中的所有点保存在一个向量中（每个簇一个）并提取代表下一步要分析的区域。

用于标志检测的 HAAR 级联分类器

这是检测街道标志的真正检测步骤。为了执行级联分类器，第一步包括构建正负图像数据集。现在我解释一下我是如何构建自己的图像数据集的。首先要注意的是，我们需要训练三个不同的 Haar 级联，以便区分我们必须检测的三种标志，因此我们必须对三种标志中的每一种重复以下步骤。

我们需要两个数据集：一个用于正样本（必须是一组包含我们要检测的路标的图像），另一个用于负样本，可以是没有路标的任何类型的图像. 在两个不同的文件夹中收集了一组 100 张正样本图像和一组 200 张负样本图像后，我们需要编写两个文本文件：

Signs.info 包含如下文件名列表，一个用于正文件夹中的每个正样本。
```
pos/image_name.png 1 0 0 50 45
```
这里，名字后面的数字分别代表数字图像中的路牌，左上角的坐标路牌的一角，他的高度和宽度。
Bg.txt 包含一个文件名列表，如下所示，一个对于负文件夹中的每个符号。
```
neg/street15.png
```

使用下面的命令行，我们生成 .vect 文件，其中包含软件从阳性样本中检索到的所有信息。

opencv_createsamples -info sign.info -num 100 -w 50 -h 50 -vec signs.vec

之后我们使用以下命令训练级联分类器：

opencv_traincascade -data data -vec signs.vec -bg bg.txt -numPos 60 -numNeg 200 -numStages 15 -w 50 -h 50 -featureType LBP

其中阶段的数量表示为了构建级联将生成的分类器的数量。在这个过程结束时，我们会获得一个文件 cascade.xml，该文件将从 CascadeClassifier 程序中用于检测图像中的对象。现在我们已经训练了我们的算法，我们可以为每种街道标志声明一个 CascadeClassifier，然后我们通过检测图像中的标志

detectMultiScale(<#InputArray image#>, <#std::vector<Rect> &objects#>)

此方法在每个已检测到的对象周围创建一个 Rect。需要注意的是，正如每个机器学习算法一样，为了表现良好，我们需要数据集中的大量样本。我建立的数据集不是很大，因此在某些情况下它无法检测到所有迹象。这通常发生在图像中看不到一小部分街道标志时，如下面的警告标志：

我已经扩展了我的数据集，直到我获得了相当准确的结果，而无需错误太多。

限速值检测

就像这里的路牌检测一样，我使用了机器学习算法，但采用了不同的方法。经过一番工作，我意识到 OCR (tesseract) 解决方案性能不佳，因此我决定构建自己的 ocr 软件。

对于机器学习算法，我将下图作为训练数据，其中包含一些速度限制值：

训练数据量少。但是，由于在限速标志中所有字母都具有相同的字体，所以这不是一个大问题。为了准备训练数据，我在 OpenCV 中编写了一个小代码。它做了以下事情：

它加载左侧的图像；
它选择数字（显然是通过轮廓查找和对字母的面积和高度应用约束以避免错误检测）。
它围绕一个字母绘制边界矩形，并等待手动按下该键。这次是用户自己按了框中字母对应的数字键。
按下对应的数字键后，会将 100 个像素值保存在一个数组中，并将对应的手动输入的数字保存在另一个数组中。
最终它将两个数组保存在单独的 txt 文件中。

在手动数字分类之后，火车数据（train.png）中的所有数字都被手动标记，图像将如下图所示。

现在我们进入训练和测试部分。

对于训练，我们执行以下操作：

加载我们之前保存的 txt 文件
创建我们将要使用的分类器实例 (KNearest)
然后我们使用 KNearest.train 函数来训练数据

现在检测：

我们加载检测到限速标志的图像
像以前一样处理图像并使用轮廓方法提取每个数字
为其绘制边界框，然后将其大小调整为 10x10，并将其像素值存储在一个数组中，如前所述。
然后我们使用KNearest.find_nearest() 函数来查找与我们提供的最接近的项目。
它还能识别正确的数字。

我在许多图像上测试了这个小 OCR，仅使用这个小数据集我就获得了大约 90% 的准确度。

代码

下面我将我所有的 openCv c++ 代码发布在一个类中，按照我的指示，您应该能够获得我的结果。

#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <stdio.h>
#include <cmath>
#include <stdlib.h>
#include "opencv2/core/core.hpp"
#include "opencv2/highgui.hpp"
#include <string.h>
#include <opencv2/ml/ml.hpp>

using namespace std;
using namespace cv;

std::vector<cv::Rect> getRedObjects(cv::Mat image);
vector<Mat> detectAndDisplaySpeedLimit( Mat frame );
vector<Mat> detectAndDisplayNoParking( Mat frame );
vector<Mat> detectAndDisplayWarning( Mat frame );
void trainDigitClassifier();
string getDigits(Mat image);
vector<Mat> loadAllImage();
int getSpeedLimit(string speed);

//path of the haar cascade files
String no_parking_signs_cascade = "/Users/giuliopettenuzzo/Desktop/cascade_classifiers/no_parking_cascade.xml";
String speed_signs_cascade = "/Users/giuliopettenuzzo/Desktop/cascade_classifiers/speed_limit_cascade.xml";
String warning_signs_cascade = "/Users/giuliopettenuzzo/Desktop/cascade_classifiers/warning_cascade.xml";

CascadeClassifier speed_limit_cascade;
CascadeClassifier no_parking_cascade;
CascadeClassifier warning_cascade;

int main(int argc, char** argv)
{
    //train the classifier for digit recognition, this require a manually train, read the report for more details
    trainDigitClassifier();

    cv::Mat sceneImage;
    vector<Mat> allImages = loadAllImage();

    for(int i = 0;i<=allImages.size();i++){
        sceneImage = allImages[i];

        //load the haar cascade files
        if( !speed_limit_cascade.load( speed_signs_cascade ) ){ printf("--(!)Error loading\n"); return -1; };
        if( !no_parking_cascade.load( no_parking_signs_cascade ) ){ printf("--(!)Error loading\n"); return -1; };
        if( !warning_cascade.load( warning_signs_cascade ) ){ printf("--(!)Error loading\n"); return -1; };

        Mat scene = sceneImage.clone();

        //detect the red objects
        std::vector<cv::Rect> allObj = getRedObjects(scene);

        //use the three cascade classifier for each object detected by the getRedObjects() method
        for(int j = 0;j<allObj.size();j++){
            Mat img = sceneImage(Rect(allObj[j]));
            vector<Mat> warningVec = detectAndDisplayWarning(img);
            if(warningVec.size()>0){
                Rect box = allObj[j];
            }
            vector<Mat> noParkVec = detectAndDisplayNoParking(img);
            if(noParkVec.size()>0){
                Rect box = allObj[j];
            }
            vector<Mat> speedLitmitVec = detectAndDisplaySpeedLimit(img);
            if(speedLitmitVec.size()>0){
                Rect box = allObj[j];
                for(int i = 0; i<speedLitmitVec.size();i++){
                    //get speed limit and skatch it in the image
                    int digit = getSpeedLimit(getDigits(speedLitmitVec[i]));
                    if(digit > 0){
                        Point point = box.tl();
                        point.y = point.y + 30;
                        cv::putText(sceneImage,
                                    "SPEED LIMIT " + to_string(digit),
                                    point,
                                    cv::FONT_HERSHEY_COMPLEX_SMALL,
                                    0.7,
                                    cv::Scalar(0,255,0),
                                    1,
                                    cv::CV__CAP_PROP_LATEST);
                    }
                }
            }
        }
        imshow("currentobj",sceneImage);
        waitKey(0);
    }
}

/*
 *  detect the red object in the image given in the param,
 *  return a vector containing all the Rect of the red objects
 */
std::vector<cv::Rect> getRedObjects(cv::Mat image)
{
    Mat3b res = image.clone();
    std::vector<cv::Rect> result;

    cvtColor(image, image, COLOR_BGR2HSV);

    Mat1b mask1, mask2;
    //ranges of red color
    inRange(image, Scalar(0, 70, 50), Scalar(10, 255, 255), mask1);
    inRange(image, Scalar(170, 70, 50), Scalar(180, 255, 255), mask2);

    Mat1b mask = mask1 | mask2;
    Mat nonZeroCoordinates;
    vector<Point> pts;

    findNonZero(mask, pts);
    for (int i = 0; i < nonZeroCoordinates.total(); i++ ) {
        cout << "Zero#" << i << ": " << nonZeroCoordinates.at<Point>(i).x << ", " << nonZeroCoordinates.at<Point>(i).y << endl;
    }

    int th_distance = 2; // radius tolerance

     // Apply partition
     // All pixels within the radius tolerance distance will belong to the same class (same label)
    vector<int> labels;

     // With lambda function (require C++11)
    int th2 = th_distance * th_distance;
    int n_labels = partition(pts, labels, [th2](const Point& lhs, const Point& rhs) {
        return ((lhs.x - rhs.x)*(lhs.x - rhs.x) + (lhs.y - rhs.y)*(lhs.y - rhs.y)) < th2;
    });

     // You can save all points in the same class in a vector (one for each class), just like findContours
    vector<vector<Point>> contours(n_labels);
    for (int i = 0; i < pts.size(); ++i){
        contours[labels[i]].push_back(pts[i]);
    }

     // Get bounding boxes
    vector<Rect> boxes;
    for (int i = 0; i < contours.size(); ++i)
    {
        Rect box = boundingRect(contours[i]);
        if(contours[i].size()>500){//prima era 1000
            boxes.push_back(box);

            Rect enlarged_box = box + Size(100,100);
            enlarged_box -= Point(30,30);

            if(enlarged_box.x<0){
                enlarged_box.x = 0;
            }
            if(enlarged_box.y<0){
                enlarged_box.y = 0;
            }
            if(enlarged_box.height + enlarged_box.y > res.rows){
                enlarged_box.height = res.rows - enlarged_box.y;
            }
            if(enlarged_box.width + enlarged_box.x > res.cols){
                enlarged_box.width = res.cols - enlarged_box.x;
            }

            Mat img = res(Rect(enlarged_box));
            result.push_back(enlarged_box);
        }
     }
     Rect largest_box = *max_element(boxes.begin(), boxes.end(), [](const Rect& lhs, const Rect& rhs) {
         return lhs.area() < rhs.area();
     });

    //draw the rects in case you want to see them
     for(int j=0;j<=boxes.size();j++){
         if(boxes[j].area() > largest_box.area()/3){
             rectangle(res, boxes[j], Scalar(0, 0, 255));

             Rect enlarged_box = boxes[j] + Size(20,20);
             enlarged_box -= Point(10,10);

             rectangle(res, enlarged_box, Scalar(0, 255, 0));
         }
     }

     rectangle(res, largest_box, Scalar(0, 0, 255));

     Rect enlarged_box = largest_box + Size(20,20);
     enlarged_box -= Point(10,10);

     rectangle(res, enlarged_box, Scalar(0, 255, 0));

     return result;
}

/*
 *  code for detect the speed limit sign , it draws a circle around the speed limit signs
 */
vector<Mat> detectAndDisplaySpeedLimit( Mat frame )
{
    std::vector<Rect> signs;
    vector<Mat> result;
    Mat frame_gray;

    cvtColor( frame, frame_gray, CV_BGR2GRAY );
    //normalizes the brightness and increases the contrast of the image
    equalizeHist( frame_gray, frame_gray );

    //-- Detect signs
    speed_limit_cascade.detectMultiScale( frame_gray, signs, 1.1, 3, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );
    cout << speed_limit_cascade.getFeatureType();

    for( size_t i = 0; i < signs.size(); i++ )
    {
        Point center( signs[i].x + signs[i].width*0.5, signs[i].y + signs[i].height*0.5 );
        ellipse( frame, center, Size( signs[i].width*0.5, signs[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 255 ), 4, 8, 0 );


        Mat resultImage = frame(Rect(center.x - signs[i].width*0.5,center.y - signs[i].height*0.5,signs[i].width,signs[i].height));
        result.push_back(resultImage);
    }
    return result;
}

/*
 *  code for detect the warning sign , it draws a circle around the warning signs
 */
vector<Mat> detectAndDisplayWarning( Mat frame )
{
    std::vector<Rect> signs;
    vector<Mat> result;
    Mat frame_gray;

    cvtColor( frame, frame_gray, CV_BGR2GRAY );
    equalizeHist( frame_gray, frame_gray );

    //-- Detect signs
    warning_cascade.detectMultiScale( frame_gray, signs, 1.1, 3, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );
    cout << warning_cascade.getFeatureType();
    Rect previus;


    for( size_t i = 0; i < signs.size(); i++ )
    {
        Point center( signs[i].x + signs[i].width*0.5, signs[i].y + signs[i].height*0.5 );
        Rect newRect = Rect(center.x - signs[i].width*0.5,center.y - signs[i].height*0.5,signs[i].width,signs[i].height);
        if((previus & newRect).area()>0){
            previus = newRect;
        }else{
            ellipse( frame, center, Size( signs[i].width*0.5, signs[i].height*0.5), 0, 0, 360, Scalar( 0, 0, 255 ), 4, 8, 0 );
            Mat resultImage = frame(newRect);
            result.push_back(resultImage);
            previus = newRect;
        }
    }
    return result;
}

/*
 *  code for detect the no parking sign , it draws a circle around the no parking signs
 */
vector<Mat> detectAndDisplayNoParking( Mat frame )
{
    std::vector<Rect> signs;
    vector<Mat> result;
    Mat frame_gray;

    cvtColor( frame, frame_gray, CV_BGR2GRAY );
    equalizeHist( frame_gray, frame_gray );

    //-- Detect signs
    no_parking_cascade.detectMultiScale( frame_gray, signs, 1.1, 3, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );
    cout << no_parking_cascade.getFeatureType();
    Rect previus;

    for( size_t i = 0; i < signs.size(); i++ )
    {
        Point center( signs[i].x + signs[i].width*0.5, signs[i].y + signs[i].height*0.5 );
        Rect newRect = Rect(center.x - signs[i].width*0.5,center.y - signs[i].height*0.5,signs[i].width,signs[i].height);
        if((previus & newRect).area()>0){
            previus = newRect;
        }else{
            ellipse( frame, center, Size( signs[i].width*0.5, signs[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 0 ), 4, 8, 0 );
            Mat resultImage = frame(newRect);
            result.push_back(resultImage);
            previus = newRect;
        }
    }
    return result;
}

/*
 *  train the classifier for digit recognition, this could be done only one time, this method save the result in a file and
 *  it can be used in the next executions
 *  in order to train user must enter manually the corrisponding digit that the program shows, press space if the red box is just a point (false positive)
 */
void trainDigitClassifier(){
    Mat thr,gray,con;
    Mat src=imread("/Users/giuliopettenuzzo/Desktop/all_numbers.png",1);
    cvtColor(src,gray,CV_BGR2GRAY);
    threshold(gray,thr,125,255,THRESH_BINARY_INV); //Threshold to find contour
    imshow("ci",thr);
    waitKey(0);
    thr.copyTo(con);

    // Create sample and label data
    vector< vector <Point> > contours; // Vector for storing contour
    vector< Vec4i > hierarchy;
    Mat sample;
    Mat response_array;
    findContours( con, contours, hierarchy,CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); //Find contour

    for( int i = 0; i< contours.size(); i=hierarchy[i][0] ) // iterate through first hierarchy level contours
    {
        Rect r= boundingRect(contours[i]); //Find bounding rect for each contour
        rectangle(src,Point(r.x,r.y), Point(r.x+r.width,r.y+r.height), Scalar(0,0,255),2,8,0);
        Mat ROI = thr(r); //Crop the image
        Mat tmp1, tmp2;
        resize(ROI,tmp1, Size(10,10), 0,0,INTER_LINEAR ); //resize to 10X10
        tmp1.convertTo(tmp2,CV_32FC1); //convert to float

        imshow("src",src);

        int c=waitKey(0); // Read corresponding label for contour from keyoard
        c-=0x30;     // Convert ascii to intiger value
        response_array.push_back(c); // Store label to a mat
        rectangle(src,Point(r.x,r.y), Point(r.x+r.width,r.y+r.height), Scalar(0,255,0),2,8,0);
        sample.push_back(tmp2.reshape(1,1)); // Store  sample data
    }

    // Store the data to file
    Mat response,tmp;
    tmp=response_array.reshape(1,1); //make continuous
    tmp.convertTo(response,CV_32FC1); // Convert  to float

    FileStorage Data("TrainingData.yml",FileStorage::WRITE); // Store the sample data in a file
    Data << "data" << sample;
    Data.release();

    FileStorage Label("LabelData.yml",FileStorage::WRITE); // Store the label data in a file
    Label << "label" << response;
    Label.release();
    cout<<"Training and Label data created successfully....!! "<<endl;

    imshow("src",src);
    waitKey(0);


}

/*
 *  get digit from the image given in param, using the classifier trained before
 */
string getDigits(Mat image)
{
    Mat thr1,gray1,con1;
    Mat src1 = image.clone();
    cvtColor(src1,gray1,CV_BGR2GRAY);
    threshold(gray1,thr1,125,255,THRESH_BINARY_INV); // Threshold to create input
    thr1.copyTo(con1);


    // Read stored sample and label for training
    Mat sample1;
    Mat response1,tmp1;
    FileStorage Data1("TrainingData.yml",FileStorage::READ); // Read traing data to a Mat
    Data1["data"] >> sample1;
    Data1.release();

    FileStorage Label1("LabelData.yml",FileStorage::READ); // Read label data to a Mat
    Label1["label"] >> response1;
    Label1.release();


    Ptr<ml::KNearest>  knn(ml::KNearest::create());

    knn->train(sample1, ml::ROW_SAMPLE,response1); // Train with sample and responses
    cout<<"Training compleated.....!!"<<endl;

    vector< vector <Point> > contours1; // Vector for storing contour
    vector< Vec4i > hierarchy1;

    //Create input sample by contour finding and cropping
    findContours( con1, contours1, hierarchy1,CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
    Mat dst1(src1.rows,src1.cols,CV_8UC3,Scalar::all(0));
    string result;

    for( int i = 0; i< contours1.size(); i=hierarchy1[i][0] ) // iterate through each contour for first hierarchy level .
    {
        Rect r= boundingRect(contours1[i]);
        Mat ROI = thr1(r);
        Mat tmp1, tmp2;
        resize(ROI,tmp1, Size(10,10), 0,0,INTER_LINEAR );
        tmp1.convertTo(tmp2,CV_32FC1);
        Mat bestLabels;
        float p=knn -> findNearest(tmp2.reshape(1,1),4, bestLabels);
        char name[4];
        sprintf(name,"%d",(int)p);
        cout << "num = " << (int)p;
        result = result + to_string((int)p);

        putText( dst1,name,Point(r.x,r.y+r.height) ,0,1, Scalar(0, 255, 0), 2, 8 );
    }

    imwrite("dest.jpg",dst1);
    return  result ;
}
/*
 *  from the digits detected, it returns a speed limit if it is detected correctly, -1 otherwise
 */
int getSpeedLimit(string numbers){
    if ((numbers.find("30") != std::string::npos) || (numbers.find("03") != std::string::npos)) {
        return 30;
    }
    if ((numbers.find("50") != std::string::npos) || (numbers.find("05") != std::string::npos)) {
        return 50;
    }
    if ((numbers.find("80") != std::string::npos) || (numbers.find("08") != std::string::npos)) {
        return 80;
    }
    if ((numbers.find("70") != std::string::npos) || (numbers.find("07") != std::string::npos)) {
        return 70;
    }
    if ((numbers.find("90") != std::string::npos) || (numbers.find("09") != std::string::npos)) {
        return 90;
    }
    if ((numbers.find("100") != std::string::npos) || (numbers.find("001") != std::string::npos)) {
        return 100;
    }
    if ((numbers.find("130") != std::string::npos) || (numbers.find("031") != std::string::npos)) {
        return 130;
    }
    return -1;
}

/*
 *  load all the image in the file with the path hard coded below
 */
vector<Mat> loadAllImage(){
    vector<cv::String> fn;
    glob("/Users/giuliopettenuzzo/Desktop/T1/dataset/*.jpg", fn, false);

    vector<Mat> images;
    size_t count = fn.size(); //number of png files in images folder
    for (size_t i=0; i<count; i++)
        images.push_back(imread(fn[i]));
    return images;
}

【讨论】：

你能告诉我如何创建级联 xml 文件吗？
它在用于标志检测的 HAAR 级联分类器部分中进行了说明！有什么不清楚？
我已经看到了，但是我找不到 opencv_createsamples.exe 和 opencv_traincascade.exe。这个可执行文件是你创建的？
我已经成功地训练了我自己的级联模型，但是我在你的代码中看不到你加载模型后在哪里使用它。可以给我一些提示吗？