2. 程式人生 > >形狀識別之直線檢測

形狀識別之直線檢測

阿新 • • 發佈：2019-01-01

形狀識別中常見的即是矩形框的識別，識別的主要步驟通常是：影象二值化，查詢輪廓，四邊形輪廓篩選等。當識別的目標矩形有一條邊被部分遮擋，如圖1所示，傳統的識別方法就不能達到識別的目的。

圖1
圖1

在這裡，提供一種識別的思路,僅供參考。識別的最終目標就是想識別出身份證的四條邊，通過計算四條邊的交點最後得到四邊形的輪廓。主要涉及的問題有如下幾點：

  1. 直線檢測
  2. 直線聚類
  3. 直線篩選
  4. 交點計算
  5. 交點排序

1.直線檢測

常規直線檢測方法即是Hough。這裡推薦使用一種比較新的直線檢測演算法LSD。

演算法的具體使用請參考網站提供的原始碼。

圖2和圖3分別是Hough直線檢測與LSD直線檢測的結果示意圖。

對於LSD演算法得到的結果，可以根據直線的長度進行初步的篩選，得到更好的檢測結果，提高後期處理效率。如圖4所示。

Hough
圖2

LSD
圖3

lsd2
圖4

2.直線聚類

由圖4可以看出，身份證的每條邊緣被分割成幾段短線段，這裡給出將每條邊上的短線段聚為一類的方法。
在極座標系下的一點(ρ,θ)即定義一條直線，其中ρ表示極座標原點到直線的距離，θ為如圖所示夾角。如圖5。

5
圖5

此時不難看出，身份證同一邊上的線段應該具有相近的極座標點。

具體做法是，先選取極座標系的原點O為影象的重點（w/2,h/2）。建立笛卡爾座標系x=u−w/2,y=h/2−v;其中(u,v)是影象座標系。極座標系(

ρ,θ)與笛卡爾座標系(x,y)的轉換關係為ρ=xcos(θ)+ysin(θ)。因此，當已知一線段的兩個端點(u1,v1),(u2,v2),即可求解出對應的(ρ,θ)。具體角度的計算請參考直線檢測之極座標表示。

程式碼如下：

//p[0] u1 p[1] v1
//p[2] u2 p[3] v2
Vec2d getPolarLine(Vec4d p )
{
    if(fabs(p[0]-p[2]) < 1e-5 )//垂直直線
    {
        if(p[0] > 0)
            return Vec2d(p[0],0);
        else
            return
 
 Vec2d(p[0],CV_PI);
    }

    if(fabs(p[1]-p[3]) < 1e-5 ) //水平直線
    {
        if(p[1] > 0)
            return Vec2d(p[1],CV_PI/2);
        else
            return Vec2d(p[1],3*CV_PI/2);
    }

    float k = (p[1]-p[3])/(p[0]-p[2]);
    float y_intercept =  p[1] - k*p[0];

    float theta;

    if( k < 0 && y_intercept > 0)
        theta =  atan(-1/k);
    else if( k > 0 && y_intercept > 0)
        theta = CV_PI + atan(-1/k);
    else if( k< 0 && y_intercept < 0)
        theta = CV_PI + atan(-1/k);
    else if( k> 0 && y_intercept < 0)
        theta = 2*CV_PI +atan(-1/k);

    float _cos = cos(theta);
    float _sin = sin(theta);

    float r = p[0]*_cos + p[1]*_sin;

    return Vec2d(r,theta);
}

將圖4中檢測到的所有直線線段利用極座標表示，然後進行分類，同類的直線分配相同的標籤號。然後對相同標籤號的線段對應的極座標進行加權平均，即為對應直線。
演算法如下：

// vector<Vec2d> polarLines 是檢測出的所有線段對應的極座標表示

