二值图像连通标记矩阵计算

最新推荐文章于 2022-09-26 11:12:32 发布
最新推荐文章于 2022-09-26 11:12:32 发布
阅读量1.7k 收藏
点赞数
分类专栏： 图形学 文章标签： struct matlab null include list python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujb861213/article/details/7365442
版权
  
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <windows.h>

HANDLE hOut, hIn; /*标准输出输入句柄*/
COORD size = {200, 1000}; /*窗口大小*/
SMALL_RECT rc = {0, 0, 200-1, 50-1};
CONSOLE_CURSOR_INFO cursor = {1, FALSE}; /*光标信息，用于隐藏光标*/

typedef struct{
	unsigned short sc;
	unsigned short ec;
	unsigned short r;
	int label;
}RunNode_t;

typedef struct equivnode 
{
	int LabelA;
	int LabelB;
	struct equivnode *next;
}EquivNode;

typedef struct equivlist 
{
	EquivNode *head;
	int length;
}EquivList;

typedef struct MapListNode_tag
{
	int idx;
	struct MapListNode_tag* pNext;
}MapListNode_t;

typedef struct MapListList_tag
{
	MapListNode_t* pMapNodeList;
	struct MapListList_tag* pNext;
}MapListListNode_t;

typedef struct  
{
	int mode ; 
	int minarea ; 
	int minpixDiff;
}SparseInfoExtractCondition_t;

void DeleteEquivListHeadNode(EquivList *list) 
{
	EquivNode *killNode;
	if (list->head != NULL) 
	{
		killNode = list->head;
		list->head = killNode->next;
		free(killNode);
		list->length--;
	}
}

void DestroyEquivList(EquivList *list) 
{
	while (list->head != NULL)
	{
		EquivNode *killNode = list->head;
		list->head = killNode->next;
		free(killNode);
		list->length--;
	}
}

void UpdateRunNode(int *pTable , RunNode_t* pNode, int NodeNum)
{
	int i;
	for(i = 0 ; i < NodeNum ; i++)
	{
		pNode[i].label = pTable[pNode[i].label-1];
	}
}

