冈萨雷斯数字图像处理——彩色图像增强3实例
冈萨雷斯数字图像处理——彩色图像增强3实例
实例一：基于直方图均衡化的彩色图像增强
要处理的图片：fruit.jpg
example1.m:
clc;
RGB=imread('fruit.jpg'); %输入彩色图像，得到三维数组
R=RGB(:,:,1); %分别取三维数组的一维，得到红绿蓝三个分量
G=RGB(:,:,2); %为R G B
B=RGB(:,:,3);
subplot(4,2,1),imshow(RGB); %绘制各分量的图像及其直方图
title('原始真彩色图像');
subplot(4,2,3),imshow(R);
title('真彩色图像的红色分量');
subplot(4,2,4), imhist(R);
title('真彩色图像的红色分量直方图');
subplot(4,2,5),imshow(G);
title('真彩色图像的绿色分量');
subplot(4,2,6), imhist(G);
title('真彩色图像的绿色分量直方图');
subplot(4,2,7),imshow(B);
title('真彩色图像的蓝色分量');
subplot(4,2,8), imhist(B);
title('真彩色图像的蓝色分量直方图');
r=histeq(R); %对个分量直方图均衡化，得到个分量均衡化图像
g=histeq(G);
b=histeq(B);
figure,
subplot(3,2,1),imshow(r);
title('红色分量均衡化后图像');
subplot(3,2,2), imhist(r);
title('红色分量均衡化后图像直方图');
subplot(3,2,3),imshow(g);
title('绿色分量均衡化后图像');
subplot(3,2,4), imhist(g);
title('绿色分量均衡化后图像直方图');
subplot(3,2,5), imshow(b);
title('蓝色分量均衡化后图像');
subplot(3,2,6), imhist(b);
title('蓝色分量均衡化后图像直方图');
figure, %通过均衡化后的图像还原输出原图像
newimg = cat(3,r,g,b);
imshow(newimg,[]);
title('均衡化后分量图像还原输出原图');
处理效果：
通过matlab仿真，比较均衡化后的还原图像与输入原始真彩色图像，输出图像轮廓更清晰，亮度明显增强。
实例二: 双边滤波(Bilateral Filtering)
双边滤波是一种非线性的滤波方法，是结合图像的空间邻近度和像素值相似度的一种折衷处理，同时考虑空域信息和灰度相似性，达到保边去噪的目的。具有简单、非迭代、局部的特点。双边滤波器的好处是可以做边缘保存（edge preserving），一般过去用的维纳滤波或者高斯滤波去降噪，都会较明显地模糊边缘，对于高频细节的保护效果并不明显。双边滤波器顾名思义比 高斯滤波 多了一个高斯方差sigma－d，它是基于空间分布的高斯滤波 函数 ，所以在边缘附近，离的较远的像素不会太多影响到边缘上的像素值，这样就保证了边缘附近像素值的保存。但是由于保存了过多的高频信息，对于彩色图像里的高频噪声，双边滤波器不能够干净的滤掉，只能够对于低频信息进行较好的滤波。
测试用例图：
matlab代码：
bfilter2.m
% BFILTER2 Two dimensional bilateral filtering. % This function implements 2-D bilateral filtering using % the method outlined in: % % C. Tomasi and R. Manduchi. Bilateral Filtering for % Gray and Color Images. In Proceedings of the IEEE % International Conference on Computer Vision, 1998. % % B = bfilter2(A,W,SIGMA) performs 2-D bilateral filtering % for the grayscale or color image A. A should be a double % precision matrix of size NxMx1 or NxMx3 (i.e., grayscale % or color images, respectively) with normalized values in % the closed interval [0,1]. The half-size of the Gaussian % bilateral filter window is defined by W. The standard % deviations of the bilateral filter are given by SIGMA, % where the spatial-domain standard deviation is given by % SIGMA(1) and the intensity-domain standard deviation is % given by SIGMA(2). % % Douglas R. Lanman, Brown University, September 2006. % [email protected], http://mesh.brown.edu/dlanman %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Pre-process input and select appropriate filter. function B = bfilter2(A,w,sigma) % Verify that the input image exists and is valid. if ~exist('A','var') || isempty(A) error('Input image A is undefined or invalid.'); end if ~isfloat(A) || ~sum([1,3] == size(A,3)) || ... min(A(:)) < 0 || max(A(:)) > 1 error(['Input image A must be a double precision ',... 'matrix of size NxMx1 or NxMx3 on the closed ',... 'interval [0,1].']); end % Verify bilateral filter window size. if ~exist('w','var') || isempty(w) || ... numel(w) ~= 1 || w < 1 w = 5; end w = ceil(w); % Verify bilateral filter standard deviations. if ~exist('sigma','var') || isempty(sigma) || ... numel(sigma) ~= 2 || sigma(1) <= 0 || sigma(2) <= 0 sigma = [3 0.1]; end % Apply either grayscale or color bilateral filtering. if size(A,3) == 1 B = bfltGray(A,w,sigma(1),sigma(2)); else B = bfltColor(A,w,sigma(1),sigma(2)); end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Implements bilateral filtering for grayscale images. function B = bfltGray(A,w,sigma_d,sigma_r) % Pre-compute Gaussian distance weights. [X,Y] = meshgrid(-w:w,-w:w); G = exp(-(X.^2+Y.^2)/(2*sigma_d^2)); % Create waitbar. h = waitbar(0,'Applying bilateral filter...'); set(h,'Name','Bilateral Filter Progress'); % Apply bilateral filter. dim = size(A); B = zeros(dim); for i = 1:dim(1) for j = 1:dim(2) % Extract local region. iMin = max(i-w,1); iMax = min(i+w,dim(1)); jMin = max(j-w,1); jMax = min(j+w,dim(2)); I = A(iMin:iMax,jMin:jMax); % Compute Gaussian intensity weights. H = exp(-(I-A(i,j)).^2/(2*sigma_r^2)); % Calculate bilateral filter response. F = H.*G((iMin:iMax)-i+w+1,(jMin:jMax)-j+w+1); B(i,j) = sum(F(:).*I(:))/sum(F(:)); end waitbar(i/dim(1)); end % Close waitbar. close(h); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Implements bilateral filter for color images. function B = bfltColor(A,w,sigma_d,sigma_r) % Convert input sRGB image to CIELab color space. if exist('applycform','file') A = applycform(A,makecform('srgb2lab')); else A = colorspace('Lab<-RGB',A); end % Pre-compute Gaussian domain weights. [X,Y] = meshgrid(-w:w,-w:w); G = exp(-(X.^2+Y.^2)/(2*sigma_d^2)); % Rescale range variance (using maximum luminance). sigma_r = 100*sigma_r; % Create waitbar. h = waitbar(0,'Applying bilateral filter...'); set(h,'Name','Bilateral Filter Progress'); % Apply bilateral filter. dim = size(A); B = zeros(dim); for i = 1:dim(1) for j = 1:dim(2) % Extract local region. iMin = max(i-w,1); iMax = min(i+w,dim(1)); jMin = max(j-w,1); jMax = min(j+w,dim(2)); I = A(iMin:iMax,jMin:jMax,:); % Compute Gaussian range weights. dL = I(:,:,1)-A(i,j,1); da = I(:,:,2)-A(i,j,2); db = I(:,:,3)-A(i,j,3); H = exp(-(dL.^2+da.^2+db.^2)/(2*sigma_r^2)); % Calculate bilateral filter response. F = H.*G((iMin:iMax)-i+w+1,(jMin:jMax)-j+w+1); norm_F = sum(F(:)); B(i,j,1) = sum(sum(F.*I(:,:,1)))/norm_F; B(i,j,2) = sum(sum(F.*I(:,:,2)))/norm_F; B(i,j,3) = sum(sum(F.*I(:,:,3)))/norm_F; end waitbar(i/dim(1)); end % Convert filtered image back to sRGB color space. if exist('applycform','file') B = applycform(B,makecform('lab2srgb')); else B = colorspace('RGB<-Lab',B); end % Close waitbar. close(h);cartoon.m
function C = cartoon(A) % CARTOON Image abstraction using bilateral filtering. % This function uses the bilateral filter to abstract % an image following the method outlined in: % % Holger Winnemoller, Sven C. Olsen, and Bruce Gooch. % Real-Time Video Abstraction. In Proceedings of ACM % SIGGRAPH, 2006. % % C = cartoon(A) modifies the color image A to have a % cartoon-like appearance. A must be a double precision % matrix of size NxMx3 with normalized values in the % closed interval [0,1]. Default filtering parameters % are defined in CARTOON.M. % % Douglas R. Lanman, Brown University, September 2006. % [email protected], http://mesh.brown.edu/dlanman %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Set the image abstraction parameters. % Set bilateral filter parameters. w = 5; % bilateral filter half-width sigma = [3 0.1]; % bilateral filter standard deviations % Set image abstraction paramters. max_gradient = 0.2; % maximum gradient (for edges) sharpness_levels = [3 14]; % soft quantization sharpness quant_levels = 8; % number of quantization levels min_edge_strength = 0.3; % minimum gradient (for edges) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Verify that the input image exists and is valid. if ~exist('A','var') || isempty(A) error('Input image A is undefined or invalid.'); end if ~isfloat(A) || size(A,3) ~= 3 || ... min(A(:)) < 0 || max(A(:)) > 1 error(['Input image A must be a double precision ',... 'matrix of size NxMx3 on the closed ',... 'interval [0,1].']); end % Apply bilateral filter to input image. B = bfilter2(A,w,sigma); % Convert sRGB image to CIELab color space. if exist('applycform','file') B = applycform(B,makecform('srgb2lab')); else B = colorspace('Lab<-RGB',B); end % Determine gradient magnitude of luminance. [GX,GY] = gradient(B(:,:,1)/100); G = sqrt(GX.^2+GY.^2); G(G>max_gradient) = max_gradient; G = G/max_gradient; % Create a simple edge map using the gradient magnitudes. E = G; E(E<min_edge_strength) = 0; % Determine per-pixel "sharpening" parameter. S = diff(sharpness_levels)*G+sharpness_levels(1); % Apply soft luminance quantization. qB = B; dq = 100/(quant_levels-1); qB(:,:,1) = (1/dq)*qB(:,:,1); qB(:,:,1) = dq*round(qB(:,:,1)); qB(:,:,1) = qB(:,:,1)+(dq/2)*tanh(S.*(B(:,:,1)-qB(:,:,1))); % Transform back to sRGB color space. if exist('applycform','file') Q = applycform(qB,makecform('lab2srgb')); else Q = colorspace('RGB<-Lab',qB); end % Add gradient edges to quantized bilaterally-filtered image. C = repmat(1-E,[1 1 3]).*Q;colorspace.m
function varargout = colorspace(Conversion,varargin)
%COLORSPACE Convert a color image between color representations.
% B = COLORSPACE(S,A) converts the color representation of image A
% where S is a string specifying the conversion. S tells the
% source and destination color spaces, S = 'dest<-src', or
% alternatively, S = 'src->dest'. Supported color spaces are
%
% 'RGB' R'G'B' Red Green Blue (ITU-R BT.709 gamma-corrected)
% 'YPbPr' Luma (ITU-R BT.601) + Chroma
% 'YCbCr'/'YCC' Luma + Chroma ("digitized" version of Y'PbPr)
% 'YUV' NTSC PAL Y'UV Luma + Chroma
% 'YIQ' NTSC Y'IQ Luma + Chroma
% 'YDbDr' SECAM Y'DbDr Luma + Chroma
% 'JPEGYCbCr' JPEG-Y'CbCr Luma + Chroma
% 'HSV'/'HSB' Hue Saturation Value/Brightness
% 'HSL'/'HLS'/'HSI' Hue Saturation Luminance/Intensity
% 'XYZ' CIE XYZ
% 'Lab' CIE L*a*b* (CIELAB)
% 'Luv' CIE L*u*v* (CIELUV)
% 'Lch' CIE L*ch (CIELCH)
%
% All conversions assume 2 degree observer and D65 illuminant. Color
% space names are case insensitive. When R'G'B' is the source or
% destination, it can be omitted. For example 'yuv<-' is short for
% 'yuv<-rgb'.
%
% MATLAB uses two standard data formats for R'G'B': double data with
% intensities in the range 0 to 1, and uint8 data with integer-valued
% intensities from 0 to 255. As MATLAB's native datatype, double data is
% the natural choice, and the R'G'B' format used by colorspace. However,
% for memory and computational performance, some functions also operate
% with uint8 R'G'B'. Given uint8 R'G'B' color data, colorspace will
% first cast it to double R'G'B' before processing.
%
% If A is an Mx3 array, like a colormap, B will also have size Mx3.
%
% [B1,B2,B3] = COLORSPACE(S,A) specifies separate output channels.
% COLORSPACE(S,A1,A2,A3) specifies separate input channels.
% Pascal Getreuer 2005-2006
%%% Input parsing %%%
if nargin < 2, error('Not enough input arguments.'); end
[SrcSpace,DestSpace] = parse(Conversion);
if nargin == 2
Image = varargin{1};
elseif nargin >= 3
Image = cat(3,varargin{:});
else
error('Invalid number of input arguments.');
end
FlipDims = (size(Image,3) == 1);
if FlipDims, Image = permute(Image,[1,3,2]); end
if ~isa(Image,'double'), Image = double(Image)/255; end
if size(Image,3) ~= 3, error('Invalid input size.'); end
SrcT = gettransform(SrcSpace);
DestT = gettransform(DestSpace);
if ~ischar(SrcT) & ~ischar(DestT)
% Both source and destination transforms are affine, so they
% can be composed into one affine operation
T = [DestT(:,1:3)*SrcT(:,1:3),DestT(:,1:3)*SrcT(:,4)+DestT(:,4)];
Temp = zeros(size(Image));
Temp(:,:,1) = T(1)*Image(:,:,1) + T(4)*Image(:,:,2) + T(7)*Image(:,:,3) + T(10);
Temp(:,:,2) = T(2)*Image(:,:,1) + T(5)*Image(:,:,2) + T(8)*Image(:,:,3) + T(11);
Temp(:,:,3) = T(3)*Image(:,:,1) + T(6)*Image(:,:,2) + T(9)*Image(:,:,3) + T(12);
Image = Temp;
elseif ~ischar(DestT)
Image = rgb(Image,SrcSpace);
Temp = zeros(size(Image));
Temp(:,:,1) = DestT(1)*Image(:,:,1) + DestT(4)*Image(:,:,2) + DestT(7)*Image(:,:,3) + DestT(10);
Temp(:,:,2) = DestT(2)*Image(:,:,1) + DestT(5)*Image(:,:,2) + DestT(8)*Image(:,:,3) + DestT(11);
Temp(:,:,3) = DestT(3)*Image(:,:,1) + DestT(6)*Image(:,:,2) + DestT(9)*Image(:,:,3) + DestT(12);
Image = Temp;
else
Image = feval(DestT,Image,SrcSpace);
end
%%% Output format %%%
if nargout > 1
varargout = {Image(:,:,1),Image(:,:,2),Image(:,:,3)};
else
if FlipDims, Image = permute(Image,[1,3,2]); end
varargout = {Image};
end
return;
function [SrcSpace,DestSpace] = parse(Str)
% Parse conversion argument
if isstr(Str)
Str = lower(strrep(strrep(Str,'-',''),' ',''));
k = find(Str == '>');
if length(k) == 1 % Interpret the form 'src->dest'
SrcSpace = Str(1:k-1);
DestSpace = Str(k+1:end);
else
k = find(Str == '<');
if length(k) == 1 % Interpret the form 'dest<-src'
DestSpace = Str(1:k-1);
SrcSpace = Str(k+1:end);
else
error(['Invalid conversion, ''',Str,'''.']);
end
end
SrcSpace = alias(SrcSpace);
DestSpace = alias(DestSpace);
else
SrcSpace = 1; % No source pre-transform
DestSpace = Conversion;
if any(size(Conversion) ~= 3), error('Transformation matrix must be 3x3.'); end
end
return;
function Space = alias(Space)
Space = strrep(Space,'cie','');
if isempty(Space)
Space = 'rgb';
end
switch Space
case {'ycbcr','ycc'}
Space = 'ycbcr';
case {'hsv','hsb'}
Space = 'hsv';
case {'hsl','hsi','hls'}
Space = 'hsl';
case {'rgb','yuv','yiq','ydbdr','ycbcr','jpegycbcr','xyz','lab','luv','lch'}
return;
end
return;
function T = gettransform(Space)
% Get a colorspace transform: either a matrix describing an affine transform,
% or a string referring to a conversion subroutine
switch Space
case 'ypbpr'
T = [0.299,0.587,0.114,0;-0.1687367,-0.331264,0.5,0;0.5,-0.418688,-0.081312,0];
case 'yuv'
% R'G'B' to NTSC/PAL YUV
% Wikipedia: http://en.wikipedia.org/wiki/YUV
T = [0.299,0.587,0.114,0;-0.147,-0.289,0.436,0;0.615,-0.515,-0.100,0];
case 'ydbdr'
% R'G'B' to SECAM YDbDr
% Wikipedia: http://en.wikipedia.org/wiki/YDbDr
T = [0.299,0.587,0.114,0;-0.450,-0.883,1.333,0;-1.333,1.116,0.217,0];
case 'yiq'
% R'G'B' in [0,1] to NTSC YIQ in [0,1];[-0.595716,0.595716];[-0.522591,0.522591];
% Wikipedia: http://en.wikipedia.org/wiki/YIQ
T = [0.299,0.587,0.114,0;0.595716,-0.274453,-0.321263,0;0.211456,-0.522591,0.311135,0];
case 'ycbcr'
% R'G'B' (range [0,1]) to ITU-R BRT.601 (CCIR 601) Y'CbCr
% Wikipedia: http://en.wikipedia.org/wiki/YCbCr
% Poynton, Equation 3, scaling of R'G'B to Y'PbPr conversion
T = [65.481,128.553,24.966,16;-37.797,-74.203,112.0,128;112.0,-93.786,-18.214,128];
case 'jpegycbcr'
% Wikipedia: http://en.wikipedia.org/wiki/YCbCr
T = [0.299,0.587,0.114,0;-0.168736,-0.331264,0.5,0.5;0.5,-0.418688,-0.081312,0.5]*255;
case {'rgb','xyz','hsv','hsl','lab','luv','lch'}
T = Space;
otherwise
error(['Unknown color space, ''',Space,'''.']);
end
return;
function Image = rgb(Image,SrcSpace)
% Convert to Rec. 709 R'G'B' from 'SrcSpace'
switch SrcSpace
case 'rgb'
return;
case 'hsv'
% Convert HSV to R'G'B'
Image = huetorgb((1 - Image(:,:,2)).*Image(:,:,3),Image(:,:,3),Image(:,:,1));
case 'hsl'
% Convert HSL to R'G'B'
L = Image(:,:,3);
Delta = Image(:,:,2).*min(L,1-L);
Image = huetorgb(L-Delta,L+Delta,Image(:,:,1));
case {'xyz','lab','luv','lch'}
% Convert to CIE XYZ
Image = xyz(Image,SrcSpace);
% Convert XYZ to RGB
T = [3.240479,-1.53715,-0.498535;-0.969256,1.875992,0.041556;0.055648,-0.204043,1.057311];
R = T(1)*Image(:,:,1) + T(4)*Image(:,:,2) + T(7)*Image(:,:,3); % R
G = T(2)*Image(:,:,1) + T(5)*Image(:,:,2) + T(8)*Image(:,:,3); % G
B = T(3)*Image(:,:,1) + T(6)*Image(:,:,2) + T(9)*Image(:,:,3); % B
% Desaturate and rescale to constrain resulting RGB values to [0,1]
AddWhite = -min(min(min(R,G),B),0);
Scale = max(max(max(R,G),B)+AddWhite,1);
R = (R + AddWhite)./Scale;
G = (G + AddWhite)./Scale;
B = (B + AddWhite)./Scale;
% Apply gamma correction to convert RGB to Rec. 709 R'G'B'
Image(:,:,1) = gammacorrection(R); % R'
Image(:,:,2) = gammacorrection(G); % G'
Image(:,:,3) = gammacorrection(B); % B'
otherwise % Conversion is through an affine transform
T = gettransform(SrcSpace);
temp = inv(T(:,1:3));
T = [temp,-temp*T(:,4)];
R = T(1)*Image(:,:,1) + T(4)*Image(:,:,2) + T(7)*Image(:,:,3) + T(10);
G = T(2)*Image(:,:,1) + T(5)*Image(:,:,2) + T(8)*Image(:,:,3) + T(11);
B = T(3)*Image(:,:,1) + T(6)*Image(:,:,2) + T(9)*Image(:,:,3) + T(12);
AddWhite = -min(min(min(R,G),B),0);
Scale = max(max(max(R,G),B)+AddWhite,1);
R = (R + AddWhite)./Scale;
G = (G + AddWhite)./Scale;
B = (B + AddWhite)./Scale;
Image(:,:,1) = R;
Image(:,:,2) = G;
Image(:,:,3) = B;
end
% Clip to [0,1]
Image = min(max(Image,0),1);
return;
function Image = xyz(Image,SrcSpace)
% Convert to CIE XYZ from 'SrcSpace'
WhitePoint = [0.950456,1,1.088754];
switch SrcSpace
case 'xyz'
return;
case 'luv'
% Convert CIE L*uv to XYZ
WhitePointU = (4*WhitePoint(1))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
WhitePointV = (9*WhitePoint(2))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
L = Image(:,:,1);
Y = (L + 16)/116;
Y = invf(Y)*WhitePoint(2);
U = Image(:,:,2)./(13*L + 1e-6*(L==0)) + WhitePointU;
V = Image(:,:,3)./(13*L + 1e-6*(L==0)) + WhitePointV;
Image(:,:,1) = -(9*Y.*U)./((U-4).*V - U.*V); % X
Image(:,:,2) = Y; % Y
Image(:,:,3) = (9*Y - (15*V.*Y) - (V.*Image(:,:,1)))./(3*V); % Z
case {'lab','lch'}
Image = lab(Image,SrcSpace);
% Convert CIE L*ab to XYZ
fY = (Image(:,:,1) + 16)/116;
fX = fY + Image(:,:,2)/500;
fZ = fY - Image(:,:,3)/200;
Image(:,:,1) = WhitePoint(1)*invf(fX); % X
Image(:,:,2) = WhitePoint(2)*invf(fY); % Y
Image(:,:,3) = WhitePoint(3)*invf(fZ); % Z
otherwise % Convert from some gamma-corrected space
% Convert to Rec. 701 R'G'B'
Image = rgb(Image,SrcSpace);
% Undo gamma correction
R = invgammacorrection(Image(:,:,1));
G = invgammacorrection(Image(:,:,2));
B = invgammacorrection(Image(:,:,3));
% Convert RGB to XYZ
T = inv([3.240479,-1.53715,-0.498535;-0.969256,1.875992,0.041556;0.055648,-0.204043,1.057311]);
Image(:,:,1) = T(1)*R + T(4)*G + T(7)*B; % X
Image(:,:,2) = T(2)*R + T(5)*G + T(8)*B; % Y
Image(:,:,3) = T(3)*R + T(6)*G + T(9)*B; % Z
end
return;
function Image = hsv(Image,SrcSpace)
% Convert to HSV
Image = rgb(Image,SrcSpace);
V = max(Image,[],3);
S = (V - min(Image,[],3))./(V + (V == 0));
Image(:,:,1) = rgbtohue(Image);
Image(:,:,2) = S;
Image(:,:,3) = V;
return;
function Image = hsl(Image,SrcSpace)
% Convert to HSL
switch SrcSpace
case 'hsv'
% Convert HSV to HSL
MaxVal = Image(:,:,3);
MinVal = (1 - Image(:,:,2)).*MaxVal;
L = 0.5*(MaxVal + MinVal);
temp = min(L,1-L);
Image(:,:,2) = 0.5*(MaxVal - MinVal)./(temp + (temp == 0));
Image(:,:,3) = L;
otherwise
Image = rgb(Image,SrcSpace); % Convert to Rec. 701 R'G'B'
% Convert R'G'B' to HSL
MinVal = min(Image,[],3);
MaxVal = max(Image,[],3);
L = 0.5*(MaxVal + MinVal);
temp = min(L,1-L);
S = 0.5*(MaxVal - MinVal)./(temp + (temp == 0));
Image(:,:,1) = rgbtohue(Image);
Image(:,:,2) = S;
Image(:,:,3) = L;
end
return;
function Image = lab(Image,SrcSpace)
% Convert to CIE L*a*b* (CIELAB)
WhitePoint = [0.950456,1,1.088754];
switch SrcSpace
case 'lab'
return;
case 'lch'
% Convert CIE L*CH to CIE L*ab
C = Image(:,:,2);
Image(:,:,2) = cos(Image(:,:,3)*pi/180).*C; % a*
Image(:,:,3) = sin(Image(:,:,3)*pi/180).*C; % b*
otherwise
Image = xyz(Image,SrcSpace); % Convert to XYZ
% Convert XYZ to CIE L*a*b*
X = Image(:,:,1)/WhitePoint(1);
Y = Image(:,:,2)/WhitePoint(2);
Z = Image(:,:,3)/WhitePoint(3);
fX = f(X);
fY = f(Y);
fZ = f(Z);
Image(:,:,1) = 116*fY - 16; % L*
Image(:,:,2) = 500*(fX - fY); % a*
Image(:,:,3) = 200*(fY - fZ); % b*
end
return;
function Image = luv(Image,SrcSpace)
% Convert to CIE L*u*v* (CIELUV)
WhitePoint = [0.950456,1,1.088754];
WhitePointU = (4*WhitePoint(1))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
WhitePointV = (9*WhitePoint(2))./(WhitePoint(1) + 15*WhitePoint(2) + 3*WhitePoint(3));
Image = xyz(Image,SrcSpace); % Convert to XYZ
U = (4*Image(:,:,1))./(Image(:,:,1) + 15*Image(:,:,2) + 3*Image(:,:,3));
V = (9*Image(:,:,2))./(Image(:,:,1) + 15*Image(:,:,2) + 3*Image(:,:,3));
Y = Image(:,:,2)/WhitePoint(2);
L = 116*f(Y) - 16;
Image(:,:,1) = L; % L*
Image(:,:,2) = 13*L.*(U - WhitePointU); % u*
Image(:,:,3) = 13*L.*(V - WhitePointV); % v*
return;
function Image = lch(Image,SrcSpace)
% Convert to CIE L*ch
Image = lab(Image,SrcSpace); % Convert to CIE L*ab
H = atan2(Image(:,:,3),Image(:,:,2));
H = H*180/pi + 360*(H < 0);
Image(:,:,2) = sqrt(Image(:,:,2).^2 + Image(:,:,3).^2); % C
Image(:,:,3) = H; % H
return;
function Image = huetorgb(m0,m2,H)
% Convert HSV or HSL hue to RGB
N = size(H);
H = min(max(H(:),0),360)/60;
m0 = m0(:);
m2 = m2(:);
F = H - round(H/2)*2;
M = [m0, m0 + (m2-m0).*abs(F), m2];
Num = length(m0);
j = [2 1 0;1 2 0;0 2 1;0 1 2;1 0 2;2 0 1;2 1 0]*Num;
k = floor(H) + 1;
Image = reshape([M(j(k,1)+(1:Num).'),M(j(k,2)+(1:Num).'),M(j(k,3)+(1:Num).')],[N,3]);
return;
function H = rgbtohue(Image)
% Convert RGB to HSV or HSL hue
[M,i] = sort(Image,3);
i = i(:,:,3);
Delta = M(:,:,3) - M(:,:,1);
Delta = Delta + (Delta == 0);
R = Image(:,:,1);
G = Image(:,:,2);
B = Image(:,:,3);
H = zeros(size(R));
k = (i == 1);
H(k) = (G(k) - B(k))./Delta(k);
k = (i == 2);
H(k) = 2 + (B(k) - R(k))./Delta(k);
k = (i == 3);
H(k) = 4 + (R(k) - G(k))./Delta(k);
H = 60*H + 360*(H < 0);
H(Delta == 0) = nan;
return;
function Rp = gammacorrection(R)
Rp = real(1.099*R.^0.45 - 0.099);
i = (R < 0.018);
Rp(i) = 4.5138*R(i);
return;
function R = invgammacorrection(Rp)
R = real(((Rp + 0.099)/1.099).^(1/0.45));
i = (R < 0.018);
R(i) = Rp(i)/4.5138;
return;
function fY = f(Y)
fY = real(Y.^(1/3));
i = (Y < 0.008856);
fY(i) = Y(i)*(841/108) + (4/29);
return;
function Y = invf(fY)
Y = fY.^3;
i = (Y < 0.008856);
Y(i) = (fY(i) - 4/29)*(108/841);
return;
runDemo.m
% RUNDEMO Illustrates the use of BFILTER2 and CARTOON. % This demo shows typical usage for the bilateral % filter implemented by BFILTER2. The application % of bilateral filtering to image abstraction is % demonstrated by the CARTOON function. % % Douglas R. Lanman, Brown University, September 2006. % [email protected], http://mesh.brown.edu/dlanman % Load test images. % Note: Must be double precision in the interval [0,1]. img1 = double(imread('einstein.jpg'))/255; img2 = double(imread('mandrill.jpg'))/255; img3 = double(imread('academy.jpg'))/255; % Introduce AWGN into test images. % Note: This will show the benefit of bilateral filtering. img1 = img1+0.03*randn(size(img1)); img2 = img2+0.03*randn(size(img2)); img1(img1<0) = 0; img1(img1>1) = 1; img2(img2<0) = 0; img2(img2>1) = 1; % Set bilateral filter parameters. w = 5; % bilateral filter half-width sigma = [3 0.1]; % bilateral filter standard deviations % Apply bilateral filter to each image. bflt_img1 = bfilter2(img1,w,sigma); bflt_img2 = bfilter2(img2,w,sigma); % Display grayscale input image and filtered output. figure(1); clf; set(gcf,'Name','Grayscale Bilateral Filtering Results'); subplot(1,2,1); imagesc(img1); axis image; colormap gray; title('Input Image'); subplot(1,2,2); imagesc(bflt_img1); axis image; colormap gray; title('Result of Bilateral Filtering'); % Display color input image and filtered output. figure(2); clf; set(gcf,'Name','Color Bilateral Filtering Results'); subplot(1,2,1); imagesc(img2); axis image; colormap gray; title('Input Image'); subplot(1,2,2); imagesc(bflt_img2); axis image; title('Result of Bilateral Filtering'); drawnow; % Apply bilateral filter for a "cartoon" effect. cartoon_img3 = cartoon(img3); % Display color input image and abstracted output. figure(3); clf; set(gcf,'Name','Image Abstraction Input'); imagesc(img3); axis image; title('Input Image'); figure(4); clf; set(gcf,'Name','Result of Image Abstraction'); imagesc(cartoon_img3); axis image; title('Abstracted Image');
实例三：图像的模糊增强
实例图片：
matlab源码：mhzq01.m
%
% 图像的模糊增强
%
% 准备工作
%
x=imread('lena.bmp');
[M,N]=size(x);
x1=double(x);
%
% 基本参数
%
Fd=0.8;
FD=-1*Fd;
% Fe=128;
Fe=128;
Xmax=255;
%
% 模糊特征平面
%
for i=1:M
for j=1:N
P(i,j)=(1+(Xmax-x1(i,j))/Fe)^FD;
end
end
%
% 模糊增强
%
times=1;
for k=1:times
for i=1:M
for j=1:N
if P(i,j) <= 0.5000
P1(i,j)=2*P(i,j)^2;
else
P1(i,j)=1-2*(1-P(i,j))^2;
end
end
end
P=P1;
end
%
% 反模糊化
%
for i=1:M
for j=1:N
I(i,j)=Xmax-Fe*((1/P(i,j))^(1/Fd)-1);
end
end
X=uint8(I);
figure,imshow(x);
figure,imshow(X);