2. 程式人生 > >二值影象的骨架提取

二值影象的骨架提取

阿新 • • 發佈：2019-02-15

  本文介紹的二值影象細化演算法是來自 T.Y. Zhang and C.Y. Suen 1984 年發表的論文 “A fast parallel algorithm for thinning digital patterns” 中所介紹的演算法。

演算法介紹

我們先進行如下定義：

這裡寫圖片描述

P1 為我們要判斷是否刪去的點，則對其 8 鄰域分別按照上圖順序標記為 P2 P3 P4 P5 P6 P7 P8 P9；
B(P1) 為 P1 8 鄰域值為 1（影象為 0-1 二值圖）的點，即：

B(P1)=P2+P3+P4+P5+P6+P7+P8+P9
A(P1) 為 P1 8 領域按照上圖排序時（P9 後面接 P2），序列 0-1 的個數：

這裡寫圖片描述

若 P1 8 鄰域的值如上圖所示，則有 A（P1）= 2。

我們遍歷影象的每個點，對每個畫素為 1 的點做如下判斷：
1. 2<=B(P1)<=6
2. A(P1)=1
3. 當為奇數次迭代時，判斷 P2∗P4∗P6=0,P4∗P6∗P8=0；當為偶數次迭代時，判斷 P2∗P4∗P8=0,P2∗P6∗P8=0
如果滿足上述條件，則刪除該點。
迴圈遍歷影象，直至沒有點被刪除。

演算法流程

while point are deleted :
    for P1 in all pixels :
        if ((1)P1=1 
           (2)2
 
<=B(P1)<=6
           (3)A(P1)=1
           (4)in odd iterations:
              P2*P4*P6=0 && P4*P6*P8=0
              in even iterations:
              P2*P4*P8=0 && P2*P6*P8=0)
              delete P1
    end for
end while

程式碼

void zhangSkeleton(Mat &srcimage)
{
    int kernel[9
 
];
    int nl = srcimage.rows;
    int nc = srcimage.cols;
    vector<Point> delete_list;
    int A, B;
    while (true)
    {
        for (int j = 1; j < nl - 1; j++)
        {
            uchar* data_pre = srcimage.ptr<uchar>(j - 1);
            uchar* data = srcimage.ptr<uchar>(j);
            uchar* data_next = srcimage.ptr<uchar>(j + 1);
            for (int i = 1; i < (nc - 1); i++)
            {
                if (data[i] == 255)
                {
                    kernel[0] = 1;
                    if (data_pre[i] == 255) kernel[1] = 1;
                    else  kernel[1] = 0;
                    if (data_pre[i + 1] == 255) kernel[2] = 1;
                    else  kernel[2] = 0;
                    if (data[i + 1] == 255) kernel[3] = 1;
                    else  kernel[3] = 0;
                    if (data_next[i + 1] == 255) kernel[4] = 1;
                    else  kernel[4] = 0;
                    if (data_next[i] == 255) kernel[5] = 1;
                    else  kernel[5] = 0;
                    if (data_next[i - 1] == 255) kernel[6] = 1;
                    else  kernel[6] = 0;
                    if (data[i - 1] == 255) kernel[7] = 1;
                    else  kernel[7] = 0;
                    if (data_pre[i - 1] == 255) kernel[8] = 1;
                    else  kernel[8] = 0;

                    B=0;
                    for (int k = 1; k < 9; k++)
                    {
                        B = B + kernel[k];
                    }
                    if ((B >= 2) && (B <= 6))
                    {
                        A = 0;
                        if (!kernel[1] && kernel[2]) A++;
                        if (!kernel[2] && kernel[3]) A++;
                        if (!kernel[3] && kernel[4]) A++;
                        if (!kernel[4] && kernel[5]) A++;
                        if (!kernel[5] && kernel[6]) A++;
                        if (!kernel[6] && kernel[7]) A++;
                        if (!kernel[7] && kernel[8]) A++;
                        if (!kernel[8] && kernel[1]) A++;
                        //
                        if (A == 1)
                        {
                            if ((kernel[1] * kernel[3] * kernel[5] == 0) 
                            && (kernel[3] * kernel[5] * kernel[7] == 0))
                            {
                                delete_list.push_back(Point(i, j));
                            }
                        }
                    }               
                }
            }
        }
        int size = delete_list.size();
        if (size == 0)
        {
            break;
        }
        for (int n = 0; n < size; n++)
        {
            Point tem;
            tem = delete_list[n];
            uchar* data = srcimage.ptr<uchar>(tem.y);
            data[tem.x] = 0;
        }
        delete_list.clear();
        for (int j = 1; j < nl - 1; j++)
        {
            uchar* data_pre = srcimage.ptr<uchar>(j - 1);
            uchar* data = srcimage.ptr<uchar>(j);
            uchar* data_next = srcimage.ptr<uchar>(j + 1);
            for (int i = 1; i < (nc - 1); i++)
            {
                if (data[i] == 255)
                {
                    kernel[0] = 1;
                    if (data_pre[i] == 255) kernel[1] = 1;
                    else  kernel[1] = 0;
                    if (data_pre[i + 1] == 255) kernel[2] = 1;
                    else  kernel[2] = 0;
                    if (data[i + 1] == 255) kernel[3] = 1;
                    else  kernel[3] = 0;
                    if (data_next[i + 1] == 255) kernel[4] = 1;
                    else  kernel[4] = 0;
                    if (data_next[i] == 255) kernel[5] = 1;
                    else  kernel[5] = 0;
                    if (data_next[i - 1] == 255) kernel[6] = 1;
                    else  kernel[6] = 0;
                    if (data[i - 1] == 255) kernel[7] = 1;
                    else  kernel[7] = 0;
                    if (data_pre[i - 1] == 255) kernel[8] = 1;
                    else  kernel[8] = 0;

                    B = 0;
                    for (int k = 1; k < 9; k++)
                    {
                        B = B + kernel[k];
                    }
                    if ((B >= 2) && (B <= 6))
                    {
                        A = 0;
                        if (!kernel[1] && kernel[2]) A++;
                        if (!kernel[2] && kernel[3]) A++;
                        if (!kernel[3] && kernel[4]) A++;
                        if (!kernel[4] && kernel[5]) A++;
                        if (!kernel[5] && kernel[6]) A++;
                        if (!kernel[6] && kernel[7]) A++;
                        if (!kernel[7] && kernel[8]) A++;
                        if (!kernel[8] && kernel[1]) A++;
                        //
                        if (A == 1)
                        {
                            if ((kernel[1] * kernel[3] * kernel[7] == 0) 
                            && (kernel[1] * kernel[5] * kernel[7] == 0))
                            {
                                delete_list.push_back(Point(i, j));
                            }
                        }
                    }
                }
            }
        }
        if (size == 0)
        {
            break;
        }
        for (int n = 0; n < size; n++)
        {
            Point tem;
            tem = delete_list[n];
            uchar* data = srcimage.ptr<uchar>(tem.y);
            data[tem.x] = 0;
        }
        delete_list.clear();
    }
}

