图像直线分析和拟合工具——opencv

 之前见过别人利用halcon封装了一个不错的函数叫drawRake好像是这个名字。这个工具挺好用的,可以在图像上随意画一条直线,然后设置一些参数,他就能在你画的这条线附近寻找你想要的直线, 然而其不是开源的,halcon也是收费的。于是我就心血来潮想自己做一个类似的工具,花了一天搞出来了,经过测试,效果还是杠杠的。下面介绍给大家,并会提供该工具函数的源码。

        图像处理过程中我们有时候要对摄像头采集的图像进行直线分析,如果利用opencv分析的话,我们常常要自己建个工程,然后利用一些检测直线的算法,比如霍夫变换等,然而这样比较耗时。这个工具就可以即时的对图像直线进行分析。接下来给出这个工具函数的原型。名字我也取为drawRake。如下:

  1.  
    std::vector<cv::Point2d> drawRake( cv::Mat &f,
  2.  
    cv::Point2d pStart,
  3.  
    cv::Point2d pEnd,
  4.  
    int gap,
  5.  
    int searchLength,
  6.  
    int threshValue,
  7.  
    bool isJudgeByGreatThan = false);


参数解析:

cv::Mat &f:图像数据,须为3通道或者单通道图像。

cv::Point2d pStart:指定直线的起点(这个是我们指定的,直线的起点和终点将被指定为搜索区域,我下面做的这个软件使用鼠标画线来指定直线)。

cv::Point2d pEnd:指定直线的终点。

int gap:搜索间隙(指定直线的细分步长)。

int searchLength:搜索长度,搜索范围。

int threshValue:搜索阈值。

bool isJudgeByGreatThan:目标点是否判决于大于阈值

返回值:std::vector<cv::Point2d>:一些列目标点集,用于直线拟合。

------------------------------------------------------------------------------------------

        可能不大好理解这几个参数的定义,先来看看下面几个直观的图像吧!如下图:是摄像头实时采集的一帧图像数据,然后我们现在要分析下图黑色箭头所示的直线。

        我们只需要在图像上的该直线附近画一条差不多直线,这条画上去的直线就是上面的输入参数的cv::Point2d pStart,cv::Point2d pEnd。效果如下图所示,因为是相机的实时帧,所以他会实时分析该直线,可以调节gap,searchLength,threshValue,isJudgeByGreatThan来分析最适合的直线。

         如上图,我们看到一堆的小箭头,那个就是点集的搜索方向。现在看到的那一堆箭头比较密集是由于gap值比较小的原因。如果我们把gap变大,就会看到这一群箭头变得稀疏了,如下图所示:

        我们看到箭头变稀疏了,因为gap增大了,我们还可以改变箭头的长度,他的意义就是输入参数searchLength,即搜索范围,他会从箭尾搜索到箭头,知道索引到符合的点,我们可以增大searchLength,就可以增加搜索范围,相应的箭头也会变长,如下图:

        我们再分析一下别的直线,也很容易的找到该直线如下所示:

        我们再来分析一下输入参数isJudgeByGreatThan,如果是FALSE的话就是从亮到暗(阈值是下限)搜索,如上图,如果设置成TRUE的话,就是从暗到亮搜索(阈值是上限),比如我们来分析一下纸箱盖子的直线,如下图。

        好了,差不多直观的了解完了,接下来就是上代码。

------------------------------------------------------------------------------------------

下面是drawRake函数源码:

std::vector<cv::Point2d> drawRake(cv::Mat &f, cv::Point2d pStart, cv::Point2d pEnd, int gap, int searchLength, int threshValue, bool isJudgeByGreatThan){
 
        // 初始化内存
        std::vector<cv::Point2d> pVec; pVec.clear();    // rake点集
        double k = 0., b = 0., xConst = 0.;                // 直线方程参数
        int lineLength = 0;                                // 直线长度
        double lineAngle = 0.;                            // 直线角度
        double opposite = 1.0;                            // 直线的方向是否相反 是:为-1.0,否:1.0
        int imageChs = f.channels();                    // 图像通道数,支持3通道和单通道图像
        cv::Mat singleChImage;                            // 单通道图像
 
        // 有效性判断
        if (f.empty()) return pVec;
        if (pStart == pEnd) return pVec;
 
        // 获取单通道图像
        if (imageChs == 1){
            //f.copyTo(singleChImage);
            singleChImage = f;
        }else if (imageChs == 3){
            cv::cvtColor(f, singleChImage, CV_BGR2GRAY);// 默认的单通道是灰度空间
        }
 
        // 获取直线方向性
        if (pEnd.x < pStart.x) opposite = -1.0;
 
        // 获取直线方程 y = k * x + b, y = b, x = const value.
        if ((pEnd.x - pStart.x) == 0.){
 
            xConst = pStart.x; // x = const value.
            lineAngle = 90.;
            if (pEnd.y < pStart.y) opposite = -1.0;        // 只有这种情况直线方向性考虑Y
        }else{
 
            k = (pEnd.y - pStart.y) / (pEnd.x - pStart.x);
            b = pStart.y - k * pStart.x;
            lineAngle = atan(k) * 180. / CV_PI;
        }
        lineLength = sqrt(pow((pEnd.x - pStart.x), 2.) + pow((pEnd.y - pStart.y), 2.));
 
        // 细分直线,细分步长位gap,获取每一个细分点的坐标
        std::vector<cv::Point2d> gapPVec; gapPVec.clear();
        double Xgap, Ygap;
        for (int g = 0; g <= lineLength; g += gap){
 
            Xgap = pStart.x + (opposite * g * cos(lineAngle * CV_PI / 180.));
            Ygap = (pEnd.x == pStart.x) ? (pStart.y + opposite * g) : (k * Xgap + b);
            gapPVec.push_back(cv::Point2d(Xgap, Ygap));
        }
 
        // 找每个细分点的直线段,直线段长度就是搜索长度范围,由searchLength指定,这边计算出来的lineAngle属于(-90 ~ 90度)
        double halfSearchLength = searchLength / 2.;
        double xLower, xUpper, yLower, yUpper;            // 细分点的直线段在X-Y轴投影的横坐标上限和下限
        double Knew = 0., Bnew = 0., XnewConst = 0.;    // 细分点的直线段的k和b    和x = const直线
        bool newLineIsVecticalLine = false;                // 默认是一般直线,非竖线
        std::vector<cv::Point> lineArrowVec[2];            // 存取用于画结果的直线标
        if (k == 0.){
            newLineIsVecticalLine = true;
        }else{
            if ((pEnd.x == pStart.x)) Knew = 0.;
            else Knew = -1. / k;
        }
        for (int i = 0; i < gapPVec.size(); i++){
 
            if (abs(lineAngle) < 45.){                    // 小于45度的情况
                
                if (newLineIsVecticalLine){ // x = const
 
                    XnewConst = gapPVec[i].x;
                    yLower = gapPVec[i].y - halfSearchLength;
                    yUpper = gapPVec[i].y + halfSearchLength;
                }
                else{                        // b = y - k * x
 
                    Bnew = gapPVec[i].y - Knew * gapPVec[i].x;
                    yLower = gapPVec[i].y - halfSearchLength * cos(abs(lineAngle * CV_PI / 180.));
                    yUpper = gapPVec[i].y + halfSearchLength * cos(abs(lineAngle * CV_PI / 180.));
                }
                // 上边到下边的直线递增查询,下边到上边的直线递减查询
                for (int yy = yLower; yy <= yUpper; yy++){
 
                    int xCur = 0, yCur = 0;
                    if (pStart.x > pEnd.x) yCur = yUpper - yy + yLower;
                    else yCur = yy;
                    xCur = (newLineIsVecticalLine) ? (XnewConst) : (yCur - Bnew) / Knew;
 
                     if (xCur > singleChImage.cols || xCur < 0 || yCur > singleChImage.rows || yCur < 0) continue;
 
                    unsigned char *pdata = singleChImage.ptr<unsigned char>(yCur);
                    if (isJudgeByGreatThan){
 
                        if (pdata[xCur] > threshValue){
 
                            pVec.push_back(cv::Point(xCur, yCur));
                            break;
                        }
                    }
                    else{
 
                        if (pdata[xCur] < threshValue){
 
                            pVec.push_back(cv::Point(xCur, yCur));
                            break;
                        }
                    }
                }
 
                double F_yLower, F_yUpper;
                if (newLineIsVecticalLine){
                    F_yLower = XnewConst;
                    F_yUpper = XnewConst;
                }else{
                    F_yLower = (yLower - Bnew) / Knew;
                    F_yUpper = (yUpper - Bnew) / Knew;
                }
                if (pStart.x < pEnd.x){
                    lineArrowVec[0].push_back(cv::Point(F_yLower, yLower));
                    lineArrowVec[1].push_back(cv::Point(F_yUpper, yUpper));
                }
                else{
                    lineArrowVec[1].push_back(cv::Point(F_yLower, yLower));
                    lineArrowVec[0].push_back(cv::Point(F_yUpper, yUpper));
                }
 
            }else{                        // 大于45度的情况
 
                Bnew = gapPVec[i].y - Knew * gapPVec[i].x;
                xLower = gapPVec[i].x - halfSearchLength * sin(abs(lineAngle * CV_PI / 180.));
                xUpper = gapPVec[i].x + halfSearchLength * sin(abs(lineAngle * CV_PI / 180.));
 
                // 左边到右边的直线递增查询,右边到左边的直线递减查询
                for (int xx = xLower; xx <= xUpper; xx++){
 
                    int xCur = 0, yCur = 0;
                    if (pStart.y > pEnd.y) xCur = xUpper - xx + xLower;
                    else xCur = xx;
                    yCur = Knew * xCur + Bnew;
 
                    if (xCur > singleChImage.cols || xCur < 0 || yCur > singleChImage.rows || yCur < 0) continue;
 
                    unsigned char *pdata = singleChImage.ptr<unsigned char>(yCur);
                    if (isJudgeByGreatThan){
 
                        if (pdata[xCur] > threshValue){
 
                            pVec.push_back(cv::Point(xCur, yCur));
                            break;
                        }
                    }else{
 
                        if (pdata[xCur] < threshValue){
 
                            pVec.push_back(cv::Point(xCur, yCur));
                            break;
                        }
                    }
                }
                double F_xLower = Knew * xLower + Bnew;
                double F_xUpper = Knew * xUpper + Bnew;
                if (pStart.y > pEnd.y){
 
                    lineArrowVec[0].push_back(cv::Point(xUpper, F_xUpper));
                    lineArrowVec[1].push_back(cv::Point(xLower, F_xLower));
                }else{
                    lineArrowVec[1].push_back(cv::Point(xUpper, F_xUpper));
                    lineArrowVec[0].push_back(cv::Point(xLower, F_xLower));
                }
            }
        }// end 'for (int i = 0; i < gapPVec.size(); i++)'
        
        // 画rake点,和搜索方向
        for (int i = 0; i < pVec.size(); i++){
 
            if (imageChs == 1){
 
                cv::circle(f, pVec[i], 3, cv::Scalar(std::rand() % 255), 3);
                drawArrow(f, lineArrowVec[0][i], lineArrowVec[1][i], 25, 30, cv::Scalar(std::rand() % 255), 1);
            }
            if (imageChs == 3){
 
                cv::circle(f, pVec[i], 3, cv::Scalar(std::rand() % 255, std::rand() % 255, std::rand() % 255), 3);
                drawArrow(f, lineArrowVec[0][i], lineArrowVec[1][i], 25, 30, cv::Scalar(std::rand() % 255, std::rand() % 255, std::rand() % 255), 1);
            }
        }
        // 画所有的细分点的搜索方向
        for (int i = 0; i < gapPVec.size(); i++){
 
            if (imageChs == 1){
 
                drawArrow(f, lineArrowVec[0][i], lineArrowVec[1][i], 25, 30, cv::Scalar(std::rand() % 255), 1);
            }
            if (imageChs == 3){
 
                drawArrow(f, lineArrowVec[0][i], lineArrowVec[1][i], 25, 30, cv::Scalar(std::rand() % 255, std::rand() % 255, std::rand() % 255), 1);
            }
        }
 
        return pVec;
}