bool getIndexWithPolarLine(vector<int>& _index)
{

    int polar_num = polarLines.size();

    if(polar_num == 0)
    {
        return false;
    }

    _index.clear();
    _index.resize(polar_num);

    //初始化標籤號
    for (int i=0; i < polar_num;i++)
        _index[i] = i;


    for (int i=0; i < polar_num-1 ;i++)
    {

        float minTheta = CV_PI;
        float minR = 50;
        Vec2d polar1 = polarLines[i];

        for (int j = i+1; j < polar_num; j++)
        {

            Vec2d polar2 = polarLines[j];

            float dTheta = fabs(polar2[1] - polar1[1]);
            float dR = fabs(polar2[0] - polar1[0]);

            if(dTheta < minTheta )
                minTheta = dTheta;

            if(dR < minR)
                minR = dR;
            //同類直線角度誤差不超過1.8°，距離誤差不超過8%
            if(dTheta < 1.8*CV_PI/180 && dR < polar1[0]*0.08)
                _index[j] = _index[i];
        }
    }

    return true;
}

由於身份證邊緣長度是大於一定閾值的，此時，如果同類線段的長度和小於某閾值，則可以剔除掉該線段。
如圖6紅色線段為LSD檢測結果，紅色直線為線段對應極座標表示的直線。
圖6
圖6

3.直線篩選

由圖6可以看出，圖中不僅有身份證邊緣的直線，同樣存在其他干擾直線，並且背景環境越複雜，干擾的直線會越多。此時就需要對直線進行篩選。這裡進行篩選的思路是，採集圖6中所示紅色線段兩側的影象資料，計算顏色特徵H,S,V。針對圖6，手上的顏色特徵明顯區別於身份證邊緣的特徵，很容易去除。資料獲取如圖7所示,圖中紅色和藍色區域即是對應線段的採集樣本區域。

sample
圖7

具體程式碼如下，輸入是一條線段，輸出是布林型別，表示該線段是否符合要求。

