使用灰度共生矩阵实现指纹分割

最新推荐文章于 2024-08-18 09:00:00 发布
最新推荐文章于 2024-08-18 09:00:00 发布
阅读量5.3k 收藏 14
点赞数
分类专栏： 图像处理 opencv 算法 文章标签： Biometric 指纹分割 灰度公共矩阵 opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/computerme/article/details/40269357
版权
图像处理 同时被 3 个专栏收录
25 篇文章 1 订阅
订阅专栏
opencv
22 篇文章 3 订阅
订阅专栏
算法
22 篇文章 4 订阅
订阅专栏

     灰度共生矩阵，Gray Level Co-occurrence Matrix,简写为GLCM

     由于纹理是由灰度分布在空间位置上反复出现而形成的，因而在图像空间中相隔某距离的两象素之间会存在一定的灰度关系，即图像中灰度的空间相关特性。灰度共生矩阵就是一种通过研究灰度的空间相关特性来描述纹理的常用方法。

     取图像(N×N)中任意一点 （x，y）及偏离它的另一点 （x+a，y+b），设该点对的灰度值为 （g1，g2）。令点（x，y） 在整个画面上移动，则会得到各种 （g1，g2）值，设灰度值的级数为 k，则（g1，g2） 的组合共有 k 的平方种。对于整个画面，统计出每一种 （g1，g2）值出现的次数，然后排列成一个方阵，再用（g1，g2） 出现的总次数将它们归一化为出现的概率P（g1，g2） ，这样的方阵称为灰度共生矩阵。

  关于灰度共生矩阵的详细描述，请参考我的另一篇博文：http://blog.csdn.net/computerme/article/details/39805257

   本文主要是采用灰度共生矩阵来实现指纹的分割，所谓的指纹分割就是把有指纹的区域从图像中提取出来。下图是的我代码的流程图


源代码如下

#include <iostream>
#include "highgui.h"
#include "cv.h"


#define GLCM_DIS 2  //灰度共生矩阵的统计距离
#define GLCM_CLASS 8 //计算灰度共生矩阵的图像灰度值等级化
#define GLCM_ANGLE_HORIZATION    0   //水平
#define GLCM_ANGLE_VERTICAL      1	 //垂直
#define GLCM_ANGLE_DIGONAL_45    2   //45度对角
#define GLCM_ANGLE_DIGONAL_135   3   //135度对角
int threshold = 15;
#pragma region calGLCM

