2D Gabour Filter : Formulae:

Transcription

1 2D Gabour Filter : In image processing a Gabor filter is a linear filter used for edge detection. Frequency and orientation representations of Gabor filters are similar to those of the human visual system, and they have been found to be particularly appropriate for texture representation and discrimination. In the spatial domain, a 2D Gabor filter is a Gaussian kernel function modulated by a sinusoidal plane wave. Formulae: Its impulse response is defined by a sinusoidal wave (a plane wave for 2D Gabor filters) multiplied by a Gaussian function. Because of the multiplication-convolution property (Convolution theorem), the Fourier transform of a Gabor filter's impulse response is the convolution of the Fourier transform of the harmonic function and the Fourier transform of the Gaussian function. The filter has a real and an imaginary component representing orthogonal directions. The two components may be formed into a complex number or used individually. Complex Real Imaginary where and In this equation, represents the wavelength of the sinusoidal factor, represents the orientation of the normal to the parallel stripes of a Gabor function, is the phase offset, is the sigma of the Gaussian envelope and is the spatial aspect ratio, and specifies the ellipticity of the support of the Gabor function.

2 MatLab: function gb=gabor_fn(sigma,theta,lambda,psi,gamma) sigma_x = sigma; sigma_y = sigma/gamma; Bounding box nstds = 3; xmax = max(abs(nstds*sigma_x*cos(theta)),abs(nstds*sigma_y*sin(theta))); xmax = ceil(max(1,xmax)); ymax = max(abs(nstds*sigma_x*sin(theta)),abs(nstds*sigma_y*cos(theta))); ymax = ceil(max(1,ymax)); xmin = -xmax; ymin = -ymax; [x,y] = meshgrid(xmin:xmax,ymin:ymax); Rotation x_theta=x*cos(theta)+y*sin(theta); y_theta=-x*sin(theta)+y*cos(theta); gb= exp(-.5*(x_theta.^2/sigma_x^2+y_theta.^2/sigma_y^2)).*cos(2*pi/lambda*x_theta +psi);

3 Laplacian of Gaussian: Laplacian filters are derivative filters used to find areas of rapid change (edges) in images. Since derivative filters are very sensitive to noise, it is common to smooth the image (e.g., using a Gaussian filter) before applying the Laplacian. This two-step process is call the Laplacian of Gaussian (LoG) operation. There are different ways to find an approximate discrete convolution kernal that approximates the effect of the Laplacian. A possible kernel is This is called a negative Laplacian because the central peak is negative. It is just as appropriate to reverse the signs of the elements, using -1s and a +4, to get a positive Laplacian. It doesn't matter. To include a smoothing Gaussian filter, combine the Laplacian and Gaussian functions to obtain a single equation: MatLab: Read Image Reads the Image into an array for further processing X = imread('build.tif'); X = rgb2gray(x); Point detection Y = imread('turbine.tif'); Y1= bwareaopen(y, 20); fplap = [1 1 1; 1-8 1; 1 1 1] Laplacian at a point fplap = [0 1 0; 1-4 1; 0 1 0] Laplacian at a point filtim = imfilter(y,fplap,'symmetric', 'conv');

4 subplot(2,2,1) imshow(y); title('original'); subplot(2,2,2) imshow(filtim); title('laplacian Point Filtered'); subplot(2,2,3) imshow(y-filtim); title('difference Image'); Gaussian Filtering of image fgauss = fspecial('gaussian',[25,25],4.0) 25X25 Gaussian filter with SD =25 is created. filtim = imfilter(x,fgauss,'symmetric', 'conv'); Filter the image by convolution with the above designed filter. filtim now contains the gaussian filtered image. subplot(2,2,1) imshow(x); title('original'); subplot(2,2,2) imshow(filtim); title('gaussian Filtered'); subplot(2,2,3) imshow(x-filtim); title('difference Image'); flap1 = fspecial('laplacian',.2); filtim1 = imfilter(filtim,flap1,'symmetric', 'conv'); fsobel = [-1 0 1; ; ] Grad in y fsobel = [ ; 0 0 0; 1 2 1] Grad in x fsobel = [0-1 -2; 1 0-1; 2 1 0] 45 degree filtim1 = imfilter(filtim,fsobel,'symmetric', 'conv'); subplot(2,2,4) imshow(filtim1); title('log Image'); Spatial Filtering Smoothing <Weighted> &High Boost Filtering favg = [1/16 2/16 1/16; 2/16 4/16 2/16; 1/16 2/16 1/16] filtim = imfilter(x,favg,'symmetric', 'conv'); subplot(2,2,1) imshow(x); title('original');