// 直線兩側取樣，計算特徵:亮度與對比度，色彩等
// Vec6d  data: 
// data[0] u1, data[1] v1  first line point
// data[2] u2, data[3] v2  second line point
// data[4] line width
// data[5] line length
// ksize  取樣引數
bool lineSidesFeature(Mat _input，Vec6d data，int ksize )
{
    //_input 輸入的影象資料，為彩色圖
    Mat gray;
    if(_input.channels() == 3)
        cvtColor(_input,gray,CV_BGR2GRAY);
    else
        _input.copyTo(gray);


//  Mat drawIm = _input.clone();

    float x1 = data[0];
    float y1 = data[1];
    float x2 = data[2];
    float y2 = data[3];

//  line(_drawIm,Point2f(x1,y1),Point2f(x2,y2),Scalar(0,255,0));
//  imshow("Sample line",drawIm);
//  waitKey(10);

    //直線左右兩側的灰度值
    vector<int> left_side;
    vector<int> right_side;

    //灰度值和
    int left_sum = 0;
    int right_sum = 0;

    //色調與飽和度
    int left_H = 0;
    float left_S = 0.0;
    int right_H = 0;
    float right_S = 0.0;

    //彩色畫素個數
    int color_pix_num = 0;
    //取樣總數
    int sample_num = 0;

    //垂直直線？
    int vertical = 0;
    //直線斜率 截距
    float _k = 0;
    float _b = 0;

    //計算直線表示式
    if(fabs(x1-x2) < 1e-2) // x = b;
    {
        vertical = 1;
        _b = x1;
    }
    else
    {
        _k = (y1-y2)/(x1-x2); //直線方程 kx + b = y;
        _b= y1 - _k*x1;
    }

//  cout<<"vertical = "<<vertical<<endl;

    // fabs(_k) > 1,取樣的直線是水平的，對應圖7中紅色區域
    // fabs(_k) < 1, 取樣的直線是垂直的，對應圖7中藍色區域

    int sample_line_type = fabs(_k) > 1 ? 1 : 0;

//  cout<<"sample_line_type = "<< sample_line_type<<endl;

    //設定取樣點的起點，取線段端點，並且是x值最小或者y值最小，依據sample_line_type 的值，
    //這樣迴圈取下一個點時可以不斷遞增+1

    float u1,u2;
    int step = 1; // 這裡step = 1，如果step = -1;那麼起點又得是最大值。
    if(vertical == 1)
    {
        if(y1 < y2)
        {
            u1 = y1;
            u2 = y2;
        }
        else
        {
            u1 = y2;
            u2 = y1;
        }
    }
    else
    {
        if(sample_line_type == 1)
        {
            if(y1 < y2)
            {
                u1 = y1;
                u2 = y2;
            }
            else
            {
                u1 = y2;
                u2 = y1;
            }
        }
        else
        {
            if(x1 < x2)
            {
                u1 = x1;
                u2 = x2;
            }
            else
            {
                u1 = x2;
                u2 = x1;
            }
        }
    }

//  cout <<"step = "<<step <<endl;

    // 從直線的一個端點開始進行取樣，該端點要麼離影象座標u最近，要麼離影象座標v最近，步長為step
    // 得到取樣點後，計算過該點垂直於直線的法線，法線上的點作為樣本點。
    // 在法線上採集的樣本點個數為 2*ksize+ 1, 步進的方向依據直線的斜率決定是沿x方向還是y方向，步長為1。
    for (float u = u1; u<= u2; u += step)
    {
        float v0 ;

        float v1,v2;

        //取樣直線的斜率與截距
        float sk,sb;
        if(vertical == 1)
        {
            v0 = x1;
        }
        else
        {
            if(sample_line_type == 1)
            {
                v0 = (u - _b)/_k;
                sk = -1/(1e-6 +_k);
                sb = u - sk*v0;
            }
            else
            {
                v0 = _k*u + _b;
                sk = -1/(1e-6 +_k);

                sb = v0 - sk*u;
            }
        }

        v1 = v0 - ksize;
        v2 = v0 + ksize;

//      cout<<"v1 = "<<v1<<", v2 = "<<v2<<endl;
        if(vertical == 1)
        {
            line(_drawIm,Point2f(v1,u),Point2f(v2,u),Scalar(0,0,255));
        }
        else
        {
            if(sample_line_type == 1)
            {
                line(_drawIm,Point2f(v1,sk*v1 + sb),Point2f(v2,sk*v2 + sb),Scalar(0,0,255));
            }
            else
                line(_drawIm,Point2f((v1-sb)/sk,v1),Point2f((v2-sb)/sk,v2),Scalar(255,0,0));
        }

        // sample_line_type = 1 ,點P0(v0,u)在直線上，垂直於該直線並過點P0，進行取樣，按x方向步長為1進行步進，起點x = v1，終點x =v2;
        // sample_line_tpye = 0, 點P0(u,v0)在直線上，垂直於該直線並過點P0，進行取樣，按y方向步長為1進行步進, 起點y = v1, 終點y = v2。

        for (float v = v1; v <= v2; v += 1)
        {
            sample_num++;

            int x , y;
            if(vertical == 1) //垂直線段
            {
                x = (int)v;
                y = (int)u;
            }
            else
            {
                if(sample_line_type == 1) //“水平”取樣,v按照x方向遞增
                {
                    x = (int)v;
                    y = (int)(sk*v + sb);
                }
                else //“垂直”取樣， v按照y方向遞增
                {
                    x = (int)((v-sb)/sk);
                    y = (int)v;
                }
            }
            //這一句很重要。
            if(x < 0 || x > gray.cols-1 || y < 0 || y > gray.rows-1)
                continue;

            int nx = MAX(0,x);
            nx = min(nx,gray.cols-1);

            int ny = MAX(0,y);
            ny = min(ny,gray.rows-1);

            int val = gray.at<uchar>(ny,nx);
            Vec3b pixel = _input.at<Vec3b>(ny,nx);

            int b = pixel[0];
            int g = pixel[1];
            int r = pixel[2];

            int _max = MAX(b,MAX(g,r));
            int _min = MIN(b,MIN(g,r));


            int C = _max - _min ;
            float S = 0;
            int H = 0;
            if(C > 10)
            {
                S = (float)C/_max;
                int vr = _max == r ? -1 : 0;
                int vg = _max == g ? -1 : 0;

                H = (vr & (g - b)) +
                    (~vr & ((vg & (b - r + 2 * C)) + ((~vg) & (r - g + 4 * C))));
                H = (H * hdiv_table180[C] + (1 << (hsv_shift-1))) >> hsv_shift;
                H += H < 0 ? 180 : 0;

                //色度判斷直線兩邊相似的顏色
                if( S > 0.1 && H > 10 )
                    color_pix_num++;
            }

            if(vertical == 1)
            {
                if(nx > _b)
                {
                    right_side.push_back(val);
                    right_sum += val;

                    right_H += H;
                    right_S += S;
                }
                else
                {
                    left_side.push_back(val);
                    left_sum += val;

                    left_H += H;
                    left_S += S;
                }
            }
            else
            {
                float d = _k*nx + _b - ny;

                if(d > 0 )
                {
                    right_side.push_back(val);
                    right_sum += val;

                    right_H += H;
                    right_S += S;
                }
                else
                {
                    left_side.push_back(val);
                    left_sum += val;

                    left_H += H;
                    left_S += S;
                }
            }

        } //v

    }//u

    int l_num = left_side.size();
    int r_num = right_side.size();
//  cout << l_num <<" "<< r_num << endl;

    float left_mean = (float) (left_sum)/l_num;
    float right_mean = (float) (right_sum)/ r_num;

    float left_H_mean = (float)(left_H)/l_num;
    float left_S_mean = (float)(left_S)/l_num;

    float right_H_mean = (float)(right_H)/r_num;
    float right_S_mean = (float)(right_S)/r_num;


    float left_var = 0, right_var = 0;
    for (int m = 0; m < l_num; m++)
    {
        left_var += (left_side[m] - left_mean)*(left_side[m] - left_mean);
    }
    if(l_num > 2)
        left_var = sqrtf(left_var)/(l_num-1);

    for (int n = 0; n < r_num; n++)
    {
        right_var += (right_side[n] - right_mean)*(right_side[n] - right_mean);
    }
    if(r_num > 2)
        right_var = sqrtf(right_var)/(r_num-1);


    cout<<"亮度： "<<left_mean <<" "<<right_mean<<endl;
    cout<<"飽和度："<<left_S_mean<<" "<<right_S_mean<<" "<<fabs(left_S_mean - right_S_mean)/(1e-5+MAX(left_S_mean,right_S_mean))<<endl; // 篩選直線兩側顏色差異 參考值0.4
    cout<<left_H_mean <<" "<<right_H_mean<<" "<<fabs(left_H_mean - right_H_mean)/(1e-5+MAX(left_H_mean,right_H_mean))<<endl; // 篩選直線兩側顏色差異 參考值 0.15 
    cout<<"方差/均值："<<left_var/left_mean<<" "<<right_var/right_mean<<endl; //篩選平滑區域

//  imshow("Sample line",drawIm);
//  waitKey(0);

    return false;
}