int  GetMax(CvMat* bWavelet,int& max_value,int& min_value)
{
	int i,j;
	int width,height;
	int max = 0;
	int min = 0;
	width = bWavelet->width;
	height = bWavelet->height;
	for (i = 0;i<height;i++ )
	{
		for(j = 0;j<width;j++)
		{
			if (CV_MAT_ELEM(*bWavelet,float,i,j)> max)
				max = CV_MAT_ELEM(*bWavelet,float,i,j);
			if(CV_MAT_ELEM(*bWavelet,float,i,j) < min)
				min = CV_MAT_ELEM(*bWavelet,float,i,j);

		}
	}
	max_value = max;
	min_value = min;
	return 1;

}
int calGLCM(CvMat* bWavelet,int angleDirection,double* featureVector)
{

	int i,j;
	int width,height;
	int min,max;

	if(NULL == bWavelet)
		return 1;

	width = bWavelet->width;
	height = bWavelet->height;

	int * glcm = new int[GLCM_CLASS * GLCM_CLASS];
	int * histImage = new int[width * height];

	if(NULL == glcm || NULL == histImage)
		return 2;

	//灰度等级化---分GLCM_CLASS个等级
	//uchar *data =(uchar*) bWavelet->imageData;


	//GetMax(bWavelet,max,min);
	//printf("max = %d,min = %d ",max,min);
	//system("pause");
	int relative_value = 0;
	for(i = 0;i < height;i++){
		for(j = 0;j < width;j++){
			histImage[i * width + j] = (int)(CV_MAT_ELEM(*bWavelet,float,i,j) * GLCM_CLASS / 256);
			//relative_value = CV_MAT_ELEM(*bWavelet,float,i,j) - min;
			//histImage[i * width + j] = (int)(relative_value * GLCM_CLASS / (max-min+1));
			//printf("%d ",histImage[i * width + j]);
		}
	}

	//初始化共生矩阵
	for (i = 0;i < GLCM_CLASS;i++)
		for (j = 0;j < GLCM_CLASS;j++)
			glcm[i * GLCM_CLASS + j] = 0;

	//计算灰度共生矩阵
	int w,k,l;
	//水平方向
	if(angleDirection == GLCM_ANGLE_HORIZATION)
	{
		for (i = 0;i < height;i++)
		{
			for (j = 0;j < width;j++)
			{
				l = histImage[i * width + j];
				if(j + GLCM_DIS >= 0 && j + GLCM_DIS < width)
				{
					k = histImage[i * width + j + GLCM_DIS];
					glcm[l * GLCM_CLASS + k]++;
				}
				if(j - GLCM_DIS >= 0 && j - GLCM_DIS < width)
				{
					k = histImage[i * width + j - GLCM_DIS];
					glcm[l * GLCM_CLASS + k]++;
				}
			}
		}
	}
	//垂直方向
	else if(angleDirection == GLCM_ANGLE_VERTICAL)
	{
		for (i = 0;i < height;i++)
		{
			for (j = 0;j < width;j++)
			{
				l = histImage[i * width + j];
				if(i + GLCM_DIS >= 0 && i + GLCM_DIS < height) 
				{
					k = histImage[(i + GLCM_DIS) * width + j];
					glcm[l * GLCM_CLASS + k]++;
				}
				if(i - GLCM_DIS >= 0 && i - GLCM_DIS < height) 
				{
					k = histImage[(i - GLCM_DIS) * width + j];
					glcm[l * GLCM_CLASS + k]++;
				}
			}
		}
	}
	//135度对角方向
	else if(angleDirection == GLCM_ANGLE_DIGONAL_135)
	{
		for (i = 0;i < height;i++)
		{
			for (j = 0;j < width;j++)
			{
				l = histImage[i * width + j];

				if(j + GLCM_DIS >= 0 && j + GLCM_DIS < width && i + GLCM_DIS >= 0 && i + GLCM_DIS < height)
				{
					k = histImage[(i + GLCM_DIS) * width + j + GLCM_DIS];
					glcm[l * GLCM_CLASS + k]++;
				}
				if(j - GLCM_DIS >= 0 && j - GLCM_DIS < width && i - GLCM_DIS >= 0 && i - GLCM_DIS < height)
				{
					k = histImage[(i - GLCM_DIS) * width + j - GLCM_DIS];
					glcm[l * GLCM_CLASS + k]++;
				}
			}
		}
	}
	//45度对角方向
	else if(angleDirection == GLCM_ANGLE_DIGONAL_45)
	{
		for (i = 0;i < height;i++)
		{
			for (j = 0;j < width;j++)
			{
				l = histImage[i * width + j];

				if(j + GLCM_DIS >= 0 && j + GLCM_DIS < width && i - GLCM_DIS >= 0 && i - GLCM_DIS < height)
				{
					k = histImage[(i - GLCM_DIS) * width + j + GLCM_DIS];
					glcm[l * GLCM_CLASS + k]++;
				}
				if(j - GLCM_DIS >= 0 && j - GLCM_DIS < width && i + GLCM_DIS >= 0 && i + GLCM_DIS < height)
				{
					k = histImage[(i + GLCM_DIS) * width + j - GLCM_DIS];
					glcm[l * GLCM_CLASS + k]++;
				}
			}
		}
	}

	//计算特征值
	double entropy = 0,energy = 0,contrast = 0,homogenity = 0;
	for (i = 0;i < GLCM_CLASS;i++)
	{
		for (j = 0;j < GLCM_CLASS;j++)
		{
			//熵
			if(glcm[i * GLCM_CLASS + j] > 0)
				entropy -= glcm[i * GLCM_CLASS + j] * log10(double(glcm[i * GLCM_CLASS + j]));
			//能量
			energy += glcm[i * GLCM_CLASS + j] * glcm[i * GLCM_CLASS + j];
			//对比度
			contrast += (i - j) * (i - j) * glcm[i * GLCM_CLASS + j];
			//一致性
			homogenity += 1.0 / (1 + (i - j) * (i - j)) * glcm[i * GLCM_CLASS + j];
		}
	}
	//返回特征值
	i = 0;
	featureVector[i++] = entropy;
	featureVector[i++] = energy;
	featureVector[i++] = contrast;
	featureVector[i++] = homogenity;

	delete[] glcm;
	delete[] histImage;
	return 0;
}

