2016-11-21 23:24:14 hzh_csdn 阅读数 7105

转载请注明来自我的CSDN博客:黄朝辉的博客

读入一幅彩色图像,进行如下图像处理:

(1) 在RGB彩色空间中对图像进行模糊和锐化处理

rgb= imread('flower.jpg');
figure;  imshow(rgb); title('原图');
 %平滑滤波  
r=rgb(:,:,1);  
g=rgb(:,:,2); 
 b=rgb(:,:,3); 
m=fspecial('average',[8,8]); 
 r_filtered=imfilter(r,m);
 g_filtered=imfilter(g,m); 
 b_filtered=imfilter(b,m);  
 rgb_filtered=cat(3,r_filtered,g_filtered,b_filtered); 
 figure;  imshow(rgb_filtered);  title('模糊后');
imwrite(rgb_filtered, 'RGB彩色空间模糊后.jpg');

彩色空间模糊后
RGB彩色空间模糊后

%拉普拉斯
lapMatrix=[1 1 1;1 -8 1;1 1 1];    
  i_tmp=imfilter(rgb,lapMatrix,'replicate'); 
 i_sharped=imsubtract(rgb,i_tmp); 
 figure;   imshow(i_sharped); title('锐化后');
imwrite(i_sharped, 'RGB彩色空间锐化后.jpg');

RGB彩色空间锐化后
RGB彩色空间锐化后

(2) 在HSI彩色空间中,对H分量图像进行模糊和锐化处理,转换回RGB格式并观察效果

(3) 在HSI彩色空间中,对S分量图像进行模糊和锐化处理,转换回RGB格式并观察效果

(4) 在HSI彩色空间中,对I分量图像进行模糊和锐化处理,转换回RGB格式并观察效果

fc = imread('flower.jpg');
h = rgb2hsi(fc);
H = h (:,:,1);
S = h (:,:,2);
I = h (:,:,3);

subplot(3,3,1);imshow(fc);  title('原图');

原图
原图

%平滑滤波 
m=fspecial('average',[8,8]); 
h_filtered=imfilter(H,m);
img_h_filtered = cat(3,h_filtered,S,I); 
rgb_h_filtered = hsi2rgb(img_h_filtered);
subplot(3,3,2);imshow(rgb_h_filtered);  title('H分量模糊后');
imwrite(rgb_h_filtered, 'H分量模糊后.jpg');

H分量模糊后
H分量模糊后

%拉普拉斯
lapMatrix=[1 1 1;1 -8 1;1 1 1];    
i_tmp=imfilter(H,lapMatrix,'replicate'); 
H_sharped=imsubtract(H,i_tmp); 
img_h_sharped = cat(3,H_sharped,S,I); 
rgb_h_sharped = hsi2rgb(img_h_sharped);
subplot(3,3,3); imshow(rgb_h_sharped); title('H分量锐化后');
imwrite(rgb_h_sharped, 'H分量锐化后.jpg');

H分量锐化后
H分量锐化后

subplot(3,3,4);imshow(fc);  title('原图');
%平滑滤波 
m=fspecial('average',[8,8]); 
s_filtered=imfilter(S,m);
img_s_filtered = cat(3,H,s_filtered,I); 
rgb_s_filtered = hsi2rgb(img_s_filtered);
subplot(3,3,5);imshow(rgb_s_filtered);  title('S分量模糊后');
imwrite(rgb_s_filtered, 'S分量模糊后.jpg');

S分量模糊后
S分量模糊后

%拉普拉斯
lapMatrix=[1 1 1;1 -8 1;1 1 1];    
i_tmp=imfilter(S,lapMatrix,'replicate'); 
s_sharped=imsubtract(S,i_tmp); 
img_s_sharped = cat(3,H,s_sharped,I); 
rgb_s_sharped = hsi2rgb(img_s_sharped);
subplot(3,3,6); imshow(rgb_s_sharped); title('S分量锐化后');
imwrite(rgb_s_sharped, 'S分量锐化后.jpg');

S分量锐化后
S分量锐化后

subplot(3,3,7);imshow(fc);  title('原图');
%平滑滤波 
m=fspecial('average',[8,8]); 
i_filtered=imfilter(I,m);
img_i_filtered = cat(3,H,S,i_filtered); 
rgb_i_filtered = hsi2rgb(img_i_filtered);
subplot(3,3,8);imshow(rgb_i_filtered);  title('I分量模糊后');
imwrite(rgb_i_filtered, 'I分量模糊后.jpg');