void BWCreateRunNodeInfoEx(int* BW , int M ,int N ,
						   SparseInfoExtractCondition_t* pCondtion,
						   RunNode_t** ppRunNode, int *pRunNodeNum,
						   int* plabels, EquivList** ppEquivList)
{
	int *pr = NULL;
	int numRuns = 0;
	RunNode_t* pNode = NULL;
	int offset ;
	int i ,j ,k ,p;  
	int currentRow = -1;
	int nextLabel = 1;
	int firstRunOnPreviousRow = -1;
	int lastRunOnPreviousRow = -1;
	int firstRunOnThisRow = -1;
	EquivList* pEquivList = (EquivList*)malloc(sizeof(EquivList));

	int Mode = pCondtion->mode;
	int MinArea = pCondtion->minarea;
	int MinpixDiff = pCondtion->minpixDiff;

	//(1)Computer numRuns
	for (i = 0; i < N; i++)   //按行遍历
	{
		pr = &BW[i*M] ;    //第row行的头指针

		if (pr[0] != 0)
			numRuns++;        //本行的第一个元素就是一个Run的头 Run的数目+1

		for (j = 1; j < M; j++) {
			if ((pr[j] != 0) && (pr[j-1] == 0))   //01的模式就是Run
				numRuns++;                        //Run的总数+1
		}
	}
	*pRunNodeNum = numRuns;

	//(2) 生成 RunNode信息
	pNode = (RunNode_t*)malloc(numRuns*sizeof(RunNode_t));
	k = 0;
	for (i = 0; i < N; i++) 
	{
		pr = &BW[i*M]; 	//第row行的头指针

		j = 0;
		while (j < M) 
		{	  
			//遍历该行
			while (j < M && pr[j] == 0)
				j++; 						//找到第一个Run所在的行号

			if ((j < M) && (pr[j] != 0)) 
			{
				pNode[k].r = i ;	   //
				pNode[k].sc = j ;
				while (j < M && pr[j] )	 //走完这个Run
					j++;
				pNode[k].ec = j-1;	//这个是结尾
				pNode[k].label = 0;
				k++;		  //处理下一个Run
			}
		}
	}

	//(3)扫描标记 ,并统计Label 关系的
	printf("\n\n");
	printf("(2)打印等价关系对\n");
	pEquivList->head = NULL;
	pEquivList->length = 0;
	offset = 1;  //八邻域为1  ,四邻域为0
	for (k = 0; k < numRuns; k++) 
	{
		if (pNode[k].r == currentRow + 1) 
		{	
			//第k个Run与第k-1个Run在相邻的两行上
			firstRunOnPreviousRow = firstRunOnThisRow;	 //firstRunOnPreviousColumn指向第k-1个Run所在的列的第一个（最上面的）Run
			firstRunOnThisRow = k;
			lastRunOnPreviousRow = k-1;
			currentRow = pNode[k].r;
		}
		else if (pNode[k].r > (currentRow + 1)) 
		{
			/* 开始新列:前一列没有Run  直接进入下一轮循环*/
			firstRunOnPreviousRow = -1;
			lastRunOnPreviousRow = -1;
			firstRunOnThisRow = k;
			currentRow = pNode[k].r;
		}

		if (firstRunOnPreviousRow >= 0) 
		{
			p = firstRunOnPreviousRow;
			while (p <= lastRunOnPreviousRow && pNode[p].sc <= pNode[k].ec + offset) 
			{
				if ((pNode[k].ec >= pNode[p].sc-offset) && 
					(pNode[k].sc <= pNode[p].ec+offset)) //有交叉
				{
					if (pNode[k].label == 0) 
					{
						pNode[k].label = pNode[p].label;
					}
					else 
					{
						if (pNode[k].label != pNode[p].label) 
						{
							EquivNode *newNode = (EquivNode *)malloc(sizeof(EquivNode));
							newNode->LabelA = pNode[k].label;
							newNode->LabelB = pNode[p].label;
							newNode->next = pEquivList->head;
							pEquivList->head = newNode;
							pEquivList->length++;
							printf("%4d %4d\n" , newNode->LabelA , newNode->LabelB);
						}
					}
				}
				p++;
			}
		}

		if (pNode[k].label == 0) 
		{
			pNode[k].label = nextLabel;
			nextLabel++;
		}
	}
	*plabels =nextLabel-1;
	*ppRunNode = pNode;
	*ppEquivList = pEquivList;

	printf("\n\n(3) 打印初始RunNode信息\n");
	printf("  sc   ec    r   label \n");
	for(i=0;i<numRuns;i++)
	{
		printf("%4d ",pNode[i].sc);
		printf("%4d ",pNode[i].ec);
		printf("%4d ",pNode[i].r);
		printf("%4d ",pNode[i].label);
		printf("\n");
	}
}

void MapListAddNode(MapListNode_t* pNode , int Idx)
{
	MapListNode_t* pNodeTemp = malloc(sizeof(MapListNode_t));
	MapListNode_t* pNodeMove = pNode;
	pNodeTemp->idx = Idx;
	pNodeTemp->pNext = NULL;

	while(pNodeMove->pNext)
		pNodeMove = pNodeMove->pNext;

	pNodeMove->pNext = pNodeTemp;
}

void MapListListAddNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode)
{
	MapListListNode_t* pListListNodeMove = pListListNode;
	MapListListNode_t* pListListNodeNew = malloc(sizeof(MapListListNode_t));
	while(pListListNodeMove->pNext)
		pListListNodeMove = pListListNodeMove->pNext;

	pListListNodeNew->pMapNodeList = pListNode;
	pListListNodeNew->pNext = NULL;
	pListListNodeMove->pNext = pListListNodeNew;
}

