2. 程式人生 > >影象處理（五）——連通域

影象處理（五）——連通域

阿新 • • 發佈：2018-11-11

連通區域（Connected Component）一般是指影象中具有相同畫素值且位置相鄰的前景畫素點組成的影象區域（Region，Blob）。連通區域分析（Connected Component Analysis,Connected Component Labeling）是指將影象中的各個連通區域找出並標記。
連通區域分析是一種在CVPR和影象分析處理的眾多應用領域中較為常用和基本的方法。例如：OCR識別中字元分割提取（車牌識別、文字識別、字幕識別等）、視覺跟蹤中的運動前景目標分割與提取（行人入侵檢測、遺留物體檢測、基於視覺的車輛檢測與跟蹤等）、醫學影象處理（感興趣目標區域提取）、等等。也就是說，在需要將前景目標提取出來以便後續進行處理的應用場景中都能夠用到連通區域分析方法，通常連通區域分析處理的物件是一張二值化後的影象。

而這次我要做的是實現影象的快速連通域演算法，可以提取出影象中的連通域，並將不同連通域用不同顏色表示。

尋找影象中的連通域的演算法有兩個，一個是Two-Pass方法

Two-Pass演算法的簡單步驟：

（1）第一次掃描：
訪問當前畫素B(x,y)，如果B(x,y) == 1：

a、如果B(x,y)的領域中畫素值都為0，則賦予B(x,y)一個新的label：
label += 1， B(x,y) = label；

b、如果B(x,y)的領域中有畫素值 > 1的畫素Neighbors：
1）將Neighbors中的最小值賦予給B(x,y):
B(x,y) = min{Neighbors}

2）記錄Neighbors中各個值（label）之間的相等關係，即這些值（label）同屬同一個連通區域；

labelSet[i] = { label_m, …, label_n }，labelSet[i]中的所有label都屬於同一個連通區域

圖示為：
在這裡插入圖片描述

// 1. 第一次遍歷

	_lableImg.release();
	_binImg.convertTo(_lableImg, CV_32SC1);

	int label = 1;  // start by 2
	std::vector<int> labelSet;
	labelSet.push_back(0);   // background: 0
	labelSet.push_back(1);   // foreground: 1

	int rows = _binImg.rows - 1;
	int cols = _binImg.cols - 1;
	for (int i = 1; i < rows; i++)
	{
		int* data_preRow = _lableImg.ptr<int>(i - 1);
		int* data_curRow = _lableImg.ptr<int>(i);
		for (int j = 1; j < cols; j++)
		{
			if (data_curRow[j] == 1)
			{
				std::vector<int> neighborLabels;
				neighborLabels.reserve(2);
				int leftPixel = data_curRow[j - 1];
				int upPixel = data_preRow[j];
				if (leftPixel > 1)
				{
					neighborLabels.push_back(leftPixel);
				}
				if (upPixel > 1)
				{
					neighborLabels.push_back(upPixel);
				}

				if (neighborLabels.empty())
				{
					labelSet.push_back(++label);  // assign to a new label
					data_curRow[j] = label;
					labelSet[label] = label;
				}
				else
				{
					std::sort(neighborLabels.begin(), neighborLabels.end());
					int smallestLabel = neighborLabels[0];
					data_curRow[j] = smallestLabel;

					// save equivalence
					for (size_t k = 1; k < neighborLabels.size(); k++)
					{
						int tempLabel = neighborLabels[k];
						int& oldSmallestLabel = labelSet[tempLabel];
						if (oldSmallestLabel > smallestLabel)
						{
							labelSet[oldSmallestLabel] = smallestLabel;
							oldSmallestLabel = smallestLabel;
						}
						else if (oldSmallestLabel < smallestLabel)
						{
							labelSet[smallestLabel] = oldSmallestLabel;
						}
					}
				}
			}
		}
	}

（2）第二次掃描：
訪問當前畫素B(x,y)，如果B(x,y) > 1：

a、找到與label = B(x,y)同屬相等關係的一個最小label值，賦予給B(x,y)；
完成掃描後，影象中具有相同label值的畫素就組成了同一個連通區域。

圖示為：
在這裡插入圖片描述

// 2. 第二遍掃描
	for (int i = 0; i < rows; i++)
	{
		int* data = _lableImg.ptr<int>(i);
		for (int j = 0; j < cols; j++)
		{
			int& pixelLabel = data[j];
			pixelLabel = labelSet[pixelLabel];
		}
	}
}

另一個方法就是Seed-Filling方法

種子填充法的連通區域分析方法：

（1）掃描影象，直到當前畫素點B(x,y) == 1：