由於待測身份證的邊緣鄰域顏色特徵是穩定的，可以作為初始經驗值，當識別線段的顏色特徵不符合經驗值要求即可剔除掉，最後得到想要的邊緣線段以及對應的極座標表示直線。然而，有時候可能得到滿足條件的直線比較多，此時可以考慮為每一類直線進行評分，然後根據得分排序，取出前4條得分最高的直線，大部分情況下都是所求邊緣直線。具體情況可具體對待，此處不再展開。

4.交點計算

這裡給出極座標系下直線的求交點方法，這裡主要注意兩點：首先，兩條直線不是平行的，其次，直線的交點在影象範圍內。

Point2f polarLinesCorss(Vec2d l0, Vec2d l1，Size sz)
{

    int w = sz.width;
    int h = sz.height;

    float r0 = l0[0];
    float theta0 = l0[1];

    float _cos0 = cos(theta0);
    float _sin0 = sin(theta0);

    float r1 = l1[0];
    float theta1 = l1[1];

    float _cos1 = cos(theta1);
    float _sin1 = sin(theta1);

    if(fabs(_cos0*_sin1 - _sin0*_cos1) < 1e-5) //兩條平行的直線
        return Point2f(0,0);

    float y = (r0*_cos1 - r1*_cos0) / (_sin0*_cos1 - _cos0*_sin1);
    float x = (r0*_sin1 - r1*_sin0) / (_cos0*_sin1 - _cos1*_sin0);

    if(x > - w/2 && x < w/2 && y > -h/2 && y < h/2)
        return Point2f(x+w/2,h/2-y);
    else
        return Point2f(0,0);
}

5.交點排序

得到四個交點，此時點的順序可能是錯亂的，需要對點進行排序，起點選擇為左上角的點，並按逆時針方向對點排序。方法如下：