測試

這裡寫圖片描述

相關推薦

Win8 Metro(C#)數字影象處理--2.40二值影象輪廓提取演算法

 [函式名稱] 二值影象輪廓提取 ContourExtraction(WriteableBitmap src) [演算法說明]   二值影象的輪廓提取對於影象識別，影象分割有著重要意義。該演算法的核心就是將影象目標的內部點消除。所謂內部點，我們要根據當前畫素點的鄰域來進

二值影象的骨架提取

  本文介紹的二值影象細化演算法是來自 T.Y. Zhang and C.Y. Suen 1984 年發表的論文 “A fast parallel algorithm for thinning digital patterns” 中所介紹的演算法。 演算法介紹

使用Matlab對二值影象進行輪廓提取

  對圖1的檢測效果如圖3所示：                        圖3 edge檢測結果 參考資料 [1]輪廓提取 ===================================================================================

MATLAB進行二值處理並提取畫素值

今天又重新看了一下2013年國賽的B題，碎紙片的拼接復原。瞭解了一下MATLAB處理影象的過程，不得不說MATLAB功能太強大，處理圖片只要幾行程式碼就足夠了。這道題還用到了模擬退火演算法，也是用MATLAB編寫的，寫在下一篇部落格裡。 MATLAB程式： clc; clear; fil

實現基於C語言的二值影象連通域標記演算法

實現基於C語言的二值影象連通域標記演算法 1 #include <stdio.h> 2 #include <stdarg.h> 3 #include <stddef.h> 4 #include <stdlib.h> 5 #includ

基於卷積神經網路特徵圖的二值影象分割

       目標檢測是當前大火的一個研究方向，FasterRCNN、Yolov3等一系列結構也都在多目標檢測的各種應用場景或者競賽中取得了很不錯的成績。但是想象一下，假設我們需要通過影象檢測某個產品上是否存在缺陷，或者通過衛星圖判斷某片海域是否有某公司的船隻

利用PIL.ImageOps.invert實現二值影象黑白反轉

利用PIL.ImageOps.invert實現二值影象黑白反轉   import PIL.ImageOps from PIL import Image img = Image.open('D:\\Desktop\\計算機視覺\\image\\0.png') img =

影象分析：二值影象連通域標記

一、前言 二值影象，顧名思義就是影象的亮度值只有兩個狀態：黑(0)和白(255)。二值影象在影象分析與識別中有著舉足輕重的地位，因為其模式簡單，對畫素在空間上的關係有著極強的表現力。在實際應用中，很多影象的分析最終都轉換為二值影象的分析，比如：醫學影象分析、前景檢測、字元識

二值影象的腐蝕膨脹原理（附程式碼）

程式碼： #include <iostream> #include<vector> #include<iomanip> using namespace std; #define picX 6 #define picY 6 type

二值影象：B&W(黑白影象)、 Gray (灰度影象) 、單色影象//Color(彩色影象)

二值影象（binary image），即影象上的每一個畫素只有兩種可能的取值或灰度等級狀態，人們經常用黑白、B&W、單色影象表示二值影象。 B&W黑白影象： 只有黑色和白色，不存在過渡性的灰色，它一個畫素只需要一個二進位制位就能表示出來，即0表示

二值影象、灰度影象、彩色影象

二值影象 二值影象(Binary Image)，按名字來理解只有兩個值，0和1，0代表黑，1代表白，或者說0表示背景，而1表示前景。其儲存也相對簡單，每個畫素只需要1Bit就可以完整儲存資訊。如果把每個畫素看成隨機變數，一共有N個畫素，那麼二值圖有2的N次方種變化，而8位灰度

SSE影象演算法優化系列二十五:二值影象的Euclidean distance map（EDM)特徵圖計算及其優化。 SSE影象演算法優化系列九：靈活運用SIMD指令16倍提升Sobel邊緣檢測的速度（4000*3000的24點陣圖像時間由480ms降低到30ms）

