基於區域的圖像分割-----------區域分裂合並

最新推荐文章于 2022-03-28 21:54:17 发布
最新推荐文章于 2022-03-28 21:54:17 发布
阅读量1.4k 收藏
点赞数
分类专栏： [Image]Contour 文章标签： image 算法 byte c
http://blog.csdn.net/cay22/article/details/5666109 

2. 區域分裂合並

區域分裂合並算法的基本思想是先確定一個分裂合並的准則,即區域特征一致性的測度,當圖像中某個區域的特征不一致時就將該區域分裂成4 個相等的子區域,當相鄰的子區域滿足一致性特征時則將它們合成一個大區域,直至所有區域不再滿足分裂合並的條件為止. 　　當分裂到不能再分的情況時，分裂結束，然後它將查找相鄰區域有沒有相似的特征，如果有就將相似區域進行合並，最後達到分割的作用。 　　在一定程度上區域生長和區域分裂合並算法有異曲同工之妙，互相促進相輔相成的，區域分裂到極致就是分割成單一像素點，然後按照一定的測量准則進行合並，在一定程度上可以認為是單一像素點的區域生長方法。 　　區域生長比區域分裂合並的方法節省了分裂的過程，而區域分裂合並的方法可以在較大的一個相似區域基礎上再進行相似合並，而區域生長只能從單一像素點出發進行生長（合並）。

 

反復進行拆分和聚合以滿足限制條件的算法。

令R表示整幅圖像區域並選擇一個謂詞P。對R進行分割的一種方法是反復將分割得到的結果圖像再次分為四個區域，直到對任何區域Ri，有P(Ri)=TRUE。這裡是從整幅圖像開始。如果P(R)=FALSE，就將圖像分割為4個區域。對任何區域如果P的值是FALSE．就將這4個區域的每個區域再次分別分為4個區域，如此不斷繼續下去。這種特殊的分割技術用所謂的四叉樹形式表示最為方便(就是說，每個非葉子節點正好有4個子樹)，這正如圖10.42中說明的樹那樣。注意，樹的根對應於整幅圖像，每個節點對應於劃分的子部分。此時，只有R4進行了進一步的再細分。

如果只使用拆分，最後的分區可能會包含具有相同性質的相鄰區域。這種缺陷可以通過進行拆分的同時也允許進行區域聚合來得到矯正。就是說，只有在P(Rj∪Rk)=TRUE時，兩個相鄰的區域Rj和Rk才能聚合。

前面的討論可以總結為如下過程。在反復操作的每一步，我們需要做：

l.對於任何區域Ri，如果P(Ri)=FALSE，就將每個區域都拆分為4個相連的象限區域。

2.將P(Rj∪Rk)=TRUE的任意兩個相鄰區域Rj和Rk進行聚合。

3.當再無法進行聚合或拆分時操作停止。

可以對前面講述的基本思想進行幾種變化。例如，一種可能的變化是開始時將圖像拆分為一組圖象塊。然後對每個塊進一步進行上述拆分，但聚合操作開始時受只能將4個塊並為一組的限制。這4個塊是四叉樹表示法中節點的後代且都滿足謂詞P。當不能再進行此類聚合時，這個過程終止於滿足步驟2的最後的區域聚合。在這種情況下，聚合的區域可能會大小不同。這種方法的主要優點是對於拆分和聚合都使用同樣的四叉樹，直到聚合的最後一步。

例10.17 拆分和聚合

圖10.43(a)顯示了一幅簡單的圖像。如果在區域Ri內至少有80％的像素具有zj-mi≦2σi的性質，就定義P(Ri)=TRUE，這裡zj是Ri內第j個像素的灰度級，mi是區域Ri的灰度級均值，σi是區域Ri內的灰度級的標准差。如果在此條件下，P(Ri)=TRUE，則設置Ri內的所有像素的值等於mi。拆分和聚合使用前速算法的要點完成。將這種技術應用於圖10.43(a)所得結果示於圖10.43(b)。請注意，圖像分割效果相當好。示於圖10.43(c)中的圖像是通過對圖10.43(a)進行門限處理得到的，門限值選在直方圖中兩個主要的尖峰之間的中點。經過門限處理，圖像中生成的陰影(和葉子的莖)被錯誤地消除了。

　