其中有一个drawArrow函数是用来画箭头的,摘自这里,源码如下:

void drawArrow(cv::Mat& img, cv::Point pStart, cv::Point pEnd, int len, int alpha,cv::Scalar& color, int thickness, int lineType){
 
        cv::Point arrow;
        // 计算 θ 角(最简单的一种情况在下面图示中已经展示,关键在于 atan2 函数,详情见下面)   
        double angle = atan2((double)(pStart.y - pEnd.y), (double)(pStart.x - pEnd.x));
        cv::line(img, pStart, pEnd, color, thickness, lineType);
        // 计算箭角边的另一端的端点位置(上面的还是下面的要看箭头的指向,也就是pStart和pEnd的位置) 
        arrow.x = pEnd.x + len * cos(angle + CV_PI * alpha / 180.);
        arrow.y = pEnd.y + len * sin(angle + CV_PI * alpha / 180.);
        cv::line(img, pEnd, arrow, color, thickness, lineType);
        arrow.x = pEnd.x + len * cos(angle - CV_PI * alpha / 180.);
        arrow.y = pEnd.y + len * sin(angle - CV_PI * alpha / 180.);
        cv::line(img, pEnd, arrow, color, thickness, lineType);
}

本文转自:https://blog.csdn.net/KayChanGEEK/article/details/77247884?utm_source=app

原文地址:https://www.cnblogs.com/eve612/p/14090256.html