#pragma endregion calcGLCM

double calc_variance(double a[4])
{
	double sum;
	double mean;
	double variance;
	sum = a[0]+a[1]+a[2]+a[3];
	mean = sum/4.0;

	variance = (a[0]-mean)*(a[0]-mean) + (a[1]-mean)*(a[1]-mean) + (a[2]-mean)*(a[2]-mean)+(a[3]-mean)*(a[3]-mean);
	variance = variance/4.0;
	return sqrt(variance);
}
void main()
{
	clock_t start,finish; 
	int WIDTH,HEIGHT;
	threshold = 8.5;
	IplImage* src_img = cvLoadImage("8.bmp",0);   //load the picture

	WIDTH = src_img->width;
	HEIGHT = src_img->height;
	int step = src_img->widthStep;             //the width of each row
	printf("width: %d step: %d depth: %d channels: %d",WIDTH,step,src_img->depth,src_img->nChannels);
	IplImage* msk_img = cvCreateImage(cvSize(WIDTH,HEIGHT),8,1);
	cvZero(msk_img);
	IplImage* dst_img = cvCreateImage(cvSize(WIDTH,HEIGHT),8,1);
	cvZero(dst_img);
	cvNot(dst_img,dst_img);



	start = clock();
	//cvSmooth(src_img,src_img,CV_GAUSSIAN);
	//cvSmooth(src_img,src_img,CV_MEDIAN,2);

	float sum;

	cvNamedWindow("src");
	cvShowImage("src",src_img);

	

	CvMat* cwindow = cvCreateMat(5,4,CV_32FC1);  //store the temperate 3*3 matrix
	//CvMat* cwindow = cvCreateMat(5,5,CV_32FC1);  //store the temperate 3*3 matrix


	double features[10];

	double entropy[4] = {0};
	double energy[4] = {0};
	double contrast[4] = {0};
	double homogenity[4] = {0};
	double variance;

	uchar* gray_ptr = NULL;
	uchar* msk_ptr = NULL;

	gray_ptr = (uchar*) (src_img->imageData);
	msk_ptr = (uchar*) (msk_img->imageData);

	int x,y;
	for(y = 2; y<src_img->height-2; y = y+2)
	{

		for ( x = 2; x<src_img->width-2; x = x+2)  
		{
			/*CV_MAT_ELEM(*cwindow,float,0,0) = gray_ptr[(y-2)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,0,1) = gray_ptr[(y-2)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,0,2) = gray_ptr[(y-2)*step+x];
			CV_MAT_ELEM(*cwindow,float,0,3) = gray_ptr[(y-2)*step+(x+1)];
			CV_MAT_ELEM(*cwindow,float,0,4) = gray_ptr[(y-2)*step+(x+2)];

			CV_MAT_ELEM(*cwindow,float,1,0) = gray_ptr[(y-1)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,1,1) = gray_ptr[(y-1)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,1,2) = gray_ptr[(y-1)*step+ x];
			CV_MAT_ELEM(*cwindow,float,1,3) = gray_ptr[(y-1)*step+(x+1)];
			CV_MAT_ELEM(*cwindow,float,1,4) = gray_ptr[(y-1)*step+x+2];

			CV_MAT_ELEM(*cwindow,float,2,0) = gray_ptr[y*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,2,1) = gray_ptr[y*step+(x-1)];
			CV_MAT_ELEM(*cwindow,float,2,2) = gray_ptr[y*step+x];
			CV_MAT_ELEM(*cwindow,float,2,3) = gray_ptr[y*step+(x+1)];
			CV_MAT_ELEM(*cwindow,float,2,4) = gray_ptr[y*step+(x+2)];

			CV_MAT_ELEM(*cwindow,float,3,0) = gray_ptr[(y+1)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,3,1) = gray_ptr[(y+1)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,3,2) = gray_ptr[(y+1)*step+x];
			CV_MAT_ELEM(*cwindow,float,3,3) = gray_ptr[(y+1)*step+(x+1)];
			CV_MAT_ELEM(*cwindow,float,3,4) = gray_ptr[(y+1)*step+(x+2)];

			CV_MAT_ELEM(*cwindow,float,4,0) = gray_ptr[(y+2)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,4,1) = gray_ptr[(y+2)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,4,2) = gray_ptr[(y+2)*step+x];
			CV_MAT_ELEM(*cwindow,float,4,3) = gray_ptr[(y+2)*step+(x+1)];
			CV_MAT_ELEM(*cwindow,float,4,4) = gray_ptr[(y+2)*step+x+2];*/


			CV_MAT_ELEM(*cwindow,float,0,0) = gray_ptr[(y-2)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,0,1) = gray_ptr[(y-2)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,0,2) = gray_ptr[(y-2)*step+x];
			CV_MAT_ELEM(*cwindow,float,0,3) = gray_ptr[(y-2)*step+(x+1)];
			//CV_MAT_ELEM(*cwindow,float,0,4) = gray_ptr[(y-2)*step+(x+2)];

			CV_MAT_ELEM(*cwindow,float,1,0) = gray_ptr[(y-1)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,1,1) = gray_ptr[(y-1)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,1,2) = gray_ptr[(y-1)*step+ x];
			CV_MAT_ELEM(*cwindow,float,1,3) = gray_ptr[(y-1)*step+(x+1)];
			//CV_MAT_ELEM(*cwindow,float,1,4) = gray_ptr[(y-1)*step+x+2];

			CV_MAT_ELEM(*cwindow,float,2,0) = gray_ptr[y*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,2,1) = gray_ptr[y*step+(x-1)];
			CV_MAT_ELEM(*cwindow,float,2,2) = gray_ptr[y*step+x];
			CV_MAT_ELEM(*cwindow,float,2,3) = gray_ptr[y*step+(x+1)];
			//CV_MAT_ELEM(*cwindow,float,2,4) = gray_ptr[y*step+(x+2)];

			CV_MAT_ELEM(*cwindow,float,3,0) = gray_ptr[(y+1)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,3,1) = gray_ptr[(y+1)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,3,2) = gray_ptr[(y+1)*step+x];
			CV_MAT_ELEM(*cwindow,float,3,3) = gray_ptr[(y+1)*step+(x+1)];
			//CV_MAT_ELEM(*cwindow,float,3,4) = gray_ptr[(y+1)*step+(x+2)];

			CV_MAT_ELEM(*cwindow,float,4,0) = gray_ptr[(y+2)*step+(x-2)];
			CV_MAT_ELEM(*cwindow,float,4,1) = gray_ptr[(y+2)*step+x-1];
			CV_MAT_ELEM(*cwindow,float,4,2) = gray_ptr[(y+2)*step+x];
			CV_MAT_ELEM(*cwindow,float,4,3) = gray_ptr[(y+2)*step+(x+1)];
			//CV_MAT_ELEM(*cwindow,float,4,4) = gray_ptr[(y+2)*step+x+2];

			calGLCM(cwindow,0,features);
			contrast[0] = features[2];
			//entropy[0] = features[0];
			//energy[0] = features[1];
			//homogenity[0] = features[3];

			calGLCM(cwindow,1,features);
			contrast[1] = features[2];
			//entropy[1] = features[0];
			//energy[1] = features[1];
			//homogenity[1] = features[3];

			calGLCM(cwindow,2,features);
			contrast[2] = features[2];
			//entropy[2] = features[0];
			//energy[2] = features[1];
			//homogenity[2] = features[3];

			calGLCM(cwindow,3,features);
			contrast[3] = features[2];

			variance = calc_variance(contrast);
			//printf("%f\n",contrast[3]);

			//entropy[3] = features[0];
			//energy[3] = features[1];
			//homogenity[3] = features[3];

			//if (variance >30)
			//	dst_ptr[y*step+x] = 0;
			//else dst_ptr[y*step+x] = 255;
			if (variance >threshold)

			{
			
				msk_ptr[(y-2)*step+(x-2)] = 255;
				msk_ptr[(y-2)*step+x-1] = 255;
				msk_ptr[(y-2)*step+x]=255;
				msk_ptr[(y-2)*step+(x+1)]= 255;
				//dst_ptr[(y-2)*step+(x+2)]= 255;

				msk_ptr[(y-1)*step+(x-2)]= 255;
				msk_ptr[(y-1)*step+x-1]= 255;
				msk_ptr[(y-1)*step+ x]= 255;
				msk_ptr[(y-1)*step+(x+1)]= 255;
				//dst_ptr[(y-1)*step+x+2]= 255;

				msk_ptr[y*step+(x-2)]= 255;
				msk_ptr[y*step+(x-1)]= 255;
				msk_ptr[y*step+x]= 255;
				msk_ptr[y*step+(x+1)]= 255;
				//dst_ptr[y*step+(x+2)]= 255;

				msk_ptr[(y+1)*step+(x-2)]= 255;
				msk_ptr[(y+1)*step+x-1]= 255;
				msk_ptr[(y+1)*step+x]= 0;
				msk_ptr[(y+1)*step+(x+1)]= 255;
				//dst_ptr[(y+1)*step+(x+2)]= 255;

				msk_ptr[(y+2)*step+(x-2)]= 255;
				msk_ptr[(y+2)*step+x-1]= 255;
				msk_ptr[(y+2)*step+x]= 255;
				msk_ptr[(y+2)*step+(x+1)]= 255;
				//dst_ptr[(y+2)*step+x+2]= 255;
				//dst_ptr[(y+2)*step+x+2]= 0;
			}
			//dst_ptr[y*step+x] = 0;
			else 
			{

				msk_ptr[(y-2)*step+(x-2)] = 0;
				msk_ptr[(y-2)*step+x-1] = 0;
				msk_ptr[(y-2)*step+x]=0;
				msk_ptr[(y-2)*step+(x+1)]= 0;
				//dst_ptr[(y-2)*step+(x+2)]= 0;

				msk_ptr[(y-1)*step+(x-2)]= 0;
				msk_ptr[(y-1)*step+x-1]= 0;
				msk_ptr[(y-1)*step+ x]= 0;
				msk_ptr[(y-1)*step+(x+1)]= 0;
				//dst_ptr[(y-1)*step+x+2]= 0;

				msk_ptr[y*step+(x-2)]= 0;
				msk_ptr[y*step+(x-1)]= 0;
				msk_ptr[y*step+x]= 0;
				msk_ptr[y*step+(x+1)]= 0;
				//dst_ptr[y*step+(x+2)]= 0;

				msk_ptr[(y+1)*step+(x-2)]= 0;
				msk_ptr[(y+1)*step+x-1]= 0;
				msk_ptr[(y+1)*step+x]= 0;
				msk_ptr[(y+1)*step+(x+1)]= 0;
				//dst_ptr[(y+1)*step+(x+2)]= 0;

				msk_ptr[(y+2)*step+(x-2)]= 0;
				msk_ptr[(y+2)*step+x-1]= 0;
				msk_ptr[(y+2)*step+x]= 0;
				msk_ptr[(y+2)*step+(x+1)]= 0;
			}

		}
	}

	cvNamedWindow("mask_before");
	cvShowImage("mask_before",msk_img);



	cvSmooth(msk_img,msk_img,CV_MEDIAN,19);
	cvMorphologyEx( msk_img, msk_img, NULL, NULL, CV_MOP_OPEN, 3 );
	// 开运算先腐蚀在膨胀,腐蚀可以清除噪点,膨胀可以修复裂缝
	cvMorphologyEx( msk_img, msk_img, NULL, NULL, CV_MOP_CLOSE, 3 );
	// 闭运算先膨胀后腐蚀,之所以在开运算之后,因为噪点膨胀后再腐蚀,是不可能去除的
	
	cvNamedWindow("mask");
	cvShowImage("mask",msk_img);

	cvCopy(src_img,dst_img,msk_img);

	cvNamedWindow("dst",CV_WINDOW_AUTOSIZE);
	cvShowImage("dst",dst_img);
finish = clock();
printf(" 计算时间%.2fms \n", (double) (finish - start));  

	cvWaitKey(0);
}