a、將B(x,y)作為種子（畫素位置），並賦予其一個label，然後將該種子相鄰的所有前景畫素都壓入棧中；
在這裡插入圖片描述
b、彈出棧頂畫素，賦予其相同的label，然後再將與該棧頂畫素相鄰的所有前景畫素都壓入棧中；
在這裡插入圖片描述

// 推及到四個鄰居
					if (_lableImg.at<int>(curX, curY - 1) == 1)
					{// 左邊的畫素
						neighborPixels.push(std::pair<int, int>(curX, curY - 1));
					}
					if (_lableImg.at<int>(curX, curY + 1) == 1)
					{// 右邊的畫素
						neighborPixels.push(std::pair<int, int>(curX, curY + 1));
					}
					if (_lableImg.at<int>(curX - 1, curY) == 1)
					{// 上面的畫素
						neighborPixels.push(std::pair<int, int>(curX - 1, curY));
					}
					if (_lableImg.at<int>(curX + 1, curY) == 1)
					{// 下面的畫素
						neighborPixels.push(std::pair<int, int>(curX + 1, curY));
					}

c、重複b步驟，直到棧為空；
此時，便找到了影象B中的一個連通區域，該區域內的畫素值被標記為label；
在這裡插入圖片描述
（2）重複第（1）步，直到掃描結束；
在這裡插入圖片描述
掃描結束後，就可以得到影象B中所有的連通區域；

而我選擇的是種子填充方法。
對下面這張圖片做處理在這裡插入圖片描述
得到結果為：
在這裡插入圖片描述

改變連通域顏色：

我用的方法是在剛開始的時候就隨機設定三個RGB 值，然後為填充不同連通域（每個連通域的畫素的RGB值都是隨機的）。

cv::Scalar icvprGetRandomColor()
{
	uchar r = 255 * (rand() / (1.0 + RAND_MAX));
	uchar g = 255 * (rand() / (1.0 + RAND_MAX));
	uchar b = 255 * (rand() / (1.0 + RAND_MAX));
	return cv::Scalar(b, g, r);
}

程式碼自取

// CVE6.cpp: 定義控制檯應用程式的入口點。
//

#include "stdafx.h"
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <stdio.h>
using namespace cv;
//Two Pass方法
void icvprCcaByTwoPass(const cv::Mat& _binImg, cv::Mat& _lableImg)
{
	/*
	 Two-Pass演算法的簡單步驟：
     （1）第一次掃描：
     訪問當前畫素B(x,y)，如果B(x,y) == 1：
     a、如果B(x,y)的領域中畫素值都為0，則賦予B(x,y)一個新的label：
     label += 1， B(x,y) = label；
     b、如果B(x,y)的領域中有畫素值 > 1的畫素Neighbors：
     1）將Neighbors中的最小值賦予給B(x,y):
     B(x,y) = min{Neighbors} 
     2）記錄Neighbors中各個值（label）之間的相等關係，即這些值（label）同屬同一個連通區域；
     labelSet[i] = { label_m, .., label_n }，labelSet[i]中的所有label都屬於同一個連通區域
	 （2）第二次掃描：
	 訪問當前畫素B(x,y)，如果B(x,y) > 1：
	 a、找到與label = B(x,y)同屬相等關係的一個最小label值，賦予給B(x,y)；
	 完成掃描後，影象中具有相同label值的畫素就組成了同一個連通區域。
	*/

	if (_binImg.empty() ||
		_binImg.type() != CV_8UC1)
	{
		return;
	}

	// 1. 第一次遍歷

	_lableImg.release();
	_binImg.convertTo(_lableImg, CV_32SC1);

	int label = 1;  // start by 2
	std::vector<int> labelSet;
	labelSet.push_back(0);   // background: 0
	labelSet.push_back(1);   // foreground: 1

	int rows = _binImg.rows - 1;
	int cols = _binImg.cols - 1;
	for (int i = 1; i < rows; i++)
	{
		int* data_preRow = _lableImg.ptr<int>(i - 1);
		int* data_curRow = _lableImg.ptr<int>(i);
		for (int j = 1; j < cols; j++)
		{
			if (data_curRow[j] == 1)
			{
				std::vector<int> neighborLabels;
				neighborLabels.reserve(2);
				int leftPixel = data_curRow[j - 1];
				int upPixel = data_preRow[j];
				if (leftPixel > 1)
				{
					neighborLabels.push_back(leftPixel);
				}
				if (upPixel > 1)
				{
					neighborLabels.push_back(upPixel);
				}

				if (neighborLabels.empty())
				{
					labelSet.push_back(++label);  // assign to a new label
					data_curRow[j] = label;
					labelSet[label] = label;
				}
				else
				{
					std::sort(neighborLabels.begin(), neighborLabels.end());
					int smallestLabel = neighborLabels[0];
					data_curRow[j] = smallestLabel;

					// save equivalence
					for (size_t k = 1; k < neighborLabels.size(); k++)
					{
						int tempLabel = neighborLabels[k];
						int& oldSmallestLabel = labelSet[tempLabel];
						if (oldSmallestLabel > smallestLabel)
						{
							labelSet[oldSmallestLabel] = smallestLabel;
							oldSmallestLabel = smallestLabel;
						}
						else if (oldSmallestLabel < smallestLabel)
						{
							labelSet[smallestLabel] = oldSmallestLabel;
						}
					}
				}
			}
		}
	}

	// 更新標籤
	// 用每個連通域中最小的標籤來表示這個連通域
	for (size_t i = 2; i < labelSet.size(); i++)
	{
		int curLabel = labelSet[i];
		int preLabel = labelSet[curLabel];
		while (preLabel != curLabel)
		{
			curLabel = preLabel;
			preLabel = labelSet[preLabel];
		}
		labelSet[i] = curLabel;
	}

	// 2. 第二遍掃描
	for (int i = 0; i < rows; i++)
	{
		int* data = _lableImg.ptr<int>(i);
		for (int j = 0; j < cols; j++)
		{
			int& pixelLabel = data[j];
			pixelLabel = labelSet[pixelLabel];
		}
	}
}