5 subplot(2,2,2) imshow(filtim); title('weighted Filtering'); subplot(2,2,3) imshow(x-filtim); title('difference Image'); subplot(2,2,4) imshow(x+0.2.*(x-filtim)); title('high Boost Sharpened');

6 Linear integro-differential operator The general form Lu(x)=trA(x) D2u+b(x) u+c(x)u+d(x)+ Rn(u(x+y) u(x) y u(x)χb1(y))dμx(y) where A(x) is a nonnegative matrix for all x, and μx is a nonnegative measure for all x satisfying Rnmin(y2,1)dμx(y)<+ MatLab: Example: I = imread('cameraman.tif'); subplot(2,2,1); imshow(i); title('original Image'); H = fspecial('motion',20,45); MotionBlur = imfilter(i,h,'replicate'); subplot(2,2,2); imshow(motionblur);title('motion Blurred Image'); H = fspecial('disk',10); blurred = imfilter(i,h,'replicate'); subplot(2,2,3); imshow(blurred); title('blurred Image');

7 Edge Detection: Edge detection algorithms operate on the premise that each pixel in a grayscale digital image has a first derivative, with regard to the change in intensity at that point, if a significant change occurs at a given pixel in the image, then a white pixel is placed in the binary image, otherwise, a black pixel is placed there instead. In general, the gradient is calculated for each pixel that gives the degree of change at that point in the image. The question basically amounts to how much change in the intensity should be required in order to constitute an edge feature in the binary image. A threshold value, T, is often used to classify edge points. Some edge finding techniques calculate the second derivative to more accurately find points that correspond to a local maximum or minimum in the first derivative. This technique is often referred to as a Zero Crossing because local maxima and minima are the places where the second derivative equal zero, and its left and right neighbors are non-zero with opposite signs. 1. Canny Edge Detector: Finds edges by looking for local maxima of the gradient of f(x,y). The gradient is calculated using the derivative of a Gaussian filter. The method uses two thresholds to detect strong and weak edges, and includes the weak edges in the output only if they are connnected to strong edges. Therefore, this method is more likely to detect true weak edges. sigma=1; f=zeros(128,128); f(32:96,32:96)=255; [g3, t3]=edge(f, 'canny', [ ], sigma); figure,imshow(g3); t3

8 Hough transform: The purpose of the technique is to find imperfect instances of objects within a certain class of shapes by a voting procedure. generate the picture f=zeros(128,128); f(32:96,32:96)=255; find edges sigma=1; [g3, t3]=edge(f, 'canny', [ ], sigma); Do the Hough transform [H t r] = hough(g3); r and c store column labels... Display the transform in such a way that we can draw points on it later... imshow(h, [], 'XData', t, 'YData', r ); Add axis labels to the picture xlabel('\theta'), ylabel('\rho'); axis on, axis normal; You result should look like this:

9 High Pass Filter: Formula: 1 exp(-(distance)^2/(2*(d0^2))) or 1 lowpass MatLab: function GaussianHighpass a=imread( cameraman.tif ); imshow(a) // original image [m n]=size(a); f_transform=fft2(a); f_shift=fftshift(f_transform); p=m/2; q=n/2; d0=70; for i=1:m for j=1:n distance=sqrt((i-p)^2+(j-q)^2); low_filter(i,j)=1-exp(-(distance)^2/(2*(d0^2)));

