OpenCV學習(13) 細化算法(1)

程序編碼參考經典的細化或者骨架算法文章：

T. Y. Zhang and C. Y. Suen, 「A fast parallel algorithm for thinning digital patterns,」 Comm. ACM, vol. 27, no. 3, pp. 236-239, 1984.

它的原理也很簡單：

      咱們對一副二值圖像進行骨架提取，就是刪除不須要的輪廓點，只保留其骨架點。假設一個像素點，咱們定義該點爲p1，則它的八鄰域點p2->p9位置以下圖所示，該算法考慮p1點鄰域的實際狀況，以便決定是否刪除p1點。假設咱們處理的爲二值圖像，背景爲黑色，值爲0，要細化的前景物體像素值爲1。

算法的描述以下。

首先複製源圖像到目地圖像，而後創建一個臨時圖像，接着執行下面操做：

1. 把目地圖像複製給臨時圖像，對臨時圖像進行一次掃描，對於不爲0的點，若是知足如下四個條件，則在目地圖像中刪除該點(就是設置該像素爲0)，這裏p2，…，p9是對應位置的像素灰度值(其爲1或者0)。

   a. 2<= p2+p3+p4+p5+p6+p7+p8+p9<=6

    大於等於2會保證p1點不是端點或孤立點，由於刪除端點和孤立點是不合理的，小於等於6保證p1點是一個邊界點，而不是一個內部點。等於0時候，周圍沒有等於1的像素，因此p1爲孤立點，等於1的時候，周圍只有1個灰度等於1的像素，因此是端點（注：端點是周圍有且只能有1個值爲1的像素)。

 

   b. p2->p9的排列順序中，01模式的數量爲1，好比下面的圖中，有p2p3 => 01, p6p7=>01,因此該像素01模式的數量爲2。

     之因此要01模式數量爲1，是要保證刪除當前像素點後的連通性。好比下面的圖中，01模式數量大於1，若是刪除當前點p1，則連通性不能保證。

    c. P2*p4*p6 = 0

    d. p4*p6*p8 = 0

      在第一次子迭代中，只是移去東南的邊界點，而不考慮西北的邊界點，注意p4,p6出現了2次，就是說它們有一個爲0，則c，d就知足。

2. 接下來，把目地圖像再次複製到臨時圖像，接着對臨時圖像進行一次掃描，若是不爲0的點它的八鄰域知足如下4個條件，則在目地圖像中刪除該點(就是設置該像素爲0)

    a. 2<= p2+p3+p4+p5+p6+p7+p8+p9<=6

    b. p2->p9的排列順序中，01模式的數量(這裏假設二值圖非零值爲1)爲1。

    c. p2*p4*p8 = 0

    d. p2*p6*p8 = 0

第二次迭代則相反，會移去西北的邊界點，注意p2,p8出現了2次，就是說它們有一個爲0，則c，d就知足。

執行完上面兩個步驟後，就完成了一次細化算法，咱們能夠屢次迭代執行上述過程，獲得最終的骨架圖。

細化算法代碼以下：