// 以左上角點為起點逆時針排序
static void sortPoints(vector<Point2f> & points )
{
    vector<Point2f> minXpoints;
    vector<Point2f> maxXpoints;

    minXpoints.push_back(points[0]);
    minXpoints.push_back(points[1]);

    maxXpoints.push_back(points[2]);
    maxXpoints.push_back(points[3]);

    for(int i =0; i< 2; i++)
    {
        float x = minXpoints[i].x;
        if(x > maxXpoints[0].x)
        {
            if(x >= maxXpoints[1].x)
            {
                (maxXpoints[0].x > maxXpoints[1].x ) ? swap(maxXpoints[1],minXpoints[i]) : swap(maxXpoints[0],minXpoints[i]);
                continue;
            }

            if(x < maxXpoints[1].x)
            {
                swap(maxXpoints[0],minXpoints[i]);
                continue;
            }
        }

        if(x <= maxXpoints[0].x)
            if(x > maxXpoints[1].x )
            {
                swap(minXpoints[i], maxXpoints[1]);

            }

    }

    if(minXpoints[0].y > minXpoints[1].y)
    {
        points[0] = minXpoints[1];
        points[1] = minXpoints[0];
    }
    else
    {
        points[0] = minXpoints[0];
        points[1] = minXpoints[1];
    }

    if(maxXpoints[0].y > maxXpoints[1].y)
    {
        points[2] = maxXpoints[0];
        points[3] = maxXpoints[1];
    }
    else
    {
        points[2] = maxXpoints[1];
        points[3] = maxXpoints[0];
    }

}

最後，檢測結果如圖8所示。
result
圖8

相關推薦

形狀識別之直線檢測

形狀識別中常見的即是矩形框的識別，識別的主要步驟通常是：影象二值化，查詢輪廓，四邊形輪廓篩選等。當識別的目標矩形有一條邊被部分遮擋，如圖1所示，傳統的識別方法就不能達到識別的目的。 圖1 在這裡，提供一種識別的思路,僅供參考。識別的最終目標就是想識

形狀識別之直線檢測(LSD)

轉自一篇基於直線檢測的形狀識別方法，不同於霍夫直線檢測。原文網址：https://blog.csdn.net/liujiabin076/article/details/74917605LSD官網（原始碼下載）：http://www.ipol.im/pub/art/2012/g

人臉識別之人臉檢測（三）--Haar特徵原理及實現

本文主要由於OpenCV的haartraining程式，對haar特徵的補充及程式碼註釋。 Haar特徵的原理是什麼？ Haar特徵分為三類：邊緣特徵、線性特徵、中心特徵和對角線特徵，組合成特徵模板。特徵模板內有白色和黑色兩種矩形，並定義該模板的特徵值為白色矩形畫

人臉識別之人臉檢測（二）--人臉識別樣本製作及訓練測試

閒得沒事，折騰下opencv 人臉識別，從樣本製作到評估。 1.直接copy opencv裡的原始碼，建立工程，新增opencv庫，可以直接cmake原始碼，但我之所以自己建立工程，是想多學習，並且降低與原始碼框架的耦合度。 這裡如果出現_imp__CreateToo

人臉識別之人臉檢測（五）--adaboost總結，整理

20170706新增: 各種Adaboost variants的比較以及不均衡問題 1.這邊有個淺顯的解釋。 2.簡單解釋到程式碼實現。 3.相對來說，這個看起來不是個人總結。 4.手動C程式碼Adaboost + stump弱

人臉識別之人臉檢測（十六）--Cascade CNN

轉自：https://blog.csdn.net/xzzppp/article/details/51692907 論文：A Convolutional Neural Network Cascade for FaceDetection 1、簡介     CascadeCN

人臉識別之疲勞檢測（二）閾值法、KNN分類和Ｋ-means聚類

Table of Contents 1、均值法 2、中值法 3、KNN 結合上一節在獲得人眼特徵點後需要對睜眼閉眼狀態做出判斷，方法的選擇需要經驗結合公平的評價方法，使用大量測試集得到不同方法下的精確度並做出比較: 1、均值法 50幀睜眼資料取均值，得到不同閾

直線檢測（line detection）之霍夫變換