最后的运行如果如下：




测试图片及源代码下载：http://download.csdn.net/detail/computerme/8056957

本文系原创，转载请注明转载自：http://blog.csdn.net/computerme/article/details/40269357

Reference:

灰度共生矩阵在指纹图像分割中的应用.  李慧娜，郭超峰，平源,2012

IT修道者
关注
专栏目录
纹理滤波、灰度共生矩阵
Ben_Ben_Niao
08-18 2120
纹理滤波可用于查找边界等，有时候比其他描述（如亮度）的效果更好 主要思想：定义滤波准则+滤波核的大小（比如，3x3的核内，核中心的像素值 = 核内的最大值-最小值） 灰度共生矩阵： 在灰度共生矩阵中元素（i,j）的值（数量） = 像素值为i 和像素值为j的像素满足’特定关系的位置‘的对的个数，比如i在j的左边（默认）。 其中：’特定关系‘可以认为设定（）。 下图显示了如何求解灰度
灰度共生矩阵算法
11-16
灰度共生矩阵的C/C++实现，用于获得图像的纹理特征
灰度共生矩阵的实现
10-11
用vc实现图像的灰度共生矩阵提取纹理特征
全球最大的开源项目管理基地 GitHub 的魅力
最新发布
Lion_Long的博客
08-18 3229
GitHub不仅为开发者提供了代码托管、版本控制和项目协作的强大工具，更是一个汇聚了全球程序员和技术爱好者的社区。在这个平台上，数以百万计的开源项目不断地推动着软件开发的边界，促进了知识共享和技术传播。本文将深入探讨GitHub的魅力所在，分析其在开源生态系统中的重要角色，以及为什么它成为无数开发者和企业的首选。
灰度共生矩阵代码实现
积沙成塔
06-24 6652
2概念 2灰度共生矩阵生成编辑 灰度直方图是对图像上单个象素具有某个灰度进行统计的结果，而灰度共生矩阵是对图像上保持某距离的两象素分别具有某灰度的状况进行统计得到的。 取图像(N×N)中任意一点 （x，y）及偏离它的另一点 （x+a，y+b），设该点对的灰度值为 （g1，g2）。令点（x，y） 在整个画面上移动，则会得到各种 （g1，g2）值，设灰度值的级
图像纹理——灰度共生矩阵
热门推荐
sunny的专栏
11-11 8万+
1.灰度共生矩阵 本文是借用一篇文章的例子讲解灰度共生矩阵，用文字说明感觉说不清，自己之前用该方法做过实验，还是会忘，所以干脆用例子的方式介绍，下一次再看也容易理解。 在图像中任意一点（x,y）及偏离它的一点(x+a,y+b)(其中a，b为整数，认为定义)构成点对。设该点对的灰度值为(f1,f2),假设图像的最大灰度级为L,则f1与f2的组合共有L*L种。对于整福图像，统计每一种(f1,f2)
VS实现灰度共生矩阵
11-13
利用VS实现获取图像的灰度共生矩阵，并用MATLAB进行验证。 文件包含lena图片、VS程序、MATLAB程序。
使用灰度共生矩阵实现指纹分割 C++
10-19
总的来说，使用灰度共生矩阵进行指纹分割是一种有效的技术，它结合了纹理分析和阈值处理，能准确地将指纹纹线与背景区分开。配合OpenCV，可以方便地实现这个过程，并且便于与其他图像处理技术集成。
指纹鉴别方法的毛孔排汗和纹理特征融合
GLA大学，马图拉，印度阿提奇莱因福奥文章历史记录：收到2020年2020年9月20日修订2020年10月4日接受在线预订2020年关键词：生物特征Gabor孔汗水欺骗纹理A B S T R A C T随着生物识别技术的发展和应用，对指纹扫描仪...
数字图像处理：灰度特性
# 1. 数字图像处理简介 ### 1.1 数字图像处理概述 数字图像处理是指利用计算机对图像进行处理和分析的技术。它包括了图像获取、图像处理、图像分析和图像显示等过程。数字图像处理的出现，使得我们能够更加方便地对...
灰度共生矩阵实现及四个主要特征提取实现函数
12-27
实现了在MATLAB上灰度共生矩阵的生成，以及四个主要特征向量的提取。
灰度共生矩阵的VC源代码，计算灰度共生矩阵5个常用量
04-24
灰度共生矩阵的VC源代码，计算灰度共生矩阵5个常用量
指纹的分割与增强
06-02
指纹图像，阈值分割后，用均值滤波增强，和方向滤波增强，得到增强后的二值图像
指纹图像的分割
qiueji的专栏
07-12 5048
指纹图像的分割是指纹图像背景与前景的分割。前景就是指纹对象本身，它包含隆起的指纹纹线部分，指纹图像是指除指纹对象本身以外的图像 从指纹图像场的角度看，强度场和梯度场反映纹线隆起及变化。分析指纹对象思路如下： 1.通过计算强度场或梯度场的值来确定指纹对象 2.把指纹对象从背景分割出来 分析指纹图像场，指纹对象与背景的区别主要表现为指纹对象的灰度和梯度与背景的不同。 从图像场的角度看，指纹对
python实现图像灰度共生矩阵
03-29
自己用python写的灰度共生矩阵小程序
指纹识别-(8)指纹图像预处理算法之图像分割
xuhe93的博客
04-25 1万+
如图指纹图像通常由脊谷区域、图像背景及边界、墨迹斑、模糊的可恢复的脊谷区域、不可恢复的模糊区域组成。在语义分割领域，图像的分割是将ROI(region of interest)分割出来。在指纹图像的分割领域，ROI一般定义为指纹前景即脊谷区域，本文所述的指纹图像的分割将可恢复区域及完好区域作为ROI。 在线指纹识别算法的一个重要步骤是对指纹图像的分割。指纹图像分割将包括脊线和谷线在内的有效区域从......
基于灰度共生矩阵的指纹图像分割算法研究
通过对指纹图像的灰度级、位移量和相对方向与灰度共生矩阵的二次统计特征的分析，实现了有效的图像分割。算法首先将指纹图像划分为矩形块，计算每块在不同方向上的灰度共生矩阵的对比度，随后利用对比度方差与预设...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值