void gThin::cvThin(cv::Mat& src, cv::Mat& dst, int intera)
    {
    if(src.type()!=CV_8UC1)
        {
        printf("只能處理二值或灰度圖像\n");
        return;
        }
    //非原地操做時候，copy src到dst
    if(dst.data!=src.data)
        {
        src.copyTo(dst);
        }

    int i, j, n;
    int width, height;
    width = src.cols -1;
    //之因此減1，是方便處理8鄰域，防止越界
    height = src.rows -1;
    int step = src.step;
    int  p2,p3,p4,p5,p6,p7,p8,p9;
    uchar* img;
    bool ifEnd;
    int A1;
    cv::Mat tmpimg;
    //n表示迭代次數
    for(n = 0; n<intera; n++)
        {
        dst.copyTo(tmpimg);
        ifEnd = false;
        img = tmpimg.data;
        for(i = 1; i < height; i++)
            {
            img += step;
            for(j =1; j<width; j++)
                {
                uchar* p = img + j;
                A1 = 0;
                if( p[0] > 0)
                    {
                    if(p[-step]==0&&p[-step+1]>0) //p2,p3 01模式
                        {
                        A1++;
                        }
                    if(p[-step+1]==0&&p[1]>0) //p3,p4 01模式
                        {
                        A1++;
                        }
                    if(p[1]==0&&p[step+1]>0) //p4,p5 01模式
                        {
                        A1++;
                        }
                    if(p[step+1]==0&&p[step]>0) //p5,p6 01模式
                        {
                        A1++;
                        }
                    if(p[step]==0&&p[step-1]>0) //p6,p7 01模式
                        {
                        A1++;
                        }
                    if(p[step-1]==0&&p[-1]>0) //p7,p8 01模式
                        {
                        A1++;
                        }
                    if(p[-1]==0&&p[-step-1]>0) //p8,p9 01模式
                        {
                        A1++;
                        }
                    if(p[-step-1]==0&&p[-step]>0) //p9,p2 01模式
                        {
                        A1++;
                        }
                    p2 = p[-step]>0?1:0;
                    p3 = p[-step+1]>0?1:0;
                    p4 = p[1]>0?1:0;
                    p5 = p[step+1]>0?1:0;
                    p6 = p[step]>0?1:0;
                    p7 = p[step-1]>0?1:0;
                    p8 = p[-1]>0?1:0;
                    p9 = p[-step-1]>0?1:0;
                    if((p2+p3+p4+p5+p6+p7+p8+p9)>1 && (p2+p3+p4+p5+p6+p7+p8+p9)<7  &&  A1==1)
                        {
                        if((p2==0||p4==0||p6==0)&&(p4==0||p6==0||p8==0)) //p2*p4*p6=0 && p4*p6*p8==0
                            {
                            dst.at<uchar>(i,j) = 0; //知足刪除條件，設置當前像素爲0
                            ifEnd = true;
                            }
                        }
                    }
                }
            }
        
        dst.copyTo(tmpimg);
        img = tmpimg.data;
        for(i = 1; i < height; i++)
            {
            img += step;
            for(j =1; j<width; j++)
                {
                A1 = 0;
                uchar* p = img + j;
                if( p[0] > 0)
                    {
                    if(p[-step]==0&&p[-step+1]>0) //p2,p3 01模式
                        {
                        A1++;
                        }
                    if(p[-step+1]==0&&p[1]>0) //p3,p4 01模式
                        {
                        A1++;
                        }
                    if(p[1]==0&&p[step+1]>0) //p4,p5 01模式
                        {
                        A1++;
                        }
                    if(p[step+1]==0&&p[step]>0) //p5,p6 01模式
                        {
                        A1++;
                        }
                    if(p[step]==0&&p[step-1]>0) //p6,p7 01模式
                        {
                        A1++;
                        }
                    if(p[step-1]==0&&p[-1]>0) //p7,p8 01模式
                        {
                        A1++;
                        }
                    if(p[-1]==0&&p[-step-1]>0) //p8,p9 01模式
                        {
                        A1++;
                        }
                    if(p[-step-1]==0&&p[-step]>0) //p9,p2 01模式
                        {
                        A1++;
                        }
                    p2 = p[-step]>0?1:0;
                    p3 = p[-step+1]>0?1:0;
                    p4 = p[1]>0?1:0;
                    p5 = p[step+1]>0?1:0;
                    p6 = p[step]>0?1:0;
                    p7 = p[step-1]>0?1:0;
                    p8 = p[-1]>0?1:0;
                    p9 = p[-step-1]>0?1:0;
                    if((p2+p3+p4+p5+p6+p7+p8+p9)>1 && (p2+p3+p4+p5+p6+p7+p8+p9)<7  &&  A1==1)
                        {
                        if((p2==0||p4==0||p8==0)&&(p2==0||p6==0||p8==0)) //p2*p4*p8=0 && p2*p6*p8==0
                            {
                            dst.at<uchar>(i,j) = 0; //知足刪除條件，設置當前像素爲0
                            ifEnd = true;
                            }
                        }
                    }
                }
            }

        //若是兩個子迭代已經沒有能夠細化的像素了，則退出迭代
        if(!ifEnd) break;
        }

    }

下面是三次細化的結果，能夠看出在垂直方向H變短了，感受這是不完美的地方。

下面咱們對兩個漢字進行5次迭代細化，結果以下：

程序代碼：工程FirstOpenCV11