I分量模糊后
I分量模糊后

%拉普拉斯
lapMatrix=[1 1 1;1 -8 1;1 1 1];    
i_tmp=imfilter(I,lapMatrix,'replicate'); 
i_sharped=imsubtract(I,i_tmp); 
img_i_sharped = cat(3,H,S,i_sharped); 
rgb_i_sharped = hsi2rgb(img_i_sharped);
subplot(3,3,9); imshow(rgb_i_sharped); title('I分量锐化后');
imwrite(rgb_i_sharped, 'I分量锐化后.jpg');

I分量锐化后
I分量锐化后

2019-06-21 08:57:23 qq_42192910 阅读数 218

最近涉及到有关图像处理的知识,在此进行学习记录。
本人是通过matlab进行实现的

1、图像模糊

matlab相关文档链接:https://ww2.mathworks.cn/help/images/ref/fspecial.html
参考博客:https://blog.csdn.net/ji0525084/article/details/8061295
通过matlab实现模糊主要就是两类,运动模糊和散焦模糊,即主要是fspecial函数的使用定义。
如:H = fspecial(‘motion’,20,45);即是运动模糊,20个像素,角度为45度。

2、图像亮度不均

matlab相关文档链接:https://www.mathworks.com/help/images/ref/imadjust.html
(或直接在matlab命令行输出doc()搜索也可查看)
参考博客:
https://blog.csdn.net/Ibelievesunshine/article/details/79958899
https://blog.csdn.net/hjxu2016/article/details/80406886
通过matlab实现图像亮度变换即主要是使用imadjust函数,有以下这四种使用方式:(解释见上述链接)
J = imadjust(I),增加对比度。
J = imadjust(I,[low_in high_in])
J = imadjust(I,[low_in high_in],[low_out high_out])
J = imadjust(I,[low_in high_in],[low_out high_out],gamma)

其实imadjust的参数“in”和“out”的范围是0,1之间,它表示图像像素的比例的意思,然后映射到新的图像J。
而对于灰度图像(0黑-255白)来说,主要使用第三个函数方式,如下是原文解释:
J = imadjust(I,[low_in high_in],[low_out high_out]) maps intensity values in I to new values in J such that values between low_in and high_in map to values between low_out and high_out.
很显然的就是将参数“in”的参数范围映射到“out”的参数范围。
图像变暗即是将灰度值较大的部分减小,如:[0 1]->[0 0.2],即是0到255的值变成了0到255 * 0.2的范围了,当然变黑暗了。
同理,那么如果变明亮,[0 1]->[0.8 1],即是0到255的值变成了255 * 0.8到255的范围了。

2013-04-10 14:51:37 mlkiller 阅读数 4206

本章主要讲图像处理中的模糊处理部分

英文叫做blur, 也叫做smootiing,  中文中叫做模糊或者平滑。

用过photoshop的人都应该知道,滤镜里面就有模糊这个选项,我们现在看看它是怎么实现的。

一含义

   模糊(平滑)是一种常用的图片处理方式,它的作用可以用来降低噪声,还有其他用途

   看一下opencv 里面的公式

               g(i,j) = \sum_{k,l} f(i+k, j+l) h(k,l)

     g(i,j)是目标坐标的像素值, f(i+k,j+l)是k,l这些地方的像素值, h(k,l)是 kernel,  我不知道怎么去准确翻译它的意义,它是过滤器的系数。 

    简单的按照我的思路去理解,就是一个权值,模糊的含义是将所有的像素按照一定的权值进行运算,得到一个比较均衡的结果。

二 类型

类型有很多种:
均值模糊(box blur) 高斯模糊(gaussian blur)  中值模糊(media blur) 二值模糊(bilateral blur)
本文只讲均值模糊和高斯模糊

三 算法

1 均值模糊
   均值模糊很简单就是周边所有的影响都是1,求平均值即可
K = \dfrac{1}{K_{width} \cdot K_{height}} \begin{bmatrix}    1 & 1 & 1 & ... & 1 \\    1 & 1 & 1 & ... & 1 \\    . & . & . & ... & 1 \\    . & . & . & ... & 1 \\    1 & 1 & 1 & ... & 1   \end{bmatrix}
2 高斯模糊
关于高斯模糊的算法,推荐这个文章
根据这个公式计算出系数即可。
上篇文章写得很详细,我就不班门弄斧了。