void icvprCcaBySeedFill(const cv::Mat& _binImg, cv::Mat& _lableImg)
{
	/*
	種子填充法的連通區域分析方法：
（1）掃描影象，直到當前畫素點B(x,y) == 1：
a、將B(x,y)作為種子（畫素位置），並賦予其一個label，然後將該種子相鄰的所有前景畫素都壓入棧中；
b、彈出棧頂畫素，賦予其相同的label，然後再將與該棧頂畫素相鄰的所有前景畫素都壓入棧中；
c、重複b步驟，直到棧為空；
此時，便找到了影象B中的一個連通區域，該區域內的畫素值被標記為label；
（2）重複第（1）步，直到掃描結束；
掃描結束後，就可以得到影象B中所有的連通區域；
	*/

	if (_binImg.empty() ||
		_binImg.type() != CV_8UC1)
	{
		return;
	}

	_lableImg.release();
	_binImg.convertTo(_lableImg, CV_32SC1);

	int label = 1;  // start by 2

	int rows = _binImg.rows - 1;
	int cols = _binImg.cols - 1;
	for (int i = 1; i < rows - 1; i++)
	{
		int* data = _lableImg.ptr<int>(i);
		for (int j = 1; j < cols - 1; j++)
		{
			if (data[j] == 1)
			{
				std::stack<std::pair<int, int>> neighborPixels;
				neighborPixels.push(std::pair<int, int>(i, j));     // 畫素座標: <i,j>
				++label;  //從一個新label開始
				while (!neighborPixels.empty())
				{
					// 棧中最上面的畫素給予和與其連通的畫素相同的label
					std::pair<int, int> curPixel = neighborPixels.top();
					int curX = curPixel.first;
					int curY = curPixel.second;
					_lableImg.at<int>(curX, curY) = label;

					// 彈出最上面的畫素
					neighborPixels.pop();

					// 推及到四個鄰居
					if (_lableImg.at<int>(curX, curY - 1) == 1)
					{// 左邊的畫素
						neighborPixels.push(std::pair<int, int>(curX, curY - 1));
					}
					if (_lableImg.at<int>(curX, curY + 1) == 1)
					{// 右邊的畫素
						neighborPixels.push(std::pair<int, int>(curX, curY + 1));
					}
					if (_lableImg.at<int>(curX - 1, curY) == 1)
					{// 上面的畫素
						neighborPixels.push(std::pair<int, int>(curX - 1, curY));
					}
					if (_lableImg.at<int>(curX + 1, curY) == 1)
					{// 下面的畫素
						neighborPixels.push(std::pair<int, int>(curX + 1, curY));
					}
				}
			}
		}
	}
}

//為連通域加上顏色
cv::Scalar icvprGetRandomColor()
{
	uchar r = 255 * (rand() / (1.0 + RAND_MAX));
	uchar g = 255 * (rand() / (1.0 + RAND_MAX));
	uchar b = 255 * (rand() / (1.0 + RAND_MAX));
	return cv::Scalar(b, g, r);
}

