我有一张带有许多凹槽的表面的图片。在大多数情况下，凹槽的边缘形成平行线，因此 Canny 和 Hough 变换非常适合检测线并进行一些表征。然而，在几个地方，凹槽被损坏并且边缘不再平行。

我正在寻找一种简单的方法来检查某条边是否为直线，或者是否存在任何间隙或与直线的偏差。我在想线性插值中的 R 平方参数之类的东西，但在这里我需要一个更依赖于位置的参数。您对如何表征边缘有任何其他想法吗？

我附上了 Canny 边缘检测后的凹槽图片。在这里，边缘是直线，凹槽很好。不幸的是，我目前无法访问凹槽损坏的图片。但是，在凹槽损坏的图片中，线条会有很大的间隙(至少是图片尺寸的 10%)或者不平行。

最佳答案

技术的核心 我在下面分享的是使用 cv::HoughLinesP() 在灰度图像中查找线段。

应用程序首先将输入图像加载为灰度图像。然后它执行基本的预处理操作以增强图像的某些特征，旨在改进 cv::HoughLinesP() 执行的检测。 :

#include <cv.h>
#include <highgui.h>

#include <algorithm>

// Custom sort method adapted from: http://stackoverflow.com/a/328959/176769
// This is used later by std::sort()
struct sort_by_y_coord 
{
    bool operator ()(cv::Vec4i const& a, cv::Vec4i const& b) const 
    {
        if (a[1] < b[1]) return true;

        if (a[1] > b[1]) return false;

        return false;
    }
};


int main()
{
    /* Load input image as grayscale */

    cv::Mat src = cv::imread("13531682.jpg", 0);

    /* Pre-process the image to enhance the characteristics we are interested at */

    medianBlur(src, src, 5);

    int erosion_size = 2;
    cv::Mat element = cv::getStructuringElement(cv::MORPH_CROSS,
                                       cv::Size(2 * erosion_size + 1, 2 * erosion_size + 1),
                                       cv::Point(erosion_size, erosion_size) );
    cv::erode(src, src, element);
    cv::dilate(src, src, element);

    /* Identify all the lines in the image */

    cv::Size size = src.size();
    std::vector<cv::Vec4i> total_lines;
    cv::HoughLinesP(src, total_lines, 1, CV_PI/180, 100, size.width / 2.f, 20);

    int n_lines = total_lines.size();
    std::cout << "* Total lines: "<< n_lines << std::endl;

    cv::Mat disp_lines(size, CV_8UC1, cv::Scalar(0, 0, 0));

    // For debugging purposes, the block below writes all the lines into disp_lines
    // for (unsigned i = 0; i < n_lines; ++i)
    // {
    //     cv::line(disp_lines, 
    //              cv::Point(total_lines[i][0], total_lines[i][2]),
    //              cv::Point(total_lines[i][3], total_lines[i][4]), 
    //              cv::Scalar(255, 0 ,0));
    // }
    // cv::imwrite("total_lines.png", disp_lines);

此时，可以将检测到的所有线段写入一个文件以进行可视化:

此时我们需要对线 vector 进行排序，因为 cv::HoughLinesP()不这样做，我们需要排序的 vector 能够通过测量和比较线之间的距离来识别线组:

    /* Sort lines according to their Y coordinate. 
       The line closest to Y == 0 is at the first position of the vector.
    */

    sort(total_lines.begin(), total_lines.end(), sort_by_y_coord());

    /* Separate them according to their (visible) groups */ 

    // Figure out the number of groups by distance between lines
    std::vector<int> idx_of_groups;   // stores the index position where a new group starts
    idx_of_groups.push_back(0); // the first line indicates the start of the first group 

    // The loop jumps over the first line, since it was already added as a group
    int y_dist = 35; // the next groups are identified by a minimum of 35 pixels of distance  
    for (unsigned i = 1; i < n_lines; i++)  
    {
        if ((total_lines[i][5] - total_lines[i-1][6]) >= y_dist) 
        {
            // current index marks the position of a new group
            idx_of_groups.push_back(i); 
            std::cout << "* New group located at line #"<< i << std::endl;           
        }
    }

    int n_groups = idx_of_groups.size();
    std::cout << "* Total groups identified: "<< n_groups << std::endl;

上面代码的最后一部分只是将线 vector 的索引位置存储在一个新的 vector<int> 中。所以我们知道哪些行开始一个新组。

例如，假设存储在新 vector 中的索引是:0 4 8 12 .请记住:它们定义了每个组的开始。这意味着组的结尾行是:0, 4-1, 4, 8-1, 8, 12-1, 12 .

知道这一点，我们编写以下代码:

    /* Mark the beginning and end of each group */

    for (unsigned i = 0; i < n_groups; i++)  
    {
        // To do this, we discard the X coordinates of the 2 points from the line, 
        // so we can draw a line from X=0 to X=size.width

        // beginning
        cv::line(disp_lines, 
                 cv::Point(0, total_lines[ idx_of_groups[i] ][7]),
                 cv::Point(size.width, total_lines[ idx_of_groups[i] ][8]), 
                 cv::Scalar(255, 0 ,0));

        // end      
        if (i != n_groups-1)
        {
            cv::line(disp_lines, 
                     cv::Point(0, total_lines[ idx_of_groups[i+1]-1 ][9]),
                     cv::Point(size.width, total_lines[ idx_of_groups[i+1]-1 ][10]), 
                     cv::Scalar(255, 0 ,0));
        }
    }
    // mark the end position of the last group (not done by the loop above)    
    cv::line(disp_lines, 
             cv::Point(0, total_lines[n_lines-1][11]),
             cv::Point(size.width, total_lines[n_lines-1][12]), 
             cv::Scalar(255, 0 ,0));

    /* Save the output image and display it on the screen */

    cv::imwrite("groups.png", disp_lines);

    cv::imshow("groove", disp_lines);
    cv::waitKey(0);
    cv::destroyWindow("groove");

    return 0;
}

生成的图像是:

这不是完美匹配，但很接近。通过在这里和那里进行一些调整，这种方法可以变得更好。我将从为 sort_by_y_coord 编写更智能的逻辑开始，它应该丢弃 X 坐标之间距离较小的线(即小线段)，以及在 X 轴上未完全对齐的线(如输出图像中第二组的线)。在您花时间评估应用程序生成的第一张图像后，这个建议就更有意义了。

祝你好运。

关于c++ - OpenCV 切槽检测，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13531682/