如前面的例子中所使用的屬性那樣，我們試圖使用基於區域中像素的均值和標准差的某些特性對區域的紋理進行量化(見11.3.3節中關於紋理的討論)。紋理分割的概念是以在謂詞P(Ri)中使用有關紋理的量度為基礎的。就是說，通過指定基於紋理內容的謂詞，我們可以使用本節中討論的任何方法進行紋理分割。

 

 

 

1.       把一幅圖像分成4份，計算每一份圖像的最大灰度值與最小灰度值的差， 如果差在誤差范圍值外，則該份圖像繼續分裂。

2.       對於那些不需要分裂的那些份圖像可以對其進行閾值切割了，例如某一塊圖像的最大灰度大於某個值，則該塊圖像變成255，否則變為0。

 

// 代碼

// 區域分裂合並的圖像分割

// nOffSetLne是行偏移量

 

// 由於分裂的層數太多了, 使用遞歸將使內存空間堆棧溢出

// 解決方法是使用一個堆棧對要分裂的塊入棧

// 使用堆棧的方法類似在"區域生長"的實現方法

#include <stack>

struct SplitStruct

{

     unsigned int nWidth;                 // 這一塊圖像的寬度

     unsigned int nHeigh;                 // 這一塊圖像的高度

     unsigned int nOffSetWidth;           // 相對源圖像數據的偏移寬度

     unsigned int nOffSetHeigh;           // 相對源圖像數據的偏移高度

};

void AreaSplitCombineEx(BYTE* image0,              // 源圖像數據

                         unsigned int nAllWidth,        // 源圖像的寬度

                         unsigned int nAllHeigh,        // 源圖像的高度

                         unsigned int w,                // 這一塊圖像的寬度

                         unsigned int h,                // 這一塊圖像的高度

                         unsigned int nOffSetWidth,     // 相對源圖像數據的偏移寬度

                         unsigned int nOffSetHeigh)     // 相對源圖像數據的偏移高度

{

 

     std::stack<SplitStruct> nMyStack;

 

     SplitStruct splitStruct, splitStructTemp;

     splitStruct.nWidth          = w;

     splitStruct.nHeigh          = h;

     splitStruct.nOffSetWidth    = nOffSetWidth;

     splitStruct.nOffSetHeigh    = nOffSetHeigh;

 

     nMyStack.push(splitStruct);

    

     int i, j;

     int nValueS[2][2];     // 用於存儲塊圖像的屬性值(該屬性值= 該塊圖像的所有像素灰度值之和除以該塊圖像所有像素點的數量)

     int nAV;

     int nWidthTemp[3], nHeightTemp[3], nTemp;

     int nWidth, nHeigh;

     int n, m, l;

     double dOver;

 

 

     while(!nMyStack.empty())

     {

         splitStruct = nMyStack.top();

         nMyStack.pop();

 

 

         n = (splitStruct.nOffSetHeigh * nAllWidth + splitStruct.nOffSetWidth);     // 該塊圖像的左上角

         // 1. 把圖像分成2 * 2 塊,

         nWidthTemp[0] = 0;

         nWidthTemp[2] = (splitStruct.nWidth + 1) / 2;

         nWidthTemp[1] = splitStruct.nWidth - nWidthTemp[2];

 

         nHeightTemp[0] = 0;

         nHeightTemp[2] = (splitStruct.nHeigh + 1) / 2;

         nHeightTemp[1] = splitStruct.nHeigh - nHeightTemp[2];

 

         // 計算每一塊圖像的屬性值

         int nValue;

         int nValueTemp;

         nAV = 0;

         for(i = 1; i < 3; ++i)

         {

              for(j = 1; j < 3; ++j)

              {

                   nValue = 0;

                   m = (n + nAllWidth * nHeightTemp[i - 1] + nWidthTemp[j - 1]);

                   for(nHeigh = 0; nHeigh < nHeightTemp[i]; ++nHeigh)

                   {

                       for(nWidth = 0; nWidth < nWidthTemp[j]; ++nWidth)

                       {

                            l = (m + nAllWidth * nHeigh + nWidth) * 4;

                            nValueTemp = (0.299 * image0[l] + 0.587 * image0[l + 1] + 0.114 * image0[l + 2]);

                            // 灰度值之和

                            nValue += nValueTemp;

                       }

                   }

 

                   if(nHeightTemp[i] * nWidthTemp[j] == 0)

                   {

                       continue;

                   }

                   if(nHeightTemp[i] * nWidthTemp[j] == 1)

                   {

                       l = m * 4;

                       if((0.299 * image0[l] + 0.587 * image0[l + 1] + 0.114 * image0[l + 2]) < 125)

// 這個值可以動態設定

                       {

                            image0[l] = image0[l + 1] = image0[l + 2] = 0;

                            image0[l + 3] = 255;

                       }

                       else

                       {

                            image0[l] = image0[l + 1] = image0[l + 2] = 255;

                            image0[l + 3] = 255;

                       }

                       continue;

                   }

 

                   // 各塊圖像的灰度平均值(每一塊圖像的屬性值)

                   nValueS[i - 1][j - 1] = nValue / (nHeightTemp[i] * nWidthTemp[j]);

                   // 2. 對每一塊進行判斷是否繼續分裂(注意分裂的原則)

                   // 我這裡的分裂原則是: 圖像的屬性值在屬性值平均值的誤差范圍之內就不分裂

                   if(nValueS[i - 1][j - 1]  < 220)     // 灰度平均值少於200 需要繼續分裂 // 這裡就是分裂准則了

                   {

                       splitStructTemp.nWidth           = nWidthTemp[j];

                       splitStructTemp.nHeigh           = nHeightTemp[i];

                       splitStructTemp.nOffSetWidth     = splitStruct.nOffSetWidth + nWidthTemp[j - 1];

                       splitStructTemp.nOffSetHeigh     = splitStruct.nOffSetHeigh + nHeightTemp[i - 1];

                       nMyStack.push(splitStructTemp);

                   }

                   else                                      // 合並(直接填充該塊圖像為黑色)

                   {

                       // 3. 如果不需要分裂, 則進行合並

                       for(nHeigh = 0; nHeigh < nHeightTemp[i]; ++nHeigh)

                       {

                            for(nWidth = 0; nWidth < nWidthTemp[j]; ++nWidth)

                            {

                                 l = (m + nAllWidth * nHeigh + nWidth) * 4;

                                 image0[l] = image0[l + 1] = image0[l + 2] = 255;

                                 image0[l + 3] = 255;

                            }

                       }

                   }

              }

         }

     }

 

     return;

}

 