void icvprLabelColor(const cv::Mat& _labelImg, cv::Mat& _colorLabelImg)
{
	if (_labelImg.empty() ||
		_labelImg.type() != CV_32SC1)
	{
		return;
	}

	std::map<int, cv::Scalar> colors;

	int rows = _labelImg.rows;
	int cols = _labelImg.cols;

	_colorLabelImg.release();
	_colorLabelImg.create(rows, cols, CV_8UC3);
	_colorLabelImg = cv::Scalar::all(0);

	for (int i = 0; i < rows; i++)
	{
		const int* data_src = (int*)_labelImg.ptr<int>(i);
		uchar* data_dst = _colorLabelImg.ptr<uchar>(i);
		for (int j = 0; j < cols; j++)
		{
			int pixelValue = data_src[j];
			if (pixelValue > 1)
			{
				if (colors.count(pixelValue) <= 0)
				{
					colors[pixelValue] = icvprGetRandomColor();
				}
				cv::Scalar color = colors[pixelValue];
				*data_dst++ = color[0];
				*data_dst++ = color[1];
				*data_dst++ = color[2];
			}
			else
			{
				data_dst++;
				data_dst++;
				data_dst++;
			}
		}
	}
}

int main(int argc, char** argv)
{
	cv::Mat binImage = cv::imread("E:/C++/CVE6/圖片2.png", 0);
	cv::imshow("img", binImage);
	//cv::Mat binImage2;
	cv::threshold(binImage, binImage, 50, 1, CV_THRESH_BINARY_INV);
	
	cv::Mat labelImg;
	//icvprCcaByTwoPass(binImage, labelImg);
	icvprCcaBySeedFill(binImage, labelImg) ;

	// 展示結果
	cv::Mat grayImg;
	//結果*10，更突出
	labelImg *= 10;
	labelImg.convertTo(grayImg, CV_8UC1);
	cv::imshow("labelImg", grayImg);

	cv::Mat colorLabelImg;
	//更改連通域顏色
	icvprLabelColor(labelImg, colorLabelImg);
	cv::imshow("colorImg", colorLabelImg);
	cv::waitKey(0);

	return 0;
}

相關推薦

影象處理（五）——連通域

連通區域（Connected Component）一般是指影象中具有相同畫素值且位置相鄰的前景畫素點組成的影象區域（Region，Blob）。連通區域分析（Connected Component Analysis,Connected Component Labeling）是指將影

影象處理（3）頻率域濾波

Fourier變換 Fourier變換最開始由傅立葉提出，當時為了解決熱力學問題。後來經過發展形成了一套完整的理論，應用在物理學、訊號學等很多方面。如果一個函式滿足絕對可積條件，即： 因為計算機處理的是離散值，要求對f(x)和F(w)都取樣，這時Fourier變換被稱為離

c語言數字影象處理（五）：空間濾波

 空間濾波原理 使用大小為m*n的濾波器對大小為M*N的影象進行線性空間濾波，將濾波器模板乘以影象中對應灰度值，相加得模板中心灰度值                                                                              a = (m-1)

python+OpenCV影象處理（五）影象的閾值分割

影象的閾值處理      一幅影象包括目標物體、背景還有噪聲，要想從多值的數字影象中直接提取出目標物體，常用的方法就是設定一個閾值T，用T將影象的資料分成兩部分：大於T的畫素群和小於T的畫素群。這是研究灰度變換的最特殊的方法，稱為影象的二值化（Binarization）。 

基於FPGA的影象處理（五）--狀態機

        使用FPGA實現各種演算法時，狀態機是很常用的方法，在SysGen中有兩種非常簡便的方法構建狀態機，一是使用Mcode，以switch-case語句輕鬆實現，二是使用SysGen自帶狀態機模組。      狀態機 假設我們要從01序列中檢測出1011序列，則

數字影象處理（五） 利用PCA演算法進行人臉識別

load('FaceLab.mat'); %他人原始碼，未經同意不得隨便轉載 % filelist=dir('*.bmp'); %inFilename = filelist.name; %讀入識別影象  testface = imread('test.bmp'); % testface = rgb2gra

Python+OpenCV圖像處理（五）—— ROI與泛洪填充

targe ros com ray inter color 方式 高度 lan 一、ROI ROI（region of interest），感興趣區域。機器視覺、圖像處理中，從被處理的圖像以方框、圓、橢圓、不規則多邊形等方式勾勒出需要處理的區域，稱為感興趣區域，ROI。

python 驗證碼 （二） 連通域分割

pass 技術 def cep get() style box 垂直 -c 切割前：　　 　　切割後： 　　　　　　　　 代碼： #-*-coding:utf-8-*- from PIL import Image import queue

c語言數字圖像處理（五）：空間濾波