void MapListListDeleteNode(MapListListNode_t* pListListNode ,MapListNode_t* pListNode)
{
	MapListListNode_t* pListListNodeMove = pListListNode;
	MapListListNode_t* pListListNodeKill = NULL;
	while(pListListNodeMove->pNext)
	{
		if(pListListNodeMove->pNext->pMapNodeList == pListNode)
		{
			pListListNodeKill = pListListNodeMove->pNext;
			pListListNodeMove->pNext = pListListNodeMove->pNext->pNext;
			free(pListListNodeKill); 
			break;
		}
		pListListNodeMove = pListListNodeMove->pNext;
	}

}
int MapListMinIdx(MapListNode_t* pNode)
{
	int min = 0x7FFFFFFF;
	while(pNode)
	{
		if(pNode->idx < min)
			min = pNode->idx;
		pNode = pNode->pNext;
	}
	return min;
}
MapListNode_t* MapListListFindIdx(MapListListNode_t* pMapListList ,int Idx)
{
	MapListNode_t* pMapListNodeHead = NULL;
	MapListNode_t* pMapNodeListMove = NULL;
	MapListListNode_t* pMapListListMove = pMapListList;
	while(pMapListListMove->pNext)
	{
		pMapListListMove = pMapListListMove->pNext;
		pMapListNodeHead = pMapListListMove->pMapNodeList;
		pMapNodeListMove = pMapListNodeHead;
		while(pMapNodeListMove)	
		{
			if(Idx == pMapNodeListMove->idx)
				return pMapListNodeHead;

			pMapNodeListMove = pMapNodeListMove->pNext;
		}
	}
	return NULL;
}

void MapListMerge(MapListNode_t* pMapListA , MapListNode_t* pMapListB)
{
	while(pMapListA->pNext)
		pMapListA = pMapListA->pNext;
	pMapListA->pNext = pMapListB;
}


void CreateMapTable(EquivList* pList ,int MapTableSize ,int **ppMapTable )
{
	int i,j,k;
	int labela,labelb;
	MapListNode_t* pMapNodeList = (MapListNode_t*)malloc(sizeof(MapListNode_t));
	MapListListNode_t* pMapListListNode = NULL;
	MapListListNode_t* pMapListListforMove = NULL;
	MapListNode_t* pMapListforMove = NULL ;
	int *pMapTableInit = NULL;
	pMapNodeList->idx = pList->head->LabelA;   
	pMapNodeList->pNext = NULL;
	MapListAddNode(pMapNodeList,pList->head->LabelB);

	DeleteEquivListHeadNode(pList);

	pMapListListNode = (MapListListNode_t*)malloc(sizeof(MapListListNode_t));
	pMapListListNode->pMapNodeList = NULL;
	pMapListListNode->pNext = NULL;
	MapListListAddNode(pMapListListNode,pMapNodeList);

	while(pList->length)
	{
		MapListNode_t* pMapListFindA = NULL;
		MapListNode_t* pMapListFindB = NULL;
		labela = pList->head->LabelA;
		labelb = pList->head->LabelB;
		pMapListFindA = MapListListFindIdx(pMapListListNode,labela);
		pMapListFindB = MapListListFindIdx(pMapListListNode,labelb);

		if(pMapListFindA)
		{
			if(pMapListFindB)
			{
				if (pMapListFindA!=pMapListFindB)
				{			
					MapListMerge(pMapListFindA,pMapListFindB);
					MapListListDeleteNode(pMapListListNode,pMapListFindB);
				}
			}
			else
			{
				MapListAddNode(pMapListFindA,labelb);
			}
		}
		else
		{
			if(pMapListFindB)
			{
				MapListAddNode(pMapListFindB,labela);
			}
			else
			{
				pMapNodeList = (MapListNode_t*)malloc(sizeof(MapListNode_t));
				pMapNodeList->pNext = NULL;
				pMapNodeList->idx = labela;
				MapListAddNode(pMapNodeList,labelb);
				MapListListAddNode(pMapListListNode,pMapNodeList);
			}
		}
		DeleteEquivListHeadNode(pList);
	}

	printf("\n\n(4)打印等价链表:\n");
	pMapListListforMove = pMapListListNode;
	while (pMapListListforMove->pNext)
	{
		pMapListforMove = pMapListListforMove->pNext->pMapNodeList;
		while(pMapListforMove)
		{
			printf("%4d",pMapListforMove->idx);
			pMapListforMove = pMapListforMove->pNext;
		}
		printf("\n");
		pMapListListforMove = pMapListListforMove->pNext;
	}

	pMapTableInit = (int*)malloc(MapTableSize*sizeof(int));
	printf("\n\n打印初始关系表");
	for(i = 1 ; i <= MapTableSize ; i++ )
	{
		pMapListforMove = MapListListFindIdx(pMapListListNode,i);
		if(pMapListforMove)
		{
			pMapTableInit[i-1] = MapListMinIdx(pMapListforMove);
			printf("%3d " ,pMapTableInit[i-1]);
		}
		else
		{
			pMapTableInit[i-1] = i;
			printf("%3d " ,i);
		}
	}

	printf("\n\n打印对应关系表");
	*ppMapTable = (int*)malloc(MapTableSize*sizeof(int));
	(*ppMapTable)[0] = 1;
	printf("%3d ",(*ppMapTable)[0]);
	k = 2;
	for(i = 1 ; i < MapTableSize ; i++ )
	{
		j = 0;

		while(j<i)
		{
			if(pMapTableInit[j] == pMapTableInit[i])
			{
				(*ppMapTable)[i] = (*ppMapTable)[j];
				break;
			}
			j++;
		}

		if(j == i)
			(*ppMapTable)[i] = k++;

		printf("%3d ",(*ppMapTable)[i]);
	}
}