10 filter_apply=f_shift.*low_filter; image_orignal=ifftshift(filter_apply); image_filter_apply=abs(ifft2(image_orignal)); imshow(image_filter_apply,[]) // sharp image Split-and-merge algorithm: The purpose of the algorithm is, given a curve composed of line segments, to find a similar curve with fewer points. The algorithm defines 'dissimilar' based on the maximum distance between the original curve and the simplified curve. The simplified curve consists of a subset of the points that defined the original curve. Gif image: MatLab: function g = splitmerge(f, mindim, fun) Q = 2^nextpow2(max(size(f))); [M, N] = size(f); f = padarray(f, [Q - M, Q - N], 'post'); Perform splitting first.

11 S = mindim, fun); Now merge by looking at each quadregion and setting all its elements to 1 if the block satisfies the predicate. Get the size of the largest block. Use full because S is sparse. Lmax = full(max(s(:))); Set the output image initially to all zeros. The MARKER array is used later to establish connectivity. g = zeros(size(f)); MARKER = zeros(size(f)); Begin the merging stage. for K = 1:Lmax [vals, r, c] = qtgetblk(f, S, K); if ~isempty(vals) Check the predicate for each of the regions of size K-by-K with coordinates given by vectors r and c. for I = 1:length(r) xlow = r(i); ylow = c(i); xhigh = xlow + K - 1; yhigh = ylow + K - 1; region = f(xlow:xhigh, ylow:yhigh); flag = feval(fun, region); if flag g(xlow:xhigh, ylow:yhigh) = 1; MARKER(xlow, ylow) = 1; Finally, obtain each connected region and label it with a different integer value using function bwlabel. g = bwlabel(imreconstruct(marker, g)); Crop and exit g = g(1:m, 1:N); function v = split_test(b, mindim, fun) THIS FUNCTION IS PART OF FUNCTION SPLIT-MERGE. IT DETERMINES WHETHER QUADREGIONS ARE SPLIT. The function returns in v logical 1s (TRUE) for the blocks that should be split and logical 0s (FALSE) for those that should not. Quadregion B, passed by qtdecomp, is the current decomposition of the image into k blocks of size m-by-m. k is the number of regions in B at this point in the procedure. k = size(b, 3); Perform the split test on each block. If the predicate function (fun) returns TRUE, the region is split, so we set the appropriate element of v to TRUE. Else, the appropriate element of v is set to FALSE. v(1:k) = false; for I = 1:k

12 quadregion = B(:, :, I); if size(quadregion, 1) <= mindim v(i) = false; continue flag = feval(fun, quadregion); if flag v(i) = true; K-Means clustering algorithm : This algorithm aims at minimizing an objective function, in this case a squared error function. The objective function, where is a chosen distance measure between a data point and the cluster centre, is an indicator of the distance of the n data points from their respective cluster centres. Let's make some fake data with two groups n=75; sample size x=[randn(n,1)+2;randn(n,1)+4.75]; y=[randn(n,1)+2;randn(n,1)+4.75];

13 the true group identity groups=[ones(n,1);ones(n,1)+1]; plot the data scatter(x,y,50,groups,'filled') data=[x,y]; IDX=kmeans(data,2); Run k-means, asking for two groups Let's make some fake data with two groups n=150; sample size x=[randn(n,1)+3;randn(n,1)+3]; y=[randn(n,1)+3;randn(n,1)+3]; plot the data subplot(1,2,1) plot(x,y,'ok','markerfacecolor','k') now divide into two using k-means and plot the results data2=[x,y]; IDX=kmeans(data2,2); plot the k-means results subplot(1,2,2) scatter(x,y,50,idx,'filled') Run k-means for a range of k for k=2:6 IDX=kmeans(data,k); The data with two groups [S,H] = silhouette(data, IDX); sila(k)=mean(s); The mean silhoette value for two groups IDX=kmeans(data2,k); The data with one group [S,H] = silhouette(data2, IDX); silb(k)=mean(s); The mean silhoette value for one group clf hold on plot(1:6, sila,'ok-','markerfacecolor','k') 2 groups plot(1:6, silb,'or-','markerfacecolor','r') 1 group set(gca,'xtick',1:6) xlabel('k') ylabel('mean silhouette value') hold off