前言 　　[影象處理] 實驗筆記系列是以影象處理演算法為主的文章專欄，以我在演算法研究中的實驗筆記資料為基礎加以整理推出的。該系列內容涉及常見的影象處理演算法理論以及常見的演算法應用，每篇部落格都會介紹相關的演算法原理，程式碼實現和演算法在實際應用中的技巧。

文字檢測+識別之FOTS

論文：FOTS: Fast Oriented Text Spotting with a Unified Network Github：https://github.com/jiangxiluning/FOTS.PyTorch   商湯和深圳先進院喬宇老師合租的作品。 &

yolo v2之車牌檢測後續識別字符（二）

一、前言        這一篇續接前一篇《yolo v2之車牌檢測後續識別字符（一）》，主要是生成模型檔案、配置檔案以及訓練、測試模型。 二、python介面生成配置檔案、模型檔案        車牌圖片端到端識別的模型檔案參考自這裡，模型圖如下所示：         本

JAVA實現人臉識別，活體檢測之百度API

-----------------------8/16更新--------------------------- 有人問原始碼: 連結：https://pan.baidu.com/s/1WP37IBacu6VZwtNOUDbSYg 密碼：vdzm 在這 -------

yolo v2之車牌檢測後續識別字符（一）

一、前言        本篇續接前一篇 yolo v2 之車牌檢測 ，前一篇使用yolo v2已經可以很準確地框出車牌圖片了，這裡完成後續的車牌字元號碼的識別，從車牌框框中要識別出車牌字元，筆者能想到3種思路，1種是同樣yolo、SSD等深度學習目標檢測的方法直接對車牌內的

OpenCV學習之路——車牌識別之車牌定位

pla sim srand oval 模糊 fault .html swa ide 去年七月份因為學校項目需要開始接觸圖像處理，但那時候只是到網上找車牌識別代碼，然後加入到自己的項目中，不清楚細節原理。 現在自己重新一步步實現車牌識別。 高斯模糊： 1 Mat Ga

語音識別之初體驗

實時 popu 背景 pcc 詞匯 原則 分類 work 通過 一、概述 作為最自然的人機交互方式 －－語音，正在改變人們的生活，豐富多媒體技術的應用。語音識別技術是語音信號處理的一個重要分支，也是近年來非常火的一個研究領域。隨著科技的飛速發展，語音識別不僅在桌面PC和

Halcon學習之邊緣檢測函數

轉換 函數 灰度 nms dir 學習 邊緣 檢測 進行 sobel_amp ( Image : EdgeAmplitude : FilterType, Size : ) 根據圖像的一次導數計算圖像的邊緣 close_edges ( Edges, EdgeImage :

車牌識別之識別與分割

atl i+1 ear %x 註釋 rgb itl original gin 1.定位，主要就是根據顏色特征，中國的車牌大都是藍牌的，也就用這種最典型的了 2.分割，分割首先還是建立在第一步基礎上，然後是用位置和投影來進行分割 哇，註釋全亂了。。。。。。。 clear a

python模塊之imghdr檢測圖片類型

logs python模塊 資料 .cn href 類型 manager 表示 response 1. imghdr是什麽 imghdr是一個用來檢測圖片類型的模塊，傳遞給它的可以是一個文件對象，也可以是一個字節流。 能夠支持的圖片格式： 2. 如何使用 提

c#圖文識別之百度api調用

arr 範圍 demo1 識別 del null var jobject static //百度圖片識別api接口　　public static JObject GeneralBasic(string apikey,string secretkey,string path)

OpenCV中幾何形狀識別與測量

OpenCV Python 圖像處理 形狀識別 幾何分析 經常看到有學習OpenCV不久的人提問，如何識別一些簡單的幾何形狀與它們的顏色，其實通過OpenCV的輪廓發現與幾何分析相關的函數，只需不到100行的代碼就可以很好的實現這些簡單幾何形狀識別與對象測量相關操作。本文就會演示給大家如何

車牌識別之規範應用

手機 程序 分享 操作系統 不可 自動 時間 帶來 安裝 越來越多的汽車成為了人們必不可少的交通工具給人們的交通帶來了不可言喻的便利。 從而車輛也遇到了——車輛管理、車輛查詢、車輛收費等等多種問題。 越來越多的汽車的數量與不斷減少的工作人員形成矛盾。從而誕生了電子警務、移動