void BWCreateRunNodeInfo(int* BW , int M ,int N ,
						 SparseInfoExtractCondition_t* pCondtion,
						 RunNode_t** ppRunNode, int *pRunNodeNum)
{
	EquivList* pEquivList = NULL;
	int *pMapTable = NULL;
	int labels = 0;
	BWCreateRunNodeInfoEx(BW ,M ,N ,pCondtion,ppRunNode, pRunNodeNum,&labels ,&pEquivList);

	if(pEquivList->length)
	{
		CreateMapTable( pEquivList, labels,&pMapTable);
		UpdateRunNode(pMapTable,*ppRunNode,*pRunNodeNum);
	}
}

void UpadateBWData(int* BW, int M ,RunNode_t* pNode , int NodeNum)
{
	int k = 0 , p = 0;
	int *pr = NULL;
	for (k = 0; k < NodeNum; k++) 
	{
		pr = &BW[pNode[k].r*M + pNode[k].sc];
		for (p = 0; p < pNode[k].ec - pNode[k].sc + 1; p++)
			*pr++ = pNode[k].label;
	}
}

#define M 40
#define N 30

int main() 
{
	int i = 0, j = 0;
	RunNode_t* pRunNode = NULL;
	int RunNum = 0;
	SparseInfoExtractCondition_t ExtractCondition;
	int BW[N][M];

	hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleWindowInfo(hOut, TRUE, &rc);
	SetConsoleScreenBufferSize(hOut, size);
	SetConsoleCursorInfo(hOut, &cursor);


	srand( (unsigned)time( NULL ) );
	printf("(1) 打印实验矩阵\n");
	for(i = 0; i< N ;i++)
	{
		for( j =0 ;j < M;j++ )
		{
			if(j == 0)
				printf("\n");

			BW[i][j] = (rand()%100)<40;
			printf("%3d ",BW[i][j]);
		}
	}

	ExtractCondition.minarea = 10;
	ExtractCondition.minpixDiff = 10;
	ExtractCondition.mode = 1;
	BWCreateRunNodeInfo((int*)BW ,M ,N ,&ExtractCondition,&pRunNode, &RunNum);

	printf("\n\n");
	printf("(5) 打印最后RunNode信息\n");
	printf("  sc  ec   r   label\n");
	for(i=0;i<RunNum;i++)
	{
		printf("%4d ",pRunNode[i].sc);
		printf("%4d ",pRunNode[i].ec);
		printf("%4d ",pRunNode[i].r);
		printf("%4d ",pRunNode[i].label);
		printf("\n");
	}

	//(4)根据统计表建立，影射关系表
	UpadateBWData((int*)BW,M,pRunNode,RunNum);


	//打印矩阵
	printf("\n(6) 生成最后的连通标记矩阵");
	for(i = 0; i< N ;i++)
	{
		for( j =0 ;j<M;j++ )
		{
			if(j == 0)
				printf("\n");
			printf("%3d ",BW[i][j]);
		}
	}
	printf("\n");
}


参考资料:

(1) 稀疏信息提取:读Matlab7.7 IPT的bwlabel函数（一）——bwlabel1的Python描述  http://blog.sina.com.cn/s/blog_4513dde60100o6oz.html 

(2) MATLAB 使用的bwlabel1.c    http://code.google.com/p/mirone/source/browse/trunk/mex/bwlabel1.c?spec=svn1874&r=1874

(3) 连通关系合并 http://blog.csdn.net/caiqi1123/article/details/7101168

 