四均值模糊的代码和效果

     先放上均值模糊的代码
void boxblur(Mat input ,Mat &out, int x, int y)
{
	// accept only char type matrices
	CV_Assert(input.depth() != sizeof(uchar));

	out.create(input.size(),input.type());

	int nChannels = input.channels();
	int nRows = input.rows;
	int nCols = input.cols;

	int size = x * y;
	float kernel = 1.0/size;

	int i,j;
	uchar* p;
	uchar* q;
	uchar R,G,B;

	for( i = x; i < nRows - x; ++i)
	{
		q = out.ptr<uchar>(i);
		for ( j = y; j < nCols - y; ++j)
		{
			float sumR = 0;
			float sumG = 0;
			float sumB = 0;
			for (int k =0; k<x;k++)
			{
				p = input.ptr<uchar>(i-x+k);
				for(int l = 0; l < y;l++)
				{
					sumB += input.at<uchar>(i - x + k,(j + l - y)*nChannels) * kernel;//p[(l + j -y)*nChannels ] * kernel;
					sumG += input.at<uchar>(i - x + k,(j + l - y)*nChannels + 1) * kernel;//p[(l + j -y)*nChannels + 1] * kernel;
					sumR += input.at<uchar>(i - x + k,(j + l - y)*nChannels + 2) * kernel;//p[(l + j -y)*nChannels + 2] * kernel;
				}
			}
			q[j*nChannels] = sumB;
			q[j*nChannels+1] = sumG;
			q[j*nChannels+2] = sumR;
		}
	}


}

红色部分是我想直接用at,而不用指针,但是效率低的厉害。


下图是用指针的相差了20倍。。。可见指针虽然万恶,但是确实是个好东西。



由于size(4,4)图太小看不清, 实际用的是8
原始 opencv 本文


五高斯模糊的代码和效果

代码如下:

void gaussblur(Mat input ,Mat &out, int x, int y)
{
	float sigma = 1.5;
	Mat kernel;
	float pi = 3.1415926;

	kernel.create(x ,y ,CV_32F);

	float mx = x/2.0;
	float my = y/2.0;

       //这里有问题,后面做修正。
	for (int i =0; i< x;i++)
	{
		for (int j =0; j<y;j++)
		{
			kernel.at<float>(i,j) = exp(-1 * ((i - mx) * (i - mx) +(j - my) * (j-my) )/( 2 * sigma * sigma))/(2 * pi * sigma *sigma) ;
		}
	}


    int nChannels = input.channels();
	int nRows = input.rows;
	int nCols = input.cols;

	out.create(input.size(),input.type());
    uchar* p;
	uchar* q;
	float* s;

	for(int  i = x; i < nRows - x; ++i)
	{
		q = out.ptr<uchar>(i);
		for (int j = y; j < nCols - y; ++j)
		{
			float sumR = 0;
			float sumG = 0;
			float sumB = 0;
			for (int k =0; k<x;k++)
			{
				p = input.ptr<uchar>(i-x+k);
				s = kernel.ptr<float>(k); 
				for(int l = 0; l < y;l++)
				{
					sumB += p[(l + j -y)*nChannels ] * s[l];//input.at<uchar>(i - x + k,(j + l - y)*nChannels) * kernel;//
					sumG += p[(l + j -y)*nChannels + 1] *s[l];//input.at<uchar>(i - x + k,(j + l - y)*nChannels + 1) * kernel;//
					sumR += p[(l + j -y)*nChannels + 2] * s[l];//input.at<uchar>(i - x + k,(j + l - y)*nChannels + 2) * kernel;
				}
			}
			q[j*nChannels] = sumB;
			q[j*nChannels+1] = sumG;
			q[j*nChannels+2] = sumR;
		}
	}

	
}

效率如下:

效果图如下:
本文没有考虑边界的情况,所以都是灰色的,可以考虑一下如何处理边界。
原始 opencv 本文

上面代码有两处问题:
第一是在size比较小的时候,这些点的概率之和不等于1,会导致图片出问题。修正如下:

	float sum = 0;
	for (int i =0; i< x;i++)
	{
		for (int j =0; j<y;j++)
		{
			sum+= kernel.at<float>(i,j) = exp(-1 * ((i - mx) * (i - mx) +(j - my) * (j-my) )/( 2 * sigma * sigma))/(2 * pi * sigma *sigma) ;
		}
	}
	for (int i =0; i< x;i++)
	{
		for (int j =0; j<y;j++)
		{
			kernel.at<float>(i,j) = kernel.at<float>(i,j)/ sum ;
		}
	}