element tex play ali p s pla lte ret void 空間濾波原理 使用大小為m*n的濾波器對大小為M*N的圖像進行線性空間濾波，將濾波器模板乘以圖像中對應灰度值，相加得模板中心灰度值

JS學習（五）作用域

//函式作用域   //JavaScript 的作用域為詞法作用域， //所謂詞法作用域是說，其作用域為在定義時(詞法分析時)就確定下來的，而並非在執行時確定   //作用域鏈是關於作用域的鏈，通常實現為一個連結串列，連結串列的每個項都是一個物件，&

c語言數字影象處理（六）：二維離散傅立葉變換

基礎知識 複數表示 C = R + jI 極座標：C = |C|(cosθ + jsinθ) 尤拉公式：C = |C|ejθ 有關更多的時域與複頻域的知識可以學習複變函式與積分變換，本篇文章只給出DFT公式，性質，以及實現方法 二維離散傅立葉變換(DFT) 其中f(x,y)為原影象，F(u,

Python程式設計 簡單的影象處理（1）

Python程式設計 簡單的影象處理（1） 1.寫個濾鏡 照片照的好，不如濾鏡用得好！一款好的濾鏡軟體可以讓照片呈現不一樣的風格乃至風情，修理照片需要揚長避短達到最佳效果。可是濾鏡款式千百種，卻沒有一款專門為你設計？？不如自己來寫個濾鏡吧！ 1.先上一張圖： 藉助Python的兩個

Python程式設計 簡單的影象處理（2）

有關中醫舌像的簡單分析 黑白圖的應用十分廣泛，它是深度學習影象處理的基礎，是影象分割、影象拼接、影象紋理分析等等技術的組成部分,較常見的應用在於X線圖片、CT圖片、MRI圖片、B超圖片、電鏡圖片等醫學領域。 在傳統醫學的“望聞問切”四診中，望診作為疾病視覺資訊的診察手段被譽為“四診之首”，舌

影象處理（八）——霍夫變換

霍夫變換是一種特徵檢測(feature extraction)，被廣泛應用在影象分析（image analysis）、電腦視覺(computer vision)以及數位影像處理(digital image processing)。 霍夫變換是用來辨別找出物件中的特徵，例如：線條。

影象處理（七）——Canny邊緣檢測

Canny邊緣檢測運算元是John F. Canny於 1986 年開發出來的一個多級邊緣檢測演算法。更為重要的是 Canny 創立了邊緣檢測計算理論（Computational theory of edge detection）解釋這項技術如何工作。 通常情況下邊緣檢測的目的是

影象處理（六）——距離變換

影象的距離變換實現了畫素與影象區域的距離變換，使得最後生成的影象在該自己元素位置處的畫素為0，臨近的背景的畫素具有較小的值，且隨著距離的增大它的的數值也就越大。 對於距離影象來說，影象中的每個畫素的灰度值為該畫素與距離其最近的背景畫素間的距離，也就是說，給每個畫素賦值為離它最近的

影象處理（四）——快速均值濾波（MATLAB實現）

均值濾波是典型的線性濾波演算法，它是指在影象上對目標畫素給一個模板，該模板包括了其周圍的臨近畫素（以目標畫素為中心的周圍8個畫素，構成一個濾波模板，即去掉目標畫素本身），再用模板中的全體畫素的平均值來代替原來畫素值。 快速均值濾波要求： 在這裡就要先解釋一下積分圖

影象處理（三）——高斯濾波

一、高斯濾波 高斯濾波是一種線性平滑濾波，適用於消除高斯噪聲，廣泛應用於影象處理的減噪過程。通俗的講，高斯濾波就是對整幅影象進行加權平均的過程，每一個畫素點的值，都由其本身和鄰域內的其他畫素值經過加權平均後得到。 實現影象的高斯濾波： 通過調整高斯函式的

影象處理（二）——影象仿射變換

這次實驗是要設計一個可以讓圖形進行繞任意中心任意角度旋轉的函式WarpAffine，其核心大概就是使用雙線性差值進行重取樣。 在數學上，雙線性插值是有兩個變數的插值函式的線性插值擴充套件，其核心思想是在兩個方向分別進行一次線性插值。 在程式碼中實現雙線性插值要注意原影象和目標影象的原

影象處理（1）——對比度和亮度調整

1.內容 設計一個Sigmoid函式，實現對影象的對比度調整； 使用opencv視窗系統的slider控制元件，互動改變Sigmoid函式的引數，實現不同程度的對比度調整； 2.方法 一次函式方法 想要調整圖片的對比度，就要對圖片中的畫素進行操作，改變畫素的值來