　　Euclidean distance map（EDM)這個概念可能聽過的人也很少，其主要是用在二值影象中，作為一個很有效的中間處理手段存在。一般的處理都是將灰度圖處理成二值圖或者一個二值圖處理成另外一個二值圖，而EDM演算法確是由一幅二值圖生成一幅灰度圖。其核心定義如下： 　　The definitio

C++——bmp二值影象的腐蝕、膨脹、開運算、閉運算

本文實現二值bmp影象的腐蝕、膨脹及開運算、閉運算操作。本文使用白色為前景、黑色為背景的二值圖進行操作：1、腐蝕腐蝕操作是結構原中心在被腐蝕影象中平移填充的過程。影象A被結構元B腐蝕，用集合論來表示如下式：                                   

MATLAB 求兩張大小完全相同二值影象影象的白色區域重疊面積

如下圖，兩副大小完全相同的二值影象，現求取白色區域的重疊面積左側影象為test01.jpg，右側為test02.jpg。思路為1.使用imsubtract將兩副影象進行相減操作，假設為test01-test02,則imsubtract（test01，test02）,相減之後如

OpenCV-二值影象連通域分析

通域分析對於影象處理後面涉及到模式識別的內容來說是基礎 連通區域（Connected Component）一般是指影象中具有相同畫素值且位置相鄰的前景畫素點組成的影象區域（Region，Blob）。連通區域分析（Connected Component Analysis,C

二值影象處理開運算

應用背景：在前兩篇博文中我們看到腐蝕操作會縮小影象前景、膨脹操作會增大影象前景，經過這兩種變換後圖像的細節也發生了一些變換，如果腐蝕和膨脹同時處理影象會產生什麼效果呢，這個問題就是本文要講的開操作。 基本原理：在二值形態學影象處理中，除了腐蝕和膨脹這兩種一次運算外，還有二次

[影象] 二值影象的位置、朝向與投影

        二值影象就是由0,1組成的影象。我們可以通過一些簡單的計算獲取影象的一系列資訊。        面積：         所有1的總和         位置：         影象的位置一般由質心來表達，我們可以直接根據質心的定義來計算x軸方向和y軸方向的

二值影象腐蝕與膨脹操作樣例

申明： 僅個人小記 前言： 我之前對腐蝕與膨脹的概念理解存在錯誤。我原來的概念解決不了結構的原點設定在結構外部的情況。故在這裡記一下。 小注： 剛開始操作的時候是同時有三張圖，分別為原影象，結構元素影象，輸出結果空白影象 注意： 原影象只是提供位置資訊，不

利用opencv逼近二值影象的邊界點，並過濾不需要的邊界，達到尋邊效果。（轉載請說明出處）

二值化影象； 利用黑白畫素值求差，得到邊緣點； 過濾邊緣點找到合適區域； 利用cvFitLine2D擬合線。 做的比較粗糙，搜尋時間在10ms左右，希望有研究opencv的朋友斧正。 效果預覽： 、 void CvProcess::FindLine( Ip

OpenCV學習筆記之針對二值影象的邊緣光滑處理（突出部消除）

處理程式碼分為兩部分，第一部分用於去除邊緣的突出部，第二部分用於邊緣光滑。具體如下所示 1.去除邊緣突出部 //去除二值影象邊緣的突出部 //uthreshold、vthreshold分別表示突出部的寬度閾值和高度閾值 //type代表突出部的顏色，0表示黑色，1代表白色