該代碼的效果也不是太好，主要是分裂准則不好確定

 

區域分裂合並中 最初使用每塊圖像區域中極大與極小灰度值之差是否在允許的偏差范圍來作為均勻性測試准則。 後來均勻性測試准則又被不斷的發展。目前，統計檢驗，如均方誤差最小， F檢測等都是最常用的均勻性測試准側方法。

 

看均方誤差最小的情況

 

 

其中C是區域R中N個點的平均值。

 

相對於區域生長而言，區域分割於合並技術不再依賴於種子點的選擇與生長順序。但選用合適的均勻性測試准則P對於提高圖像分割質量十分重要，當均勻性測試准則P選擇不當時，很容易會引起「方塊效應」

Iam_Rocky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
基于区域的图像分割-----------区域分裂合并
cay22的专栏
06-12 1万+
基于区域的图像分割-----------区域分裂合并
split-merge图像分割与合并程序
06-18
split-merge程序的c++版本。显示了分裂过程和结果。加载和显示图片，显示分裂过程，用到了opencv3.1的库。核心算法全部用c++编写。个人根据书中的思路编写，求轻喷。
区域分裂合并
06-03
实现了图像处理中常见的一个算法，区域分裂合并
区域分裂合并法
03-22
本程序属于图像分割技术中区域分割的区域分裂合并法，具有良好的分割效果
【Opencv】图像分割——区域分裂合并
weixin_53598445的博客
03-28 1万+
文章目录1 环境2 效果3 原理4 代码 1 环境 Python 3.8.8 PyCharm 2021 opencv-python 2 效果 3 原理   区域生长是从某个或者某些像素点出发，最后得到整个区域，进而实现目标提取。分裂合并差不多是区域生长的逆过程：从整个图像出发，不断分裂得到各个子区域，然后再把前景区域合并，实现目标提取。分裂合并的假设是对于一幅图像，前景区域由一些相互连通的像素组成的，因此，如果把一幅图像分裂到像素级，那么就可以判定该像素是否为前景像素。当所有像素点或者子区域完成判断以
matlab练习程序（图像区域分裂）
weixin_34357267的博客
01-11 1920
图像区域分裂可以将图像中相似的区域归为一个子区域，否则这个区域分裂。 分裂的步骤还是很好理解的。 对一个图像而言，首先确定一个分裂准则，如果当前图像区域中有像素没有满足这个准则，那么本区域继续分裂，否则分裂停止。 我这里用的准则就是当前像素灰度是否和本区域平均灰度差距过大，如果相差很大则继续分裂，否则分裂停止并将本区域赋值为本区域平均值。 分裂具体步骤： 1.输入图像作为初始区域。 2...
基于区域的分裂合并图像分割方法
10-27
基于区域的分裂合并算法是一种常用的图像分割方法，它依据像素之间的相似性来进行区域的形成、分裂和合并。这种方法通常包括两个核心步骤：分裂（split）和合并（merge），其主要思想是根据特定的准则来判断相邻像素...
R-Tree空间索引算法的研究历程和最新进展分析
最新发布
09-20
因此，许多变种R-Tree应运而生，如R*Tree、X-Tree、QUADtree等，它们通过不同的策略改进了原始R-Tree的分裂和合并过程，以减少重叠区域，提高查询速度。 近年来，R-Tree的研究继续深化，关注点包括更高效的分裂和...
4-聚类算法.7z4-聚类算法.7z
07-03
这种技术广泛应用于市场分割、图像分析、生物信息学、社交网络分析等多个领域。聚类算法并不依赖于预先定义好的类别，而是通过计算数据点之间的距离或相似度来自动形成簇。 常见的聚类算法有以下几种： 1. K-Means...
区域分裂-合并算法程序
05-05
用c++实现了数字图像处理中的区域分裂-合并算法，并在图像上验证了算法的正确性，能用。
基于区域分裂合并技术的图像分割
06-26
包含毕业论文的所有文档，包含源码，基于j2se
图像分裂合并的matlab实现.
05-15
基本MATLAB写成的图像分裂合并法，有部分注释，比较强大
区域分裂与聚合代码
05-04
冈萨雷斯数字图像处理 中的例题 区域分裂与聚合，全部代码，包括子程序
阈值法、区域增长法、分裂合并法和K均值法分割图像
05-10
使用阈值法、区域增长法、分裂合并法和K均值法分割图像的实例。
Splitting and Merging--区域分裂与合并算法
weixin_30823001的博客
07-23 1016
https://nezha.github.io/%E8%AF%BE%E7%A8%8B%E7%A0%94%E7%A9%B6/2015-12-6-region_split_merging/ 转载于:https://www.cnblogs.com/guochen/p/11231747.html
区域生长与分裂合并
御坂御坂001的博客
01-11 1万+
文章目录1.区域生长2.区域分裂与合并 图像分割就是把图像分成若干特定的、具有独特性质的区域并提取出感兴趣目标的技术和过程，它是图像处理到图像分析的关键步骤。区域生长需要选择一组能正确代表所需区域的种子像素，确定在生长过程中的相似性准则，制定让生长停止的条件或准则。相似性准则可以是灰度级、彩色、纹理、梯度等特性。选取的种子像素可以是单个像素，也可以是包含若干像素的小区域。大部分区域生长准则使用图像...
图像分割-区域分裂合并算法
蜗壳X儿
08-14 1万+
原文：https://www.jianshu.com/p/fa573431ef3d 区域分裂合并法：区域分裂合并法是一种图像分割算法。 它与区域生长法略有相似之处，但无需预先指定种子点，而是按某种一致性准则分裂或者合并区域。 分裂合并法对分割复杂的场景图像比较有效。 算法的思想并不复杂，总的来说，就是先把图像分成4块，若这其中的一块符合分裂条件，那么这一块又分裂成4块，就这样一直分裂。分裂到一定数量时，以每块为中心，检查相邻的各块，满足一定条件，就合并。 如此循环往复进行分裂和合并的操作。 最后合并小区，即
数字图像处理(七) 图像分割
热门推荐
小小何先生的学习之旅
11-23 1万+
本文首发于公众微信号-AI研究订阅号。   本节主要目的是介绍图像分割的一些基本概念。来源于东北大学 魏颖教授的模式识别课程笔记。 本节重点：1）图像分割的基本概念及图像分割分类的基础；2）边缘分割法；3）阈值分割法；4）区域分割法。 图像分割概述   人类视觉在观察和分析一幅图像时，总是首先将注意力集中在图像中的感兴趣的物体或区域，即将其从其他景物中分离开来，然后对其进行特征分析，再根据...
基于PIE-engine的isodata算法代码
05-30
由于基于PIE-engine的ISODATA算法需要结合具体的图像分割任务进行实现，因此无法提供通用的代码。不过，以下是一个基于Python的ISODATA算法实现示例，你可以根据具体需求进行修改和优化。 ```python import numpy as np def isodata_segmentation(image, K, min_size, max_iterations): # 对图像进行初步分割，得到初步区域 regions = pie_engine_segmentation(image) # 对每个区域进行像素点的采样，得到每个区域的样本数据 samples = [] for region in regions: mask = region.mask samples.append(image[mask]) # 初始化类别中心和方差 centers = np.zeros((K, image.shape[-1])) variances = np.zeros((K, image.shape[-1])) for k in range(K): centers[k] = np.mean(samples[k], axis=0) variances[k] = np.var(samples[k], axis=0) + 1e-10 # 迭代优化 for i in range(max_iterations): # 对样本数据进行分类，得到类别标签 labels = np.zeros(len(samples), dtype=int) for j, sample in enumerate(samples): distances = np.linalg.norm(sample - centers, axis=1) labels[j] = np.argmin(distances) # 计算每个类别的均值和方差 for k in range(K): mask = (labels == k) if np.sum(mask) > 0: centers[k] = np.mean(samples[mask], axis=0) variances[k] = np.var(samples[mask], axis=0) + 1e-10 # 合并方差较小的类别 merge_indices = [] for k in range(K): for l in range(K): if k != l and np.linalg.norm(centers[k] - centers[l]) < np.sqrt(variances[k] + variances[l]): merge_indices.append((k, l)) for indices in merge_indices: k, l = indices mask = (labels == l) centers[k] = (centers[k] * np.sum(labels == k) + np.mean(samples[mask], axis=0) * np.sum(mask)) / (np.sum(labels == k) + np.sum(mask)) variances[k] = (variances[k] * np.sum(labels == k) + np.var(samples[mask], axis=0) * np.sum(mask)) / (np.sum(labels == k) + np.sum(mask)) + 1e-10 centers = np.delete(centers, l, axis=0) variances = np.delete(variances, l, axis=0) labels[labels == l] = k # 分裂方差较大的类别 split_indices = [] for k in range(K): if np.max(variances[k]) > 0.5 * np.mean(variances): split_indices.append(k) for k in split_indices: new_center = centers[k] + np.random.normal(scale=np.sqrt(variances[k]), size=(1, image.shape[-1])) new_center = np.clip(new_center, 0, 255) centers[k] = (centers[k] + new_center) / 2 new_variance = np.var(samples[labels == k], axis=0) + 1e-10 variances[k] = (variances[k] + new_variance) / 2 new_center = centers[k] + np.random.normal(scale=np.sqrt(variances[k]), size=(1, image.shape[-1])) new_center = np.clip(new_center, 0, 255) centers = np.vstack((centers, new_center)) variances = np.vstack((variances, new_variance)) # 如果类别数量过多或过少，则重新初始化 if len(centers) > K * 2 or len(centers) < K: centers = np.zeros((K, image.shape[-1])) variances = np.zeros((K, image.shape[-1])) for k in range(K): centers[k] = np.mean(samples[k], axis=0) variances[k] = np.var(samples[k], axis=0) + 1e-10 # 如果每个类别的样本数量小于最小值，则合并到最近的类别中 for k in range(K): if np.sum(labels == k) < min_size: distances = np.linalg.norm(centers - centers[k], axis=1) distances[k] = np.inf nearest_index = np.argmin(distances) mask = (labels == k) centers[nearest_index] = (centers[nearest_index] * np.sum(labels == nearest_index) + centers[k] * np.sum(mask)) / (np.sum(labels == nearest_index) + np.sum(mask)) variances[nearest_index] = (variances[nearest_index] * np.sum(labels == nearest_index) + variances[k] * np.sum(mask)) / (np.sum(labels == nearest_index) + np.sum(mask)) + 1e-10 centers = np.delete(centers, k, axis=0) variances = np.delete(variances, k, axis=0) labels[labels == k] = nearest_index # 根据类别标签重新进行分割，得到最终结果 segmentation = np.zeros(image.shape[:2], dtype=int) for j, region in enumerate(regions): segmentation[region.mask] = labels[j] return segmentation ``` 需要注意的是，上述代码中用到的`pie_engine_segmentation`函数需要根据具体情况进行实现和调整。该函数的作用是对图像进行初步分割，得到初步的区域。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值