liujb861213
关注
专栏目录
二值图像连通区域标记matlab,二值图像快速连通区域计算方法与流程
weixin_39609354的博客
03-19 574
本发明涉及图像处理技术领域，具体涉及一种二值图像快速连通区域计算方法。背景技术：连通分量标记(或者称连通分量分析，连通区域标记)是图论应用中的一种算法，给二值图像中的每个连通区域标上一个特定的标号。该算法可用来对图像的目标进行定位和计数。连通分量标记通常在计算机视觉领域中对二值图像的连通区域进行检测，也可以处理彩色图像和更高维的数据。当将其集成到图像识别系统或者是人机交互系统是，该算法也起到重要作...
python 连通区域_二值图像连通区域标记
weixin_39849800的博客
12-05 2163
原像素矩阵M为：根据原像素矩阵M大小，初始化标记矩阵labelM：算法流程1. 首先要确定是标记8邻域连通还是4邻域连通，如果是8邻域连通，就用模板1，如果是4邻域连通，就用模板2。中间像素记为目标像素，模版其余像素记为包围像素。 (1) (2)2. 若原像素矩阵M中，包围像素均为0，则labelM中目标像素标记号+1；如果不全为0，则l...
基于游程链的连通区域标记的图像连通域（blob）C++实现
01-21
实现基于游程链的连通区域标记的图像连通域(Blob)算法，运算速度还可以，实现原理跟opencv的连通域实现方法不一样。
【图像处理】二值图像连通区域标记中等价对的合并
学无止境
08-25 1517
近来，在进行数字图像处理练习过程中，遇到连通区域标记的问题，网上有很多相关算法的讲解，我参考的是这篇文章，根据作者的讲解，可以很轻易地实现连通域的标记。本人在进行基于行程的标记处理中第三步——”等价对的合并”时编写简单程序实现。希望能对诸君有所参考。其中equivalences存放所有等价对，overlap存放所有合并后的结果。void MergeRuns(vector<pair<int,int>>
通过连通矩阵来研究图的连通性
10-01
这一个关于图的联通性研究的题目 里面有课程设计的论文和说明书
二值图像分析笔记（1）—— 图像二值化
一角残叶的博客
07-22 2474
1 二值图像 像素矩阵只包含0和1； 0：黑色 1：白色 1.1 RGB彩色图像到二值图像的转换 彩色图像到灰度图像的转换 灰度图像到二值图像 1.2 常见的图像二值化方法 基于均值-统计学原理 迭代法 Otus 法（最好用的） 直方图法 1.3 基于均值-统计学原理 计算灰度图像的像素均值 m,以 m 作为阈值把图像分成二值图像，对任意一个像素点的灰度值x x > m ? x...
C语言版二值图像统计连通区域
08-28
C语言版二值图像统计连通区域 一、引言 在图像处理领域中，二值图像统计连通区域是一种常用的图像处理算法。该算法的主要目的是将二值图像中的连通区域进行标记和统计，以便于后续的图像处理和分析。本文将详细...
二值图像连通区域的标记,二值图像分支点连接数,matlab源码.zip
10-15
一、二值图像连通区域的标记 1. 连通组件：在二值图像中，如果两个白像素通过一串相邻的白像素相连，则它们属于同一个连通区域。连通组件分析是寻找并标记这些区域的过程，用于识别图像中的独立对象。 2. 标记...
二值图像数字矩阵的距离变换（python+opencv)
一只在cv道路上爬行的小乌龟~
05-23 1373
代码链接：数字图像处理距离变换实现（python+opencv) 实验要求： 1，自定义64乘64二值图，随机生成图案（像素随机置成0，1，其中1像素的数量为100个） 2，按照某种距离度量，D4或D8（这里计算的是D4，即城市街区距离） 3，根据二值图，计算64*64的距离矩阵，如图 数字图像处理中三种常见的距离 距离变换原理： 在实际处理中我们要将输入图像中1全部转为0，输入矩阵中的0转为一个比较大的值，如下图： 然后利用两个掩膜进行扫描，参考数字图像的距离变换算法 最终得到的更新后的数组即为距
matlab数字图像处理——图像的读写，灰度、二值图像
fffmvp的博客
09-26 5395
利用imread读入trees_gray.jpg，利用size函数得到图像数据矩阵维度，利用imresize将图像缩小原来的一半，显示缩小后的图像，将此缩小后图像存储成为trees_small.jpg文件。利用imread读入trees_gray.jpg，利用im2bw将灰度图像转换二值图像（阈值自行设定），显示二值图像，将此二值图像存储成为trees_bw.jpg文件。对比二值图像和灰度图像的数据矩阵差别：二值图像数据矩阵元素只由0和1构成。（5）在保证将图像的长宽比不变的情况下，将图像缩小。
python---图片转二值矩阵
qwer492915298的博客
03-19 1万+
一，如果想获取图片的数据，我们就需要获取 读入图片数据----》转为灰色图片（如果不转的话，转二维时就会出现数据比较大的元素，因为颜色多变）---》 转二维数组-----》转二值矩阵（0或1） im.shape--返回行与列，例如（10,3），10行3列，shape[0]=10 , shape[1]=3 ''' Created on 2019年3月19日 转图片的灰度 数据灰度值都...
matlab中二值图像、灰度图像、彩色图像、索引图像都是几维矩阵，区别是什么？
zhb123GGGGGG的专栏
04-30 1万+
文章出处：http://zhidao.baidu.com/question/530453986.html?qbl=relate_question_3&word=matlab%D6%D0%C8%E7%BA%CE%C5%D0%B6%CF%D2%BB%B8%F6%CD%BC%CF%F1%CA%C7%BB%D2%B6%C8%CD%BC%CF%F1%B2%CA%C9%AB%CD%BC%CF%F1&optim
【数字图像处理】第8章 二值图像分析
小羊咩咩的博客
05-21 6116
8 二值图像分析 目录（一）二值图像分析基本概念（二）二值图像分析方法1）贴标签2）腐蚀3）膨胀4）开运算与闭运算 问题的提出 经过图像分割之后，获得了目标物与非目标物两种不同的对象。但是提取出的目标物存在以下的问题： 1）提取的目标中存在伪目标物； 2）多个目标物中，存在粘连或者是断裂； 3）多个目标物存在形态的不同。 （一）二值图像分析基本概念 二值图像分析的目的 二值图像的分析首先是区分所提取出的不同的目标物，之后，对不同的目标物特征差异进行描述与计算，最后获得所需要的分析结果。 二值图像分析的基.
Matlab中bwlabel函数的使用
热门推荐
万人往的专栏
05-06 12万+
用法： L = bwlabel(BW,n) 返回一个和BW大小相同的L矩阵，包含了标记了BW中每个连通区域的类别标签，这些标签的值为1、2、num（连通区域的个数）。n的值为4或8，表示是按4连通寻找区域，还是8连通寻找，默认为8。 四连通或八连通是图像处理里的基本感念：而8连通，是说一个像素，如果和其他像素在上、下、左、右、左上角、左下角、右上角或右下角连接着，则认为他们是联通的；
图像算法-二值图像 目标标记 连通区域
ch190029975的博客
09-19 3608
图像分割是图像领域的重点和难点，边缘检测是图像分割时常用的算法，下面介绍边缘检测领域常用的算子。
给定0-1矩阵求连通域
xunan003的博客
05-06 6791
图像处理题目：注意，一下所有需要写代码的题目，不允许使用OpenCV的Mat类。如果图片内容需要用指针读取。1 . 给定0-1矩阵，求连通域。（遇到过N次，笔试面试都有，最好做到能徒手hack代码或者伪代码。）    二值图像分析最重要的方法就是连通区域标记，它是所有二值图像分析的基础，它通过对二值图像中白色像素（目标）的标记，让每个单独的连通区域形成一个被标识的块，进一步的我们就可以获取这些块的...
图像就是矩阵
saltriver的专栏
12-23 3万+
学过线性代数的对矩阵并不陌生。一般来说，图像是一个标准的矩形，有着宽度（width）和高度（height）。而矩阵有着行（row）和列（column），矩阵的操作在数学和计算机中的处理都很常见且成熟，于是很自然的就把图像作为一个矩阵，把对图像的操作转换成对矩阵的操作，实际上所有的图像处理工具都是这么做的。我们看看下面这张图像：用opencv读取：import cv2 mountain = cv2.i
matlab获得二值图像平均面积
最新发布
10-08
2. 然后，使用bwlabel函数对二值图像进行标记，将连通的区域标记为不同的整数。这将生成一个标记矩阵。 3. 接下来，使用regionprops函数计算每个区域的属性，包括面积。该函数将返回一个结构体数组，其中每个元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值