第二个问题是本文中sigma 是个固定值,实际上它是个可变值,具体怎么计算,我没有搞清楚,可以查看opencv的源代码,下面文章有参考价值

更新一下参考opencv里面的可以这样计算
sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8 .
修改程序之后发现和原始的高斯函数基本一致,希望广大朋友们多多评论,本人水平有限,很多地方有纰漏,希望能够共同提高。
2019-09-29 20:22:04 weixin_44225182 阅读数 556

图像锐化(原理篇)

       图像锐化处理的目的是为了使图像的边缘、轮廓线以及图像的细节变得清晰,经过平滑的图像变得模糊的根本原因是因为图像受到了平均或积分运算,因此可以对其进行逆运算(如微分运算,其实这里用的是差分)就可以使图像变得清晰。
       图像中边缘的定义是什么?在图像处理中认为,灰度值变化剧烈的地方就是边缘。变化剧烈程度,数学上就是函数的一阶导数。假设下面第一张图是图像的灰度函数,可以看出,中间变化较快的地方应该是图像的边缘。第二张图是图一的一阶导数,由数学知识可知,一阶导数的极值就是那个变化最快的点–边缘。第三张图是图一的二阶导数,二阶导数为0时,可以看出是图像的边缘处。所以,对于确定图像的边缘,我们只需要找到一阶导数为极值点或者二阶导数为0的位置就行(二阶导数为0不一定为边缘点 比如一副颜色相同的图像 其一阶导数 二阶导数都是0 没有边缘)
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
       那为什么用差分来寻找边缘呢对于连续的函数来说,一阶导数就是直接求导,二阶同理。但是,图像本质是一个二维矩阵,离散型的。是无法求导的。这时候,就需要用到差分这个概念了。实在理解不到的话,可以认为:连续型函数是求导(求微分),离散型函数则是求差分。

一阶导数、二阶导数差分的证明
在这里插入图片描述
图像上差分的求法
在这里插入图片描述
常用一阶微分算子证明
在这里插入图片描述
二阶算子证明
在这里插入图片描述

更多

获取更多资料、代码,微信公众号:海轰Pro
回复 海轰 即可

2017-12-14 17:50:13 lovebaby859450415 阅读数 1539

数字图像处理的MATLAB实现(第二版) - 第二章学习总结


灰度变换与空间滤波

  • 亮度(或灰度变换)
  • 空间滤波
  • 模糊图像处理

1.背景知识

空域处理思想由公式(1)表示:

g(x,y)=T[f(x,y)](1)

其中,f(x,y)为输入图像,g(x,y)为处理后的图像,T为对图像的f的算子,作用于点(x,y)的领域。

2.灰度变换函数

由于输出图像仅仅取决于点的灰度值,而不是取决于点的领域,因此灰度变换函数通常如公式(2)所示:

s=T(r)(2)

其中,r表示图像f中的灰度,s表示图像g中的灰度。两者在图像中处于相同的坐标(x,y)处。

2.1灰度图像进行灰度变换的基本图像处理工具箱函数

g=imadjust(f, [low_inhigh_in], [low_outhigh_out], gamma)

其中,将 low_inhigh_in 之间的值映射到 low_outhigh_out 之间,而超出该范围的值都被截去,小于 low_in 的值映射为 low_out ,大于 high_in 的值映射为 high_out 。参数 gamma 指明了由 f 映射生成图像 g 时的曲线。如果 gamma 的值小于1,映射被加权至较亮的输出,反之较暗的输出。

Low_High=stretchlim(f, tol)

其中,Low_High 是低和高均受限的两元素向量,可用于完成对比度拉伸。默认情况下,Low_High 是指定灰度图像f中所有像素值底部和顶部饱和度的1%,tol 是两元素向量[low_frachigh_frac],指定了图像低和高像素值饱和度的百分比。


测试:

test.m
f = imread('Fig0203(a).tif'):
% default
g1 = imadjust(f, [0 1], [1, 0]);

% 调用工具箱的负片函数
g = imcomplement(f);

% 扩展亮度[0.5 0.75]->[0 1]
g2 = imadjust(f, [0.5 0.75], [0 1]);

% 使用gamma增强
g3 = imadjust(f, [ ], [ ], 2);

% 使用stretchlim函数
g4 = imadjust(f, stretchlim(f), [ ]);

2.2. 针对灰度变换的自建M函数

tofloat 函数
Logicaluint8uint16int16类的图像转换成 single类,配合应用适当的比例因子。下面附上附注释的完整代码。


function [out, revertclass] = tofloat(in)
%TOFLOAT Convert image to floating point
%  [OUT, REVERTCLASS] = TOFLOAT(IN) converts the input image IN to
%  floating-point. If IN is a double or a single image, then OUT
%  equals IN. Otherwise, OUT equals IM2SINGLE(IN). REVERTCLASS is
%  a function handle that can be used to convert back to the class
%  of IN.

identity = @(x) x;       % 函数句柄
tosingle = @im2single;   % 函数句柄

table = {'uint8',   tosingle, @im2uint8
         'uint16',  tosingle, @im2uint16
         'int16',   tosingle, @im2int16
         'logical', tosingle, @logical
         'double',  identity, identity
         'single',  identity, identity};

% 返回 in 在表中第一列的第几个位置
classIndex = find(strcmp(class(in), table(:, 1)));

% 如果是classIndex矩阵为空,则isempty 返回 1
if isempty(classIndex)
    error('Unsupported input image class.');
end

% 这里table是cell数据类型,这里用'{ }', 表示在对应位置的输出值
% out = table{classIndex, 2} = 对应的句柄函数
out = table{classIndex, 2}(in);

revertclass = table{classIndex, 3}; % revertclass= @(x) x
end

gscale 函数
用于标定灰度的M-函数

我们通常希望把图像标度在全尺度,即最大范围[0, 255]或[0, 65535],不然当我们想利用8位或者16位格式保存或观看一幅图像时,就会出现问题。
gscale 函数的目的就是实现该功能。


function g =gscale(f, varargin)
% GSCALE Scales the intensity of the input image.
% G = GSCALE(F, 'full8') scales the intensities of F to the full
% 8-bit intensity range [0, 255]. This is the default if there is
% only one input argument.
%
% G = GSCALE(F, 'full16') scales the intensities of F to the full
% 16-bit intensity range [0, 65535].
% G = GSCALE(F, 'minmax', LOW, HIGH) scales the intensities of F
% to the range [LOW, HIGH]. These vaules must be provided, and they
% must be in the range [0, 1], independently of the class of the 
% input. GSCALE performs any necessary scaling. If the input is of
% class double, and its vaules are not in the range [0, 1], then 
% GSCALE scales it to  this range before processing.
% 
% The class of the output is the same as the class of the input.

% length 计算varargin中的最大向量尺度
if length(varargin) == 0   % If only one argument it must be f.
    method = 'full8';
else
    method = varargin{1};
end

% strcmp 比较class(f) 是否是double类型 如果是则返回1 
% max(f(:) > 1) 如果f中有大于1的元素则返回逻辑1
if strcmp(class(f), 'double') & (max(f(:)) > 1 | min(f(:)) < 0)
    f = mat2gray(f);
end

% Perform the specified scaling.
switch method
case 'full8'
    g = im2uint8(mat2gray(double(f)));   % im2uint8 将f转换为8位无符号整形
case 'full16'
    g = im2uint16(mat2gray(double(f)));  % im2uint16 将f转换为16位无符号整形
case 'minmax'
    low = varargin{2}; high = varargin{3};
    if low > 1 | low < 0 high > 1 | high < 0
        error('Parameters low and high must be in the range [0, 1].');
    end
    if strcmp(class(f), 'double')
        low_in = min(f(:));
        high_in = max(f(:));
    elseif strcmp(class(f), 'uint8')
        low_in = double(min(f(:)))./255;
        high_in = double(max(f(:)))./255;
    elseif strcmp(class(f), 'uint16')
        low_in = double(min(f(:)))./65535;
        high_in = double(max(f(:)))./65535;
    else
    % imadjust automatically matches the class of the input.
    g = imadjust(f, [low_in high_in], [low high]);
end

intrans 函数

该函数整合“负片变换”、“对数变换”、“gamma变换”、“对比度扩展”。

function g = intrans(f, method, varargin)

% Verify the correct number of inputs.
error(nargchk(2, 4, nargin))
if strcmp(method, 'log')
    % The log transform handles image classes differently than the 
    % others transforms, so let the logTranform function handle that
    % and then return.
    g = logTranform(f, varargin{:});
    return;
end

% If f is floating point, check to see if it is in the range [0, 1]
% If it is not, force it to be using function mat2gray.
if isfloat(f) && (max(f(:)) > 1 || min(f(:)) < 0)
    f = mat2gray(f);
end
[f, revertclass] = tofloat(f); % Store class of f for use later.

% Perform the intensity transformation specified
switch method
case 'neg'
    g = imcomplement(f);

case 'gamma'
    g = gammaTransform(f, varargin{:});

case 'stretch'
    g = stretchTransform(f, varargin{:});

case 'specified'
    g = spcfiedTransform(f, varargin{:});

otherwise
    error('Unknown enchancement method.');
end

% Convert to the class of the input image.
g = revertclass(g);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function g = gammaTransform(f, gamma)
g = imadjust(f, [ ], [ ], gamma);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function g = stretchTransform(f, varargin)
if isempty(varargin)
    % Use defaults.
    m = mean2(f);
    E = 4.0;
elseif length(varargin) == 2
    m = varargin{1};
    E = varargin{2};
else
    error('Incorrect number of inputs for the stretch method.');
end
g = 1./(1 + (m./f).^E);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function g = spcfiedTransform(f, txfun)
% f is floating point with vaules in the range [0 1].
txfun = txfun(:);  % Force it to be a column vector.
if any(txfun) > 1 || any(txfun) <= 0
    error('All elements of txfun must be in the range [0 1].');
end
T = txfun;
X = linspace(0, 1, numel(T))';
g = interpl(X, T, f);

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function g = logTranform(f, varargin)
[f, revertclass] = tofloat(f);
if numel(varagin) >= 2
    if strcmp(varagin{2}, 'uint8')
        revertclass = @im2uint8;
    elseif strcmp(varagin{2}, 'uint16')
        revertclass = @im2uint16;
    else
        error('Unsupported CLASS option for "log" method.');
    end
end
if numel(varagin < 1)
    % Set default for C
    C = 1;
else
    C = varargin{1};
end
g = C * (log(1+f));
g = revertclass(g);
end

3. 直方图处理和函数绘图

3.1. 直方图

思想:“不同灰度级出现的概率”。如公式(3)所示:

p(rk)=h(rk)/n=nk/n(3)

其中,rk[0,G] 间隔内第k级灰度,nk为图像中出现rk这种灰度的像素数。对于浮点图像类,G=1.0
注:对于 uint8uint16G=L1

工具箱对应的梳理图像直方图的核心函数是 imhist ,其基本语法如下:

h=imhist(f,b)

其中,f 为输入图像,h 为直方图,b是用来形容直方图的“统计堆栈”的数目(若b不在此参数列表中,默认值是256)。“统计堆栈”仅仅是灰度的一小部分。例如:f 为一幅 uint8 类的图像,取b=2 ,然后灰度范围被分成[0 127]和[128 255]两部分,得到的直方图有两个值,h(1)=numel([0127])h(2)=numel([128255])


3.2. 直方图均衡化

假设灰度级为归一化在[0, 1]范围内的连续量,让pr(r)代表一幅给定图像的灰度级的概率密度函数PDF-1PDF-2。下标用来区分输入图像和输出图像的概率密度函数。假设我们对输入灰度进行下列变换,得到输出灰度级s。

s=T(r)=r0pr(w)dw(4)

式中的w 是积分虚变量。则:

ps(s)={10s10other(5)

简言之‘生成后的图像灰度级等概率,灰度级覆盖了整个[0, 1]范围,即实现了动态范围的扩展’对上式转到离散的灰度级。
sk=T(rk)=j=0kpr(rj)=j=0knjn(6)

公式(6)中,k=0,1,2,3,...,L1Sk 是输出图像的灰度值。对应输入图像的灰度值为rk

工具箱对应的直方图均衡化函数:

g=histeq(f,nlev)

其中,f为输入图像,nlev为输出图像设定的灰度级数。


3.3. 直方图规定化


4. 空间滤波

4.1. 线性空间滤波


4.2. 非线性空间滤波


5.模糊集合

matlab图片模糊处理

阅读数 1073

具体实现的函数和思路

博文 来自: pxe512
没有更多推荐了,返回首页