EX.NO: DISPLAY OF GRAYSCALE IMAGES DATE: AIM: To write a MATLAB program

a) To read and display an image. b) To perform data type conversion to 8 bit, 16 bit, 32 bit and double data

types. c) To perform file format conversion in jpg, jpeg, png, bmp and tiff formats. d) To perform arithmetic and logical operations on different images.

SOFTWARE USED: MATLAB Version 2013. THEORY: Types and classes of images: Name Description Double Double precision, floating point numbers

in approximate range 10308(8 bytes per element)

Single Single precision, floating point with value in range 10308(4 bytes per element)

Uint8 Unsigned 8 bit integer[0, 255] (1 byte per element)

Unit16 Unsigned 16 bit integer[0 , 65536] (2 byte/element)

Uint32 Unsigned 32 bit integer[0 , 4294967295] (4 byte/element)

Char Characters (2 bytes/element) Logical Values are 0 or 1 (1 byte/element) Image types: The toolbox supports 4 types of images:

Grayscale Binary Indexed RGB

Grayscale image, also called gray level image, is a data matrix whose values represent shades of grey.

Binary image: Each pixel assumes one of only two discrete values 1 or 0. A binary image is started as a logical array of 0s or 1s. Thus, a numeric array is converted into binary using function logical. BW refers to binary images. Indexed image: It consists of an array and a colourmap matrix. The pixel values in the array are direct indices into a colourmap. This uses the variable X to refer to the array and map refers to the colourmap. The colourmap matrix is an m-by-3 array of class double containing floating point values in the range [0,1]. Each row of a map specifies red, green and blue components of a single colour. RGB images use three numbers for each pixel, allowing possible use of millions of colours within the image at the cost of requiring three times as much space as grayscale images do. Image files and formats: They are the standardized means of organizing and storing digital images.

a) JPEG/JFIF: Joint Photographic Experts Group is a compression method. JPEG compressed images are actually stored in JFIF (JPEG File

Interchange Format). JPEG in most cases is a lossy compression. JPEG/JFIF filename extension is JPG or JPEG

b) TIFF (Tagged Image File Formats): It is a flexible format that manually saves 8 bits or 16 bits per

colour(RGB) for 24 bits and 48 bits total. Filename extension: TIFF or TIF E.g.: Digital Camera Images

c) GIF (Graphics Interchange Format): It is limited to an 8 bit palette or 256 colours. This makes GIF format

suitable for simplediagrams, shapes etc. Supports animation Lossless compression that is more effective

d) PNG(Portable Network Graphics): Supports true colour(16 million) The lossless PNG format is best suited for editing pictures. The lossy

formats like PNG are best suited for final distribution. e) BMP (Bitmap File Format):

Handles graphics files within MS Windows OS BMP files are uncompressed, hence they are large

SYNTAXES USED: IMREAD IMREAD reads image from graphics file. a=imread(filename.fmt) reads a grayscale or color image from the file specified by the string FILENAME. The text string fmt specifies the format of the file by its standard file extension. The return value A is an array containing the image data. If the file contains a grayscale image, A is an M-by-N array. If the file contains a true color image, A is an M-by-N by-3 array. For tiff files containing color images that use the CMYK color space, A is an M-by-N-by-4 array. IMSHOW IMSHOW displays image in Handle Graphics. a=imshow(i,[low high]) displays the grayscale image I, specifying the display range for I in [low high].the value low (and any value less than low) displays as black, the value high (and any value greater than high) displays as white. Values in between are displayed as intermediate shades of gray, using default number of gray levels. if you use an empty matrix([]) for[low high], imshow uses [min(I(:))]; that is, the min value in I is displayed as black, and the max value is displayed as white. imshow(rgb) displays the true color image rgb. imshow(bw) displays the binary image bw. imshow displays pixels with 0 as black and pixels with 1 as white. IMRESIZE It resizes image. b=imresize(a,scale) returns an image that is scale times the size of a, which is grayscale, rgb, or binary image. b=imresize(a,[numrows numcols]) resizes the image so that it has specified number of rows and columns. either numrows or numcols may be NaN, in which case imresize computes the number of rows or columns automatically in order to preserve the image aspect ratio. IMFINFO IMFINFO displays information about graphics file. a=imfinfo(filename.fmt) returns a structure whose fields contain information about an image in a graphics file. It displays the information about file size, height, width, resolution, image type, etc. RGB2GRAY Converts RGB image or colormap to grayscale. rgb2gray converts RGB images to grayscale by eliminating the hue and saturation information while retaining the luminance. IMADD Adds one image from another or adds constant to an image. Z=imadd(X,Y) adds each element in array X with the corresponding element in array Y and returns the sum in the corresponding element of the output array Z. X and Y are real, non-sparse numeric arrays with the same size and class, or Y is a scalar double. Z

has the same size and class as X, unless X is logical, in which case Z is double. If X and Y are integer arrays, elements in the output that exceed the range of the integer type are truncated, and fractional values are rounded. IMSUBTRACT Subtract one image from another or subtract constant from image Z = imsubtract(X,Y) subtracts each element in array Y from the corresponding element in array X and returns the difference in the corresponding element of the output array Z. X and Y are real, non-sparse numeric arrays of the same size and class, or Y is a double scalar. The array returned, Z, has the same size and class as X unless X is logical, in which case Z is double. If X is an integer array, elements of the output that exceed the range of the integer type are truncated, and fractional values are rounded. IMMULTIPLY Multiplication of two images or multiplication of an image by a constant Z = immultiply(X,Y) multiplies each element in array X by the corresponding element in array Y and returns the product in the corresponding element of the output array Z. If X and Y are real numeric arrays with the same size and class, then Z has the same size and class as X. If X is a numeric array and Y is a scalar double, then Z has the same size and class as X. If X is logical and Y is numeric, then Z has the same size and class as Y. If X is numeric and Y is logical, then Z has the same size and class as X. immultiply computes each element of Z individually in double-precision floating point. If X is an integer array, then elements of Z exceeding the range of the integer type are truncated, and fractional values are rounded. If X and Y are numeric arrays of the same size and class, you can use the expression X.*Y instead of immultiply. IMDIVIDE Division of the image by a constant value Z = imdivide(X,Y) divides each element in the array X by the corresponding element in array Y and returns the result in the corresponding element of the output array Z. X and Y are real, non-sparse numeric arrays with the same size and class, or Y can be a scalar double. Z has the same size and class as X and Y, unless X is logical, in which case Z is double. If X is an integer array, elements in the output that exceed the range of integer type are truncated, and fractional values are rounded. If X and Y are numeric arrays of the same size and class, you can use the expression X./Y instead of imdivide.

LOGICAL OPERATIONS True or false (Boolean) conditions The logical data type represents true or false states using the numbers 1 and 0, respectively. Certain MATLAB functions and operators return logical values to indicate fulfillment of a condition. You can use those logical values to index into an array or execute conditional code. FUNCTIONS bitand Find logical AND cmp Find logical NOT bitor Find logical OR bitxor Logical exclusive-OR

TYPE AND FILE CONVERSION clear; clc; img1=imread('rice.png'); subplot(221); imshow(img1); title('uint8'); whos('img1'); uint16=im2uint16(img1); subplot(222); imshow(uint16); title('uint16'); whos('uint16'); double=im2double(img1); subplot(223); imshow(double); title('double'); whos('c'); imwrite(img1,'convert.tif'); tif=imread('convert.tif'); subplot(224); imshow(tif); title('Tif'); whos('tif'); inf=imfinfo('rice.png') info=imfinfo('convert.tif') ARITHMETIC OPERATION: img2=imread('cameraman.tif'); figure; subplot(331); imshow(img2); title('Camera Man'); whos('img2'); subplot(332); imshow(img1); title('Rice'); add=imadd(img1,img2); subplot(333); imshow(add); title('Added');

whos('add'); sub=imsubtract(img1,img2); subplot(334); imshow(sub); title('Subtracted'); whos('sub'); div1=imdivide(img1,2); subplot(335); imshow(div1); title('Divided by 2'); whos('div1'); div2=imdivide(img1,0.2); subplot(336); imshow(div2); title('Divided by 0.2'); whos('div2'); mul1=immultiply(img1,2); subplot(337); imshow(mul1); title('Multiply by 2'); whos('mul1'); mul2=immultiply(img1,0.2); subplot(338); imshow(mul2); title('Multiply by 0.2'); whos('mul2'); LOGICAL OPERATION: im1=imread('Rice.png'); im2=imread('Coins.png'); im3=imresize(im2,[256 256]); or=bitor(im1,im3); subplot(233); imshow(or); title('OR'); whos('or*'); and=bitand(im1,im3); subplot(234); imshow(and); title('AND'); whos('and*');

xor=bitxor(im1,im3); subplot(235); imshow(xor); title('XOR'); whos('xor*'); subplot(231); imshow(im1); title('Image1'); subplot(232); imshow(im3); title('Image2');

OBSERVATION: Name Size Bytes Class Attributes img1 256x256 65536 uint8 Name Size Bytes Class Attributes uint16 256x256 131072 uint16 Name Size Bytes Class Attributes tif 256x256 65536 uint8 inf = Filename: [1x62 char] FileModDate: '26-Jan-2003 01:03:06' FileSize: 44607 Format: 'png' FormatVersion: [] Width: 256 Height: 256 BitDepth: 8 ColorType: 'grayscale' FormatSignature: [137 80 78 71 13 10 26 10] Colormap: [] Histogram: [] InterlaceType: 'none' Transparency: 'none' SimpleTransparencyData: [] BackgroundColor: [] RenderingIntent: [] Chromaticities: [] Gamma: [] XResolution: [] YResolution: [] ResolutionUnit: [] XOffset: [] YOffset: [] OffsetUnit: []

SignificantBits: [] ImageModTime: '27 Dec 2002 19:57:12 +0000' Title: [] Author: [] Description: 'Rice grains' Copyright: 'Copyright The MathWorks, Inc.' CreationTime: [] Software: [] Disclaimer: [] Warning: [] Source: [] Comment: [] OtherText: [] info = Filename: '\\psf\Home\Documents\MATLAB\convert.tif' FileModDate: '17-Sep-2015 10:29:31' FileSize: 66250 Format: 'tif' FormatVersion: [] Width: 256 Height: 256 BitDepth: 8 ColorType: 'grayscale' FormatSignature: [73 73 42 0] ByteOrder: 'little-endian' NewSubFileType: 0 BitsPerSample: 8 Compression: 'PackBits' PhotometricInterpretation: 'BlackIsZero' StripOffsets: [8 8265 16474 24733 32987 41198 49461 57732] SamplesPerPixel: 1 RowsPerStrip: 32 StripByteCounts: [8257 8209 8259 8254 8211 8263 8271 8263] XResolution: 72 YResolution: 72 ResolutionUnit: 'Inch' Colormap: [] PlanarConfiguration: 'Chunky' TileWidth: [] TileLength: []

TileOffsets: [] TileByteCounts: [] Orientation: 1 FillOrder: 1 GrayResponseUnit: 0.0100 MaxSampleValue: 255 MinSampleValue: 0 Thresholding: 1 Offset: 65996 Name Size Bytes Class Attributes img2 256x256 65536 uint8 Name Size Bytes Class Attributes add 256x256 65536 uint8 Name Size Bytes Class Attributes sub 256x256 65536 uint8 Name Size Bytes Class Attributes div1 256x256 65536 uint8 Name Size Bytes Class Attributes div2 256x256 65536 uint8 Name Size Bytes Class Attributes mul1 256x256 65536 uint8 Name Size Bytes Class Attributes

mul2 256x256 65536 uint8 Name Size Bytes Class Attributes

or 256x256 65536 uint8 Name Size Bytes Class Attributes and 256x256 65536 uint8 OUTPUT: FILE CONVERSION

ARITHMETIC OPERATION

LOGICAL OPERATION:

EX.NO: MASKING AND THRESHOLDING DATE- AIM: To write a MATLAB program

a) To read and display an image. b) To create a grayscale image and perform masking operation c) To perform thresholding operation.

SOFTWARE USED: MATLAB Version 2013. THEORY THRESHOLDING Thresholding is a method of image segmentation based on the intensity histogram of the image. Suppose an image f(x,y) consists of a light object on a dark background in such a way that object and background pixels have intensity levels grouped into two dominant modes. Here, it is easier to extract by selecting a threshold T that separates these modes. Then any point (x,y) for which f(x,y) T is called object point; otherwise the point is called background point. The threshold image g(x,y) is defined as

Single threshold Multiple Threshold

Thresholding may be viewed as a operation involving the function T of the form

Where

a. f(x,y) = gray level of point (x,y) b. p(x,y) = local property of the point (x,y)

c. x,y = the spatial coordinates of the point

When T depends only on f(x,y) ie, only the gray level values, the threshold is called Global Threshold When T depends only on both f(x,y) and p(x,y) ie, the gray level values & the local properties, the threshold is called Local Threshold When T depends only f(x,y), p(x,y) & x,y ie, the gray level values, the local properties as well as the spatial coordinates of the point the threshold is called Dynamic or Adaptive Threshold SYNTAXES USED: IMREAD IMSHOW IMPIXEL REGION impixelregion creates a Pixel Region tool associated with the image displayed in the current figure, called the target image. The Pixel Region tool opens a separate figure window containing an extreme close-up view of a small region of pixels in the target image. The Pixel Region rectangle defines the area of the target image that is displayed in the Pixel Region tool. You can move this rectangle over the target image using the mouse to view different regions. To get a closer view of the pixels displayed in the tool, use the zoom buttons on the Pixel Region tool toolbar or change the size of the Pixel Region rectangle using the mouse. MAT2GRAY I = mat2gray(A, [amin amax]) converts the matrix A to the intensity image I. The returned matrix I contains values in the range 0.0 (black) to 1.0 (full intensity or white). amin and amax are the values in A that correspond to 0.0 and 1.0 in I. Values less than amin become 0.0, and values greater than amax become 1.0. I = mat2gray(A) sets the values of amin and amax to the minimum and maximum values in A. gpuarrayI = mat2gray(gpuarrayA,___) performs the operation on a GPU.

MASKING OF IMAGE co=imread('Rice.png'); co1=im2double(co); subplot(221); imshow(co1); title('Coins'); whos('co1*'); ma=zeros(256,256); ma1=im2double(ma); title('Mask Unprocessed'); for i=107:140; j=16:28; ma1(i,j)=1; end subplot(222); imshow(ma1); fi=immultiply(co1,ma1); subplot(223); imshow(fi); THRESHOLDING a=imread('coins.png'); subplot(231); imshow(a); title('Coins'); subplot(232); imhist(a); title('Histogram'); b1=a>99; subplot(233); imshow(b1); title('Using Threshold Value'); BW=im2bw(a,0.4667); subplot(234); imshow(BW); title('Using Histogram'); level=graythresh(a); BW1=im2bw(b1,level); subplot(235); imshow(BW1); title('Using Greythresh'); display(level);

OBSERVATION: MASKING

THRESHOLDING

EX.NO: ADDITION OF NOISES AND FILTERING DATE: AIM: To write a MATLAB program

a) To add the following noises to an image: Salt & pepper Speckle Poisson Gaussian

b) To filter an image using the following types of filter: Median Weiner Gaussian Laplacian

SOFTWARE REQUIRED: MATLAB Version 2013. SYNTAX USED: IMNOISE Add noise to image. J = IMNOISE (I, TYPE,) Add noise of a given TYPE to the intensity image.

'gaussian' Gaussian white noise with constant mean and variance

'poisson' Poisson noise

'salt & pepper' On and off pixels

'speckle' Multiplicative noise

Types:

Gaussian: Gaussian white noise with constant mean and variance. J = IMNOISE(I,'gaussian',M,V) adds Gaussian white noise of mean M and variance V to the image I. When unspecified, M and V default from 0 to 0.01 respectively.

Salt And pepper: "On and Off" pixels.

J = IMNOISE(I, salt& pepper',D) adds "salt and pepper" noise to the image I, where D is the noise density. This affects approximately D*numel(I) pixels. The default for D is 0.05.

Speckle: Multiplicative noise. J = IMNOISE(I,'speckle',V) adds multiplicative noise to the image I,using the equation J = I + n*I, where n is uniformly distributed random noise with mean 0 and variance V. The default for V is 0.04.

Poisson: Poisson noise. J = IMNOISE(I, poisson') generates Poisson noise from the data instead of adding artificial noise to the data. IfI is double precision, then input pixel values are interpreted as means of Poisson distributions scaled up by 1e12. For example, if an input pixel has the value 5.5e-12, then the corresponding output pixel will be generated from a Poisson distribution with mean of 5.5 and then scaled back down by 1e12. If I is single precision, the scale factor used is 1e6. If I is uint8 or uint16, then input pixel values are used directly without scaling. For example, if a pixel in a uint8 input has the value 10, then the corresponding output pixel will be generated from a Poisson distribution with mean 10.

IMFILTER: IMFILTER N-D filtering of multidimensional images. B = IMFILTER(A,H) filters the multidimensional array A with the multidimensional filter H. A can be logical or it can be a nonsparse numeric array of any class and dimension. The result, B has the same size and class as A. Replace h in this syntax with

g for Gaussian filter. l for laplacian filter.

Types of filters

Median: MEDFILT2 2-D median filtering.

B = MEDFILT2(A,[M N]) performs median filtering of the matrix A in two dimensions. Each output pixel contains the median value in the M-by-N neighborhood around the corresponding pixel in the input image. MEDFILT2 pads the image with zeros on the edges, so the median values for the points within [M N]/2 of the edges may appear distorted.

Wiener: WIENER2 2-D adaptive noise-removal filtering.

WIENER2 lowpass filters an intensity image that has been degraded by constant power additive noise. WIENER2 uses a pixel-wise adaptive Wiener method based on statistics estimated from a local neighborhood of each pixel. J = WIENER2(I,[M N],NOISE) filters the image I using pixel-wise adaptive Wiener filtering, using neighborhoods of size M-by-N to estimate the local image mean and standard deviation. If you omit the [M N] argument, M and N default to 3. The additive noise (Gaussian white noise) power is assumed to be NOISE. FSPECIAL: FSPECIAL Create predefined 2-D filters. H = FSPECIAL(TYPE) creates a two-dimensional filter H of the specified type and returns H as correlation kernel.

Value Description

Average Averaging filter

gaussian Gaussian lowpass filter

laplacian Approximates the two-dimensional Laplacian operator

Prewitt Prewitt horizontal edge-emphasizing filter

Sobel Sobel horizontal edge-emphasizing filter

Types:

Gaussian: Gaussian lowpass filter.

H = FSPECIAL('gaussian',HSIZE,SIGMA) returns a rotationally symmetric Gaussian lowpass filter of size HSIZE with standard deviation SIGMA (positive). HSIZE can be a vector specifying the number of rows and columns in H or a scalar, in which case H is a square matrix. The default HSIZE is [3 3], the default SIGMA is 0.5.

Laplacian: filter approximating the 2-D Laplacian operator.

H = FSPECIAL('laplacian',ALPHA) returns a 3-by-3 filter approximating the shape of the two-dimensional Laplacian operator. The parameter ALPHA controls the shape of the Laplacian and must be in the range 0.0 to 1.0. The default ALPHA is 0.2.

Mean(A):

M = mean(A) returns the mean value along the first array dimension of A whose size does not equal 1.

If A is a vector => mean(A) returns the mean of the elements.

If A is a nonempty, nonvector matrix => mean(A) treats the columns of A as vectors and returns a row vector whose elements are the mean of each column.

If A is an empty 0-by-0 matrix => mean(A) returns NaN.

If A is a multidimensional array => mean(A) treats the values along the first array dimension whose size does not equal 1 as vectors and returns an array of row vectors.

ADDITION OF NOISE img=imread('Rice.png'); noi=imnoise(img,'salt & pepper',0.05); subplot(331); imshow(img); title('Rice'); subplot(332); imshow(noi); title('Salt and Pepper'); img2=imread('coins.png'); noi2=imnoise(img2,'gaussian',0.07,0.07); subplot(333); imshow(img2); title('Coins'); subplot(334); imshow(noi2); title('Gaussian'); noi3=imnoise(img,'poisson'); subplot(335); imshow(noi3); title('Poisson'); noi4=imnoise(img,'speckle',0.07); subplot(336); imshow(noi4); title('Speckle'); FILTERING %speckle noise a=imread('cameraman.tif'); subplot(331); imshow(a); title('original image'); b=imnoise(a,'speckle',0.01); subplot(332); imshow(b); title('speckle noise'); K = filter2(fspecial('average',3),b)/255; subplot(333); imshow(K); title('Average'); L = medfilt2(b,[3 3]);

subplot(334); imshow(L); title('Median'); m = wiener2(b,[5 5]); subplot(335); imshow(m); title('Weiner'); n=filter2(fspecial('gaussian',3,0.5),b)/255; subplot(336); imshow(n); title('Gaussian'); o=filter2(fspecial('log',[5 5],0.5),b)/255; subplot(337); imshow(o); title('Log'); %poisson noise a=imread('cameraman.tif'); subplot(331); imshow(a); title('original image'); c=imnoise(a,'poisson'); subplot(332); imshow(c); title('poisson noise'); K = filter2(fspecial('average',3),c)/255; subplot(333); imshow(K); title('Average'); L = medfilt2(c,[3 3]); subplot(334); imshow(L); title('Median'); m = wiener2(c,[5 5]); subplot(335); imshow(m); title('Weiner'); n=filter2(fspecial('gaussian',3,0.5),c)/255; subplot(336); imshow(n); title('Gaussian');

o=filter2(fspecial('log',[5 5],0.5),c)/255; subplot(337); imshow(o); title('Log'); %salt&pepper noise a=imread('cameraman.tif'); subplot(331); imshow(a); title('original image'); d=imnoise(a,'salt & pepper',0.02); subplot(332); imshow(d); title('salt&pepper noise'); K = filter2(fspecial('average',3),d)/255; subplot(333); imshow(K); title('Average'); L = medfilt2(d,[3 3]); subplot(334); imshow(L); title('Median'); m = wiener2(d,[5 5]); subplot(335); imshow(m); title('Weiner'); n=filter2(fspecial('gaussian',3,0.5),d)/255; subplot(336); imshow(n); title('Gaussian'); o=filter2(fspecial('log',[5 5],0.5),d)/255; subplot(337); imshow(o); title('Log'); %gaussian noise a=imread('cameraman.tif'); subplot(331); imshow(a); title('original image'); e=imnoise(a,'gaussian',0.001,0.01); subplot(332);

imshow(e); title('gaussian noise') K = filter2(fspecial('average',3),e)/255; subplot(333); imshow(K); title('Average'); L = medfilt2(e,[3 3]); subplot(334); imshow(L); title('Median'); m = wiener2(e,[5 5]); subplot(335); imshow(m); title('Weiner'); n=filter2(fspecial('gaussian',3,0.5),e)/255; subplot(336); imshow(n); title('Gaussian'); o=filter2(fspecial('log',[5 5],0.5),e)/255; subplot(337); imshow(o); title('Log');

OBSERVATION NOISE

FILTERING OF SPECKLE NOISE

FILTERING OF SALT&PEPPER NOISE

FILTERING OF POISSON NOISE

FILTERING OF GAUSSIAN NOISE

EX.NO: MORPHOLOGICAL OPERATION DATE: AIM: To write a MATLAB program to perform the following morphological operations on the given image:

a) Dilation b) Erosion c) Opening & closing

SOFTWARE USED: MATLAB Version 2013. SYNTAXES USED: IMREAD IMSHOW IMDIVIDE IMRESIZE IMFINFO IMFINFO displays information about graphics file. a=imfinfo(filename.fmt) returns a structure whose fields contain information about an image in a graphics file. It displays the info about file size, height, width, resolution, image type, etc. RGB2GRAY Converts RGB image or colormap to grayscale. rgb2gray converts RGB images to grayscale by eliminating the hue and saturation information while retaining the luminance STREL Creates a stereo element of desired shape SE = strel(shape, parameters) creates a structuring element, SE, of the type specified by shape. This table lists all the supported shapes. Depending on shape, strel can take additional parameters. See the syntax descriptions that follow for details about creating each type of structuring element. SE = strel('ball', R, H, N) SE = strel('diamond', R) SE = strel('disk', R, N) SE = strel('line', LEN, DEG) SE = strel('octagon', R) SE = strel('rectangle', MN) SE = strel('square', W)

IMERODE IM2 = imerode(IM,SE) erodes the grayscale, binary, or packed binary image IM, returning the eroded imageIM2. The argument SE is a structuring element object or array of structuring. IM2 = imerode(IM,NHOOD) erodes the image IM, where NHOOD is an array of 0's and 1's that specifies the structuring element neighbourhood. IMDILATE IM2 = imdilate(IM,SE) dilates the grayscale, binary, or packed binary image IM, returning the dilated image,IM2. The argument SE is a structuring element object, or array of structuring element objects, returned by the strelfunction.If IM is logical and the structuring element is flat, imdilate performs binary dilation; otherwise, it performs grayscale dilation. If SE is an array of structuring element objects, imdilate performs multiple dilations of the input image, using each structuring element in SE in succession. IMOPEN IM2 = imopen(IM,SE) performs morphological opening on the grayscale or binary image IM with the structuring element SE. The argument SE must be a single structuring element object, as opposed to an array of objects. The morphological open operation is erosion followed by a dilation, using the same structuring element for both operations. IM2 = imopen(IM,NHOOD) performs opening with the structuring element strel(NHOOD), where NHOOD is an array of 0's and 1's that specifies the structuring element neighbourhood. IMCLOSE IM2 = imclose(IM,SE) performs morphological closing on the gray scale or binary image IM, returning the closed image, IM2. The structuring element, SE, must be a single structuring element object, as opposed to an array of objects. The morphological close operation is a dilation followed by an erosion, using the same structuring element for both operations. BWMORPH BW2 = bwmorph(BW,operation) applies a specific morphological operation to the binary image BW.BW2 = bwmorph(BW,operation,n) applies the operation n times. n can be Inf, in which case the operation is repeated until the image no longer changes.

MORPHOLOGICAL OPERATION DILATION a = imread('cameraman.tif'); s1 = strel('line',10,0);disp(s1); b = imdilate(a,s1); subplot(421); imshow(a); title('Original image') subplot(422) imshow(b); title('Dilated image-line 1'); s2 = strel('line',10,90);disp(s2); c = imdilate(a,s2); subplot(423) imshow(c); title('Dilated image-line 2'); s3 = strel('line',10,45);disp(s3); d = imdilate(a,s3); subplot(424) imshow(d); title('Dilated image-line 3'); s4 = strel('ball',5,8);disp(s4); e= imdilate(a,s4); subplot(425) imshow(e); title('Dilated image-ball'); s5 = strel('disk',6,6);disp(s5); f= imdilate(a,s5); subplot(426) imshow(f); title('Dilated image-disc'); s6 = strel('diamond',6);disp(s6); g= imdilate(a,s6); subplot(427) imshow(g); title('Dilated image-diamond'); EROSION a = imread('coins.png'); s1 = strel('line',10,0);disp(s1); b = imerode(a,s1);

subplot(421); imshow(a); title('Original image') subplot(422) imshow(b); title('Eroded image-line 1'); s2 = strel('line',10,90);disp(s2); c = imerode(a,s2); subplot(423) imshow(c); title('Eroded image-line 2'); s3 = strel('line',10,45);disp(s3); d = imerode(a,s3); subplot(424) imshow(d); title('Eroded image-line 3'); s4 = strel('ball',5,8);disp(s4); e= imerode(a,s4); subplot(425) imshow(e); title('Eroded image-ball'); s5 = strel('disk',6,6);disp(s5); f= imerode(a,s5); subplot(426) imshow(f); title('Eroded image-disc'); s6 = strel('diamond',4);disp(s6); g= imerode(a,s6); subplot(427) imshow(g); title('Eroded image-diamond'); CLOSED a = imread('cameraman.tif'); s1 = strel('line',10,0);disp(s1); b = imclose(a,s1); subplot(421); imshow(a); title('Original image') subplot(422) imshow(b);

title('Closed image-line 1'); s2 = strel('line',10,90);disp(s2); c = imclose(a,s2); subplot(423) imshow(c); title('Closed image-line 2'); s3 = strel('line',10,45);disp(s3); d = imclose(a,s3); subplot(424) imshow(d); title('Closed image-line 3'); s4 = strel('ball',5,8);disp(s4); e= imclose(a,s4); subplot(425) imshow(e); title('Closed image-ball'); s5 = strel('disk',6,6);disp(s5); f= imclose(a,s5); subplot(426) imshow(f); title('Closed image-disc'); s6 = strel('diamond',4);disp(s6); g= imclose(a,s6); subplot(427) imshow(g); title('Closed image-diamond'); OPENED a = imread('cameraman.tif'); s1 = strel('line',10,0);disp(s1); b = imopen(a,s1); subplot(421); imshow(a); title('Original image') subplot(422) imshow(b); title('Opened image-line 1'); s2 = strel('line',10,90);disp(s2); c = imopen(a,s2); subplot(423) imshow(c);

title('Opened image-line 2'); s3 = strel('line',10,45);disp(s3); d = imopen(a,s3); subplot(424) imshow(d); title('Opened image-line 3'); s4 = strel('ball',5,8);disp(s4); e= imopen(a,s4); subplot(425) imshow(e); title('Opened image-ball'); s5 = strel('disk',6,6);disp(s5); f= imopen(a,s5); subplot(426) imshow(f); title('Opened image-disc'); s6 = strel('diamond',4);disp(s6); g= imopen(a,s6); subplot(427) imshow(g); title('Opened image-diamond');

OBSERVATION DILATED

ERODED

CLOSED

OPENED

EX.NO: GRAY LEVEL ENHANCEMENT DATE: AIM: To write a MATLAB program to perform the following enhancements on an image:

a) Brightness and Contrast Adjustment b) Gamma Transformation/ Power Law Transformation c) Gray Level Slicing d) Bit Plane Slicing e) Logarithmic transformation f) Contrast stretching

SOFTWARE USED: MATLAB Version 2013. THEORY: Thresholding: A special case of contrast stretching where ==0is called clipping. Thresholding is a special case of clipping where a=b=t and the output becomes binary.

Contrast stretching: Low contrast images occur often due to poor or non-uniform lightning conditions or due to non-linearity or small dynamic range of the imaging sensor. The figure shows atypical contrast stretching transformation, which can be expressed as: V={ u , 0u1

Gray level slicing: Highlighting a specific range of gray levels in an image. There are two basic themes for gray level slicing. One approach is to display a high value for all the gray levels in the range of interest and a low value for all other gray levels (Binary image, Fig(a)) The second approach is to brighten the desired range of gray levels but preserve the background and gray-level tonalities in the image.(Fig(b))

Bit plane slicing:

Highlighting the contribution made to the total image appearance by specific bits might be perceived.

Each pixel representation by 8 bits, when separated into bit planes ranging from 0 to 7, the 0th plane represents least significant bit to bit plane 7th the most significant bit.

0-plane : lower order bits in bytes 7-plane: higher order bits

Separating bit planes is useful for analyzing relative importance played by each bit. The higher order bits contain majority of visually significant data.

Mapping all pixels between 0 to 127 to one level & 128-255 to another gray level.

Log transformations: The general form of the log transformation is

s = c log(1+r) c: constant

The shape of the log curve shows that this transformation maps a narrow range of low gray level values in the input image into a wider range of output levels. The opposite is true for higher levels of input levels. We would use a transformation of this type to expand the values of dark pixels in an image while compressing the higher level values. The opposite is true for inverse log transformation.

Power law transformations: The basic form of power law transformation is

crs = C, : positive constants

Power law curves with the fractional values of map a narrow range of dark input values into a wider range of output values, with the opposite being true for higher values of input levels.

SYNTAXES USED: IMREAD IMSHOW IMRESIZE IMFINFO RGB2GRAY IMADD IMADJUST IMADJUST Adjust image intensity values or colormap. J = IMADJUST(I) maps the values in intensity image I to new values in J such that 1% of data is saturated at low and high intensities of I. This increases the contrast of the output image J. RGB2 = imadjust(RGB1,[.2 .3 0; .6 .7 1],[]). BITGET BITGET Get bit. C = BITGET(A,BIT) returns the value of the bit at position BIT in A. A must be an unsigned integer or an array of unsigned integers, and BIT must be a number between 1 and the number of bits in the unsigned integer class of A e.g., 32 for UINT32s. STRETCHLIM STRETCHLIM Find limits to contrast stretch an image. LOW_HIGH = STRETCHLIM(I,TOL) returns a pair of gray values that can be used by IMADJUST to increase the contrast of an image.

GRAY LEVEL ENHANCEMENT LOG TRANSFORM clc; clear; img=imread('Cameraman.tif'); subplot(221); imshow(img); title('Original Image'); con=input('Enter Constant below 1='); [I,J]=size(img); for i=1:I for j=1:J f=double(img(i,j)); z(i,j)=con.*log10(1+f); end end subplot(222); imshow(z); title('Log Transformed below 1'); con1=input('Enter Constant above 1='); [I,J]=size(img); for i=1:I for j=1:J f=double(img(i,j)); z1(i,j)=con1.*log10(1+f); end end subplot(223); imshow(z1); title('Log Transformed above 1'); GAMMA TRANSFORM clc; clear; img=imread('pout.tif'); subplot(221); imshow(img); title('Original'); con=input('Enter the Constant '); dou=im2double(img); g=input('Enter Gamma Value above 1 ');

[x,y]=size(img); for i=1:x for j=1:y e(i,j)=con*(dou(i,j))^g; end end subplot(222); imshow(e); title('Above 1'); g1=input('Enter Gamma Value below 1 '); for i=1:x for j=1:y f(i,j)=con*(dou(i,j))^g1; end end subplot(223); imshow(f); title('Below 1'); GRAY SLICING clear; clc; img=imread('Rice.png'); subplot(221); imshow(img); title('Original'); [I,J]=size(img); for i=1:I for j=1:J if img(i,j)>=150 && img(i,j)

BIT SLICING clear; clc; im=imread('cameraman.tif'); [I,J]=size(im); for i=1:8 b=bitget(im,i); subplot(3,3,i); imshow(b,[]); end CONTRAST ENHANCEMENT img=imread('Rice.png'); adj=imadjust(img,stretchlim(img),[]); subplot(321); imshow(img); title('Original Image'); subplot(323); imshow(adj); title('Enhanced Image'); img2=imread('Rice.png'); subplot(325); imshow(img2); title('Contrast Image'); imcontrast(gca); subplot(322); imhist(img); subplot(324); imhist(adj);

OBSERVATION:

LOG TRANSFORM

GAMMA TRANSFORM

BIT SLICING

GRAY SLICING

CONTRAST ENHANCEMENT

EX.NO: EDGE DETECTION DATE: AIM: To write a MATLAB program to perform the detection of edges by following algorithms:

a. Sobel b. Canny c. Roberts d. Prewitt

SOFTWARE USED: MATLAB Version 2013 THEORY Edge detection refers to the process of identifying and locating sharp discontinuities in an image. The discontinuities are abrupt changes in pixel intensity which characterize boundaries of objects in a scene. Classical methods of edge detection involve convolving the image with an operator (a 2-D filter), which is constructed to be sensitive to large gradients in the image while returning values of zero in uniform regions. The geometry of the operator determines a characteristic direction in which it is most sensitive to edges. Operators can be optimized to look for horizontal, vertical, or diagonal edges. Edge detection is difficult in noisy images, since both the noise and the edges contain high frequency content. Attempts to reduce the noise result in blurred and distorted edges. The various operators used may be as follows: SOBEL The operator consists of a pair of 33 convolution kernels as shown in Figure 1. One kernel is simply the other rotated by 90.

These kernels are designed to respond maximally to edges running vertically and horizontally relative to the pixel grid, one kernel for each of the two perpendicular orientations. The kernels can be applied separately to the input image, to produce separate measurements of the gradient component in each orientation (call these Gx and Gy). These can then be combined together to find the absolute magnitude of the gradient at each point and the orientation of that gradient. The gradient magnitude is given by:

Typically, an approximate magnitude is computed using:

which is much faster to compute. The angle of orientation of the edge (relative to the pixel grid) giving rise to the spatial gradient is given by: q = arctan(Gy /Gx) CANNY In order to implement the canny edge detector algorithm, it is first necessary to filter out any noise in the original image before trying to locate and detect any edges. The Gaussian smoothing can be performed using standard convolution methods. After smoothing the image and eliminating the noise, the next step is to find the edge strength by taking the Gradient of the image. The Sobel operator performs a 2-D spatial gradient measurement on an image. Then, the approximate absolute gradient magnitude (edge strength) at each point can be found.The magnitude, or edge strength, of the gradient is then approximated using the formula

The direction of the edge is computed using the gradient in the x and y directions. However, an error will be generated when sumX is equal to zero. Whenever the gradient in the x direction is equal to zero, the edge direction has to be equal to 90 degrees or 0 degrees, depending on what the value of the gradient in the y-direction is equal to. If GY has avalue of zero, the edge direction will equal 0 degrees. Otherwise the edge direction will equal 90 degrees. Theformula for finding the edge direction is just: Theta = invtan (Gy / Gx)

After the edge directions are known, non-maximum suppression now has to be applied. Non-maximum suppression is used to trace along the edge in the edge direction and suppress any pixel value (sets it equal to 0) that is not considered to be an edge. This will give a thin line in the output image. Finally, hysteresis is used as a means of eliminating streaking. Streaking is the breaking up of an edge contour caused by the operator output fluctuating above and below the threshold. If a single threshold, T1 isapplied to an image, and an edge has an average strength equal to T1, then due to noise, there will be instances where the edge dips below the threshold. Equally it will also extend above the threshold making an edge look like a dashed line. To avoid this, hysteresis uses 2 thresholds, a high and a low. Any pixel in the image that has a value greater than T1 is presumed to be an edge pixel, and is marked as such immediately. Then, any pixels that are connected to this edge pixel and that have a value greater than T2 are also selected as edge pixels. If you think of following an edge, you need a gradient of T2 to start but you don't stop till you hit a gradient below T1. ROBERTS The Roberts Cross operator performs a simple, quick to compute, 2-D spatial gradient measurement on an image. Pixel values at each point in the output represent the estimated absolute magnitude of the spatial gradient of the input image at that point. The operator consists of a pair of 22 convolution kernels as shown in

One kernel is simply the other rotated by 90. This is very similar to the Sobel operator.

PREWITT Prewitt operator is similar to the Sobel operator and is used for detecting vertical and horizontal edges inimages.

SYNTAXES USED: IMREAD IMSHOW SOBEL METHOD BW = edge(I, sobel') specifies the Sobel method.The Sobel method finds edges using the Sobel approximation to the derivative. It returns edges at those points where the gradient of I is maximum. PREWITT METHOD BW = edge(I,'prewitt') specifies the Prewitt method. The Prewitt method finds edges using the Prewitt approximation to the derivative. It returns edges at those points where the gradient of I is maximum. ROBERTS METHOD

BW = edge(I,'roberts') specifies the Roberts method. The Roberts method finds edges using the Roberts approximation to the derivative. It returns edges at those points where the gradient of I is maximum.

CANNY METHOD BW = edge(I,'canny') specifies the Canny method. The Canny method finds edges by looking for local maxima of the gradient of I. 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 connected to strong edges. This method is therefore less likely than the others to be fooled by noise, and more likely to detect true weak edges.

EDGE DETECTION img1=imread('cameraman.tif'); img2=edge(img1,'canny'); img3=edge(img1,'log'); img4=edge(img1,'prewitt'); img5=edge(img1,'roberts'); img6=edge(img1,'sobel'); img7=edge(img1,'zerocross'); subplot(421); imshow(img1); title('original'); subplot(422); imshow(img2); title('canny'); subplot(423); imshow(img3); title('log'); subplot(424); imshow(img4); title('prewitt'); subplot(425); imshow(img5); title('roberts'); subplot(426); imshow(img6); title('sobel'); subplot(427); imshow(img7); title('zerocross');

OUTPUT: EDGE DETECTION

EX.NO: DISCRETE FOURIER TRANSFORMATION DATE: AIM: To write a MATLAB program to

a) To generate the DFT basis image for the given matrix dimension b) Find the Discrete Fourier Transform of an image. c) To prove the rotational property & convolution of DFT

SOFTWARE USED: MATLAB version 2013 THEORY Fourier Transform

The Fourier transform is an important image processing tool which is used to decompose an image into its sine and cosine components. The output of the transformation represents the image in Fourier as Frequency domain while the input image is the spatial domain equivalent.

Discrete Fourier transform

The DFT is the sampled Fourier Transform and therefore does not contain all frequencies forming an image, but only a set of samples which is large enough to fully describe the spatial domain image. The number of frequencies corresponds to the number of pixels in the spatial domain image, i.e. the image in the spatial and Fourier domain is of the same size.

For a square image of size NN, the two-dimensional DFT is given by:

where f(a,b) is the image in the spatial domain and the exponential term is the basis function corresponding to each point F(k,l) in the Fourier space. The equation can be interpreted as: the value of each point F(k,l) is obtained by multiplying the spatial image with the corresponding base function and summing the result.

The basis functions are sine and cosine waves with increasing frequencies, i.e. F(0,0) represents the DC-component of the image which corresponds to the average brightness and F(N-1,N-1) represents the highest frequency.

The inverse Fourier transform is given by:

Note the normalization term in the inverse transformation. This normalization is sometimes applied to the forward transform instead of the inverse transform, but it should not be used for both.

To obtain the result for the above equations, a double sum has to be calculated for each image point. However, because the Fourier Transform is separable, it can be written as

where

Using these two formulas, the spatial domain image is first transformed into an intermediate image using N one-dimensional Fourier Transforms. This intermediate image is then transformed into the final image, again using None-dimensional Fourier Transforms. Expressing the two-dimensional Fourier Transform in terms of a series of 2N one-dimensional transforms decreases the number of required computations.

The Fourier Transform produces a complex number valued output image which can be displayed with two images, either with the real and imaginary part or with magnitude and phase. In image processing, often only the magnitude of the Fourier Transform is displayed, as it contains most of the information of the geometric structure of the spatial domain image. However, if we want to re-transform the Fourier image into the correct spatial domain after some processing in the frequency domain, we must make sure to preserve both magnitude and phase of the Fourier image.

SYNTAXES USED: IMREAD IMSHOW ZEROS () creates an array of all zeros. B = zeros (m, n) or B = zeros([m n]) returns an m-by-n matrix of zeros. FFT2(X) returns the two-dimensional discrete Fourier transform (DFT) of X.

Y = fft2(X) returns the two-dimensional discrete Fourier transform (DFT) of X. The DFT is computed with a fast Fourier transform (FFT) algorithm. The result, Y, is the same size as X. If the dimensionality of X is greater than 2, the fft2 function returns the 2-D DFT for each higher dimensional slice of X. For example, if size(X) = [100 100 3], then fft2 computes the DFT of X(:,:,1), X(:,:,2) and X(:,:,3).Y = fft2(X, m ,n) truncates X, or pads X with zeros to create an m-by-n array before doing the transform. The result is m-by-n.

FFTSHIFT() Shift zero-frequency component to center of spectrum.

Y = fftshift(X) rearranges the outputs of fft, fft2, and fftn by moving the zero-frequency component to the center of the array. It is useful for visualizing a Fourier transform with the zero-frequency component in the middle of the spectrum. ALGORITHM

Step 1 Define an input vector i Step 2 Form the Dft matrix function Step 3 Multiply the Dft matrix, its transpose and input vector

Convolution Property Step 1 Generate a binary image using 0s and 1s Step 2 Two images are generated Step 3 Convolve both the generated images Step 4 Take the FFT of the two images separately, multiply and take the inverse Fourier

transform Step 5 Plot the convoluted and multiplied output Step 6 Verify if the images are equal

Rotation property Step 1 Generate a binary image using 0s & 1s Step 2 Rotate the generated image using function imrotate() Step 3 Take the magnitude of the FFT of the original and rotated image Step 4 Display the image, rotated image & their corresponding FFTs

DISCRETE FOURIER TRANSFORM DFT clear; clc; M=input('Enter M='); N=M; i=sqrt(-1); for k=0:N-1 for p=0:N-1 for n=0:N-1 for q=0:N-1 g{k+1,p+1}(n+1,q+1)=(exp((-2*pi*i*k*n)/N))*(exp((-2*pi*i*p*q)/M)); end end end end subplot(221); mag=g; t=1; for i=1:N for j=1:M subplot (M,N,t); imshow(mag{i,j}); t=t+1; end end DFT AND IDFT TO IMAGE: a=imread('Coins.png'); subplot(231); imshow(a); title('Original'); b=im2double(a); c=fft2(b); subplot(232); imshow(c); title('FFT'); d=ifft2(c); subplot(233); imshow(d); title('IFFT'); mag=abs(c); subplot(234);

imshow(mag); title('Magnitude Plot'); ang=angle(c); subplot(235); imshow(ang); title('Phase Plot'); TO PROVE CONVOLUTION PROPERTY: img1=zeros(256); for i=90:170 for j=90:170 img1(i,j)=1; end end img2=ones(256); for i=40:210 for j=40:210 img2(i,j)=0; end end img3=conv2(img1,img2,'same'); ff1=fft2(img1); ff2=fft2(img2); ff3=ff1.*ff2; img4=fftshift(ifft2(ff3)); subplot(231),imshow(img1),title('Image 1'); subplot(232),imshow(img2),title('Image 2'); subplot(233),imshow(ff1),title('FFT of Image 1'); subplot(234),imshow(ff2),title('FFT of Image 2'); subplot(235),imshow(img3),title('Convolution in Time Domain'); subplot(236),imshow(img4),title('Multiplication in Frequency Domain'); TO PROVE ROTATION PROPERTY: clc; clear; a=imread('coins.png'); subplot(231); imshow(a); title('Image'); a1=im2double(a); b=fft2(a1);

subplot(232); imshow(b); title('FFT of Image'); c=imrotate(a1,90); subplot(233); imshow(c); title('Rotated Image'); d=fft2(c); subplot(234); imshow(d); title('FFT of Rotated Image');

DISCRETE FOURIER TRANSFORM GENERATED IMAGES

DFT & IDFT IN IMAGE:

TO PROVE CONVOLUTION PROPERTY:

TO PROVE ROTATION PROPERTY:

EX.NO: DISCRETE COSINE TRANSFORMATION DATE: AIM: To write a MATLAB program

a) To generate a Basis images with the given matrix dimension using DCT transforms

b) To perform the discrete cosine transform on the given image

SOFTWARE USED: MATLAB Version 2013 THEORY The NxN Cosine transform matrix also called Discrete Cosine transform ( DCT ) is defined as

The 2-D DCT of a sequence & The inverse discrete transform are defined as :

SYNTAXES USED: IMREAD IMSHOW SUBPLOT: subplot Create axes in tiled positions. DCT: Discrete cosine transform. Y = dct(X) returns the discrete cosine transform of X. The vector Y is the same size as X and contains the discrete cosine transforms coefficients. Y = dct(X, N) pads or truncates the vector X to length N before transforming. ABS: Absolute value. abs(X) is the absolute value of the elements of X. When X is complex, abs(X) is the complex modulus (magnitude) of the elements of X. LOG: Natural logarithm. log(X) is the natural logarithm of the elements of X.Complex results are produced if X is not positive. IDCT: Inverse discrete cosine transform. X = idct(Y) inverts the DCT transform, returning the original vector if Y was obtained using Y = DCT(X). X = idct(Y,N) pads or truncates the vector Y to length N before transforming. If Y is a matrix, the idct operation is applied to each column. ALGORITHM : Basis function generation

Step 1 Open a new M file Step 2 Get the input matrix dimension ,N Step 3 Assign the values for (k) (l) Step 4 Use the suitable Matlab expression for cosine transforms inside the loop Step 5 Repeat the loop till N-1 Step 6 Plot the basis vectors as NxN

DCT of an image

Step 1 Read the input image in a variable a Step 2 Convert it to grayscale Step 3 Resize the image to NxN size Step 4 Generate the CT transform matrix of size N Step 5 Apply the rule U=A.V.AT and store the size N Step 6 Convert the output image in absolute and logarithmic form Step 7 Plot the DCT of an image

DISCRETE COSINE TRANSFORM clc; close all; clear; N=input('Enter Order='); M=N; a1=ones(1,N)*sqrt(2/N); a1(1)=sqrt(1/N); a2=ones(1,N)*sqrt(2/M); a2(1)=sqrt(1/M); for u=0:N-1 for v=0:M-1 for x=0:N-1 for y=0:M-1 h{u+1,v+1}(x+1,y+1)=a1(u+1)*a2(v+1)*cos((((2.*x)+1).*u.*pi)/(2.*N)).*cos((((2.*y)+1).*v.*pi)/(2.*N)); end end end end mag=h; k=1; for i=1:N for j=1:M subplot(N,M,k); imshow(mag{i,j}); k=k+1; end end DCT & IDCT IN IMAGE: clear; clc; img=imread('Rice.png'); img2=im2double(img); img3=dct2(img2); img4=idct2(img3); subplot(231),imshow(img),title('Original'); subplot(232),imshow(img3),title('DCT'); subplot(233),imshow(img4),title('IDCT'); mag=abs(img3); subplot(234),imshow(mag),title('Magnitude Plot'); pha=angle(img3); subplot(235),imshow(pha),title('Phase Plot');

OUTPUT: DISCRETE COSINE TRANSFORM GENERATED IMAGES

DCT & IDCT IN IMAGE:

EX NO. HISTOGRAM EQUALISATION DATE AIM To write a MATLAB code to enhance contrast the given images using histogram equalization SOFTWARE USED MATLAB 2013a THEORY Histogram Histogram of a digital image with intensity levels in the range [0,L-1] is a discrete function h(rk) = nk Where rk = kthintensity value in interval (0,G) nk = number of pixels in the image with intensity rk It is a graphical representation of showing a visual impression of distribution of data. It is the estimate of probability distribution of a continuous variable. The normalized Histogram is obtained by dividing all elements of h(rk) by total number of pixels in image P(rk) = h(rk)/ n = nk/ n Histogram equalization It is a grey level mapping process that seeks to produce monochrome images with uniform intensity histograms. It gives the net result of this intensity level with increased dynamic range, which tends to have high contrast. The transformation is the cumulative distribution function

SYNTAXES USED IMREAD IMSHOW IMHIST(I) calculates the histogram for the intensity image I and displays a plot of the histogram. The number of bins in the histogram is determined by the image type.

If I is a grayscale image, imhist uses a default value of 256 bins. If I is a binary image, imhist uses two bins.

imhist(i,n) displays a histogram for the intensity image I, where n specifies the number of bins used in the histogram. n also specifies the length of the colorbar displayed at the bottom of the histogram plot. If I is a binary image, n can only have the value 2. HISTEQ Histeq enhances the contrast of images by transforming the values in an intensity image, or the values in the colormap of an indexed image, so that the histogram of the output image approximately matches a specified histogram.

J = histeq(I,hgram) transforms the intensity image I so that the histogram of the output intensity image J with length(hgram) bins approximately matches hgram. The vector hgram should contain integer counts for equally spaced bins with intensity values in the appropriate range: [0, 1] for images of class double, [0, 255] for images of class uint8, and [0, 65535] for images of class uint16. histeq automatically scales hgram so that sum(hgram) = prod(size(I)). The histogram of J will better match hgram when length(hgram) is much smaller than the number of discrete levels in I.

J = histeq(I,n) transforms the intensity image I, returning in J an intensity image with n discrete gray levels. A roughly equal number of pixels is mapped to each of the n levels in J, so that the histogram of J is approximately flat. (The histogram of J is flatter when n is much smaller than the number of discrete levels in I.) The default value for n is 64. ALGORITHM The following steps are preformed to obtain Histogram Equalisation. Find the frequency of each pixel value

Step 1 Consider a matrix A

Step 2 Let No. of bins = 5 Step 3 Pixel value 1 occurs 3 times

Pixel value 2 occurs 3 times and so on Step 4 Find the probability of each frequency

The probability of pixel value 1s = Frequency (1)/No of pixels =3/9 Step 5 Find the cumulative histogram of each pixel

The cumulative histogram of 1 = 3 The cumulative histogram of 2 = cumulative histogram of 1 + Frequency of 2 = 3 + 2 = 5

Step 6 Find the cumulative probability distribution of each pixel

CDF of 1 = Cumulative histogram of 1 / No of pixels = 3/9 Step 7 Calculate the final value of each pixel by multiplying of with no of bins

CDF of 1 = 3/9 * 5 = 1.6667. Round off ~ 2 Step 8 Replace the final values

HISTOGRAM EQUALIZATION WITHOUT USING INBUILT FUNCTION clear; clc; I=imread('cameraman.tif'); I=double(I); maximum_value=max((max(I))); [row col]=size(I); c=row*col; h=zeros(1,300); z=zeros(1,300); for n=1:row for m=1:col if I(n,m) == 0 I(n,m)=1; end end end for n=1:row for m=1:col t = I(n,m); h(t) = h(t) + 1; end end pdf = h/c; cdf(1) = pdf(1); for x=2:maximum_value cdf(x) = pdf(x) + cdf(x-1); end new = round(cdf * maximum_value); new= new + 1; for p=1:row for q=1:col temp=I(p,q); b(p,q)=new(temp); t=b(p,q); z(t)=z(t)+1; end end b=b-1; subplot(2,2,1); imshow(uint8(I)) , title(' Image1');

subplot(2,2,2), bar(h) , title('Histogram of the Original Image'); subplot(2,2,3), imshow(uint8(b)) , title('Image2'); subplot(2,2,4), bar(z) , title('Histogram Equalisation of image2'); HISTOGRAM EQUALIZATION USING INBUILT FUNCTION img1=imread('cameraman.tif'); equalised=histeq(img1); subplot(221);imshow(img1);title('Original Image'); subplot(222);imhist(img1);title('Original Image Histogram'); subplot(223);imshow(equalised);title('Equalised Image'); subplot(224);imhist(equalised);title('Equalised Image Histogram');

OUTPUT HISTOGRAM EQUALIZATION WITHOUT INBUILT FUNCTION

HISTOGRAM EQUALIZATION WITH INBUILT FUNCTION

EX NO.: IMAGE FILTERING-FREQUENCY DOMAIN DATE: AIM: To write a MATLAB program to apply the following filters to the given image:

a) 2-D Butterworth low pass filter b) 2-D Butterworth high pass filter c) Gaussian low pass filter d) Gaussian high pass filter e) Ideal low pass filter f) Ideal high pass filter

SOFTWARES USED : MATLAB Version 2013a THEORY: The foundation for linear filtering in frequency domain is the convolution theorem, f(x,y)*h(x,y) H(u,v)F(u,v) where H(u,v) is the filter transfer function The idea in frequency domain filtering is to select a filter transfer function that modifies F(u,v) in a specific manner.

LOWPASS FREQUENCY DOMAIN FILTERS: The transfer function of an ideal lowpass filter is

>

=

),( if 0 ),( if 1

),(0

0

DvuDDvuD

vuH

where D(u,v) : the distance from point (u,v) to the center of the frequency rectangle

[ ]21

22 )2/()2/(),( NvMuvuD += D0 is a positive number The locus of points for which D(u,v)= D0 is a circle. Because filter H(u,v) multiplies the Fourier transform of an image, we see that an ideal filter cuts off all components of F(u,v) outside the circle and keeps all the components on or inside the circle unchanged. A Butterworth lowpass filter of order n, with cut off frequency at distance D0 from the center of the filter, has the transfer function

[ ] nDvuDvuH 2

0/),(11),(

+=

A Gaussian lowpass filter has transfer function given by

20

2 2/),(),( DvuDevuH = Where is the standard deviation HIGH PASS FREQUENCY DOMAIN FILTERS: The high pass filtering sharpens the image by attenuating low frequencies and leaving the high frequencies of an image unaltered. If Hlp(u,v) is the transfer function of a lowpass filter, then the transfer function of the corresponding high pass filter Hhp(u,v) is given by,

Hhp(u,v)=1- Hlp(u,v) ALGORITHM:

Step 1 Read the image to be filtered. Step 2 Take the Fourier Transform of the image using function fft2(). Step 3 Define the transfer function of the filter and form the transfer matrix. Step 4 Multiply the formed transfer matrix with transformed image. Step 5 Take inverse Fourier transform to get the filtered image. Display the images and

transfer function in 3-D view.

Ideal low pass and high pass filter: Step 1 Read the image. Step 2 Create the mask for low pass or high pass filtering. Step 3 Take the Fourier transform of the mask and of the image using function fft2(). Step 4 Multiply the transformed mask and image. Step 5 Take the inverse Fourier transform using the function ifft2() to get filtered

image. Step 6 Display the filtered image, mask and fftshift of the mask

FREQUENCY DOMAIN FILTERS BUTTERWORTH LOWPASS FILTER clear; clc; img=imread('Coins.png'); [X,Y]=size(img); N=input('Order of Filter='); x=ceil(X/2); y=ceil(Y/2); rad=26; for i=1:X for j=1:Y d(i,j)=sqrt((i-x).^2+(j-y).^2); h(i,j)=1/(1+((d(i,j))/rad).^(2*N)); end end fft1=fftshift(fft2(img)); fil=h.*fft1; fin=ifft2(fil); fin1=uint8(fin); subplot(221); imshow(img); title('Original'); subplot(222); imshow(fin1); title('After LPF'); subplot(223); surf(h); title('LPF in 3D'); subplot(224); imshow(h); title('LPF as Image'); BUTTERWORTH HIGH PASS FILTER clear; clc; img=imread('Coins.png'); [X,Y]=size(img); N=input('Order of Filter='); x=ceil(X/2); y=ceil(Y/2);

rad=26; for i=1:X for j=1:Y d(i,j)=sqrt((i-x).^2+(j-y).^2); h(i,j)=1-(1/(1+((d(i,j))/rad).^(2*N))); end end fft1=fftshift(fft2(img)); fil=h.*fft1; fin=ifft2(fil); fin1=uint8(fin); subplot(221); imshow(img); title('Original'); subplot(222); imshow(fin1); title('After HPF'); subplot(223); surf(h); title('HPF in 3D'); subplot(224); imshow(h); title('HPF as Image'); IDEAL LOW PASS FILTER clear; clc; img=imread('Coins.png'); [X,Y]=size(img); N=input('Order of Filter='); x=ceil(X/2); y=ceil(Y/2); rad=26; for i=1:X for j=1:Y d(i,j)=sqrt((i-x).^2+(j-y).^2); if d(i,j)

end end fft1=fftshift(fft2(img)); fil=h.*fft1; fin=ifft2(fil); fin1=uint8(fin); subplot(221); imshow(img); title('Original'); subplot(222); imshow(fin1); title('After Ideal LPF'); subplot(223); surf(h); title('Ideal LPF in 3D'); subplot(224); imshow(h); title('Ideal LPF as Image'); IDEAL HIGH PASS FILTER clear; clc; img=imread('Coins.png'); [X,Y]=size(img); N=input('Order of Filter='); x=ceil(X/2); y=ceil(Y/2); rad=26; for i=1:X for j=1:Y d(i,j)=sqrt((i-x).^2+(j-y).^2); if d(i,j)

fin1=uint8(fin); subplot(221); imshow(img); title('Original'); subplot(222); imshow(fin1); title('After Ideal HPF'); subplot(223); surf(h); title('Ideal HPF in 3D'); subplot(224); imshow(h); title('Ideal HPF as Image'); GAUSSIAN LOW PASS FILTER: clear; clc; img=imread('Coins.png'); [X,Y]=size(img); N=input('Order of Filter='); x=ceil(X/2); y=ceil(Y/2); rad=26; for i=1:X for j=1:Y d(i,j)=sqrt((i-x).^2+(j-y).^2); h(i,j)=exp(-(d(i,j).^2)/(2*((rad).^2))); end end fft1=fftshift(fft2(img)); fil=h.*fft1; fin=ifft2(fil); fin1=uint8(fin); subplot(221); imshow(img); title('Original'); subplot(222); imshow(fin1); title('After Gaussian LPF'); subplot(223); surf(h);

title('Gaussian LPF in 3D'); subplot(224); imshow(h); title('Gaussian LPF as Image'); GAUSSIAN HIGH PASS FILTER: clear; clc; img=imread('Coins.png'); [X,Y]=size(img); N=input('Order of Filter='); x=ceil(X/2); y=ceil(Y/2); rad=26; for i=1:X for j=1:Y d(i,j)=sqrt((i-x).^2+(j-y).^2); h(i,j)=1-exp(-(d(i,j).^2)/(2*((rad).^2))); end end fft1=fftshift(fft2(img)); fil=h.*fft1; fin=ifft2(fil); fin1=uint8(fin); subplot(221); imshow(img); title('Original'); subplot(222); imshow(fin1); title('After Gaussian HPF'); subplot(223); surf(h); title('Gaussian HPF in 3D'); subplot(224); imshow(h); title('Gaussian HPF as Image');

OUTPUT: BUTTERWORTH LOWPASS FILTER

BUTTERWORTH HIGHPASS FILTER

IDEAL LOWPASS FILTER

IDEAL HIGHPASS FILTER

GAUSSIAN LOWPASS FILTER

GAUSSIAN LOWPASS FILTER

EX NO.: COLOUR IMAGE PROCESSING-I DATE: AIM: To write a MATLAB program to:

a) Display a colour image and its R, G, B and H, S, V components b) Convert the given RGB image to different forms c) Perform colour manipulation using brighten, cmpermute, cmunique, rgbplot

commands THEORY: Colour image processing deals with colour descriptions of images that are natural and intuitive to humans. Human eyes:

Primary colors for standardization blue : 435.8 nm green : 546.1 nm red : 700 nm

Cones in human eyes are divided into three sensing categories 65% are sensitive to red light 33% sensitive to green light 2% sensitive to blue (but most sensitive)

The R, G, and B colors perceived by human eyes cover a range of spectrum

RGB Colour models: The model is based on a Cartesian co-ordinate system. RGB values are at 3 corners. Cyan , magenta and yellow are at the other three corners. Black is at the origin and white is at the corner furthest from the origin.

NTSC Colour space: One of the main advantages of this format is that grayscale information is separated from color data, so the same signal can be used for both color and black and white television sets.

In the NTSC color space, image data consists of three components: luminance (Y), hue (I), and saturation (Q). The first component, luminance, represents grayscale information, while the last two components make up chrominance (color information).

YCbCr The YCbCr color space is widely used for digital video. In this format, luminance information is stored as a single component (Y), and chrominance information is stored as two color-difference components (Cb and Cr). Cb represents the difference between the blue component and a reference value. Cr represents the difference between the red component and a reference value.

Y 16 65.481 128.553 24.966 R

Cb = 128 + -37.797 -74.203 112.000 + G Cr 128 112.000 -93.786 -18.214 B HSV colour space:

Hue, saturation, value is formulated by looking at RGB colour cube along its gray scale axis(the axis joining the black and white vertices) which results in a hexagonally shaped colour space. As we move along the vertical (gray) axis, size of hexagonal plane perpendicular to the axis changes.

Hue: expressed as an angle around a colour hexagon, typicallyusing the red axis as reference (0) axis.

Value: measured along the axis of the cone. V=0 end of axis is black V=1 end of axis is white Saturation: (purity of colour) measured as the distance from V axis. The HSV colour system is based on cylindrical co-ordinates. Conversion from RGB

-HSV entails developing the equation to map RGBvalues (which are in Cartesian co-ordinates) to cylindrical co-ordinates.

CMY & CMYK colour spaces Cyan, Magenta and Yellow are the secondary colours of RGB or

alternativelyprimary colours of pigments. It is used in colour printers and copiers that deposit colour pigments on paper. It requires CMY data input or an RGBCMY conversion to be performed

internally, as: C 1 R M = 1 - G Y 1 B In theory, equal amounts of cyan, magenta and yellow should produce

black.However, practically, muddy black is produced. Hence, a fourth colour black is added, giving rise to CMYK model.

HSI colour space: Hue, saturation and brightness.

Hue: colour attribute that describes pure colour whereas saturation is the measure of the degree to which a pure colour is diluted by white light.

Brightness: subjective descriptor that is impossible to measure.

The dotis an arbitrary colour point. The angle from the red axis gives the hue, and the length ofthe vector is the

saturation. The intensity of all colours in any of these planes is given by the position of the

plane on the vertical intensity axis.

Converting colours from RGBHIS Given a colour as R, G, and B its H, S, and I values are calculated as follows:

>

=

GBifGBif

H 360

( ) ( )[ ]( ) ( )( )[ ]

+

+=

21

2

21

1cosBGBRGR

BRGR

( )( )[ ]BGR

BGRS ,,min31

++=

( )BGRI ++= 31 Cmunique: Eliminate duplicate colors in colormap and convert grayscale or truecolor image to indexed image Cmpermute: Rearrange colors in colormap. Randomly reorders the colors in map to produce a new colormap

Imapprox: Approximate indexed image by reducing number of colors

ALGORITHM: To display colour images and individual colour elements:

Step 1 Read the input RGB image Step 2 Display the image in rgb, hsv, ntsc, yCbCr, and Lab forms. Separate the individual

colour elements like r-plane, g-plane, b-plane, hsv plane, yq plane, lab plane. Step 3 Observe the output images.

Colour image manipulation:

Step 1 Read the input image. Step 2 Perform the colour map manipulation using brighten, cmpermute, cmunique

and rgbplot commands. Step 3 Observe the output image

COLOR IMAGE PROCESSING img1=imread('peppers.png'); subplot(551); imshow(img1); title('Original image'); img2=rgb2hsv(img1); subplot(552); imshow(img2); title('HSV'); img3=rgb2ycbcr(img1); subplot(553); imshow(img3); title('YCBCR'); img4=rgb2ntsc(img1); subplot(554); imshow(img4); title('NTSC'); img5=img1(: , : , 1); subplot(555); imshow(img5); img6=img1(: , : , 2); subplot(556); imshow(img6); img7=img1(: , : , 3); subplot(557); imshow(img7); img8=img2(: , : ,1); subplot(558); imshow(img8); title('HUE'); img9=img2(: , :, 2); subplot(559); imshow(img9); title('SATURATION'); img10=img2(: , : , 3); subplot(5,5,10); imshow(img10); title('VALUE'); Red=img1;Blue=img1;Green=img1; Red(:,:,2:3)=0; subplot(5,5,11);

imshow(Red); title('RED COMPONENT'); Green(:,:,1)=0; subplot(5,5,12); imshow(Green); title('GREEN COMPONENT'); Blue(:,:,1:2)=0; subplot(5,5,13); imshow(Blue); title('BLUE COMPONENT'); j=img3(: ,: ,1); subplot(5,5,14); imshow(j); title('Y COMPONENT'); k=img3(: ,: ,2); subplot(5,5,15); imshow(k); title('CB COMPONENT'); l=img3(: ,: ,3); subplot(5,5,16); imshow(l); title('CR COMPONENT');

OUTPUT CONVERSION BETWEEN COLOR SPACE

EX NO. COLOUR IMAGE PROCESSING- II DATE: AIM: To write a MATLAB program to perform colour conversion of colour images into various formats. SOFTWARES USED MATLAB Version 2013a THEORY: Makecform: Create color transformation structure C = makecform (type)creates the color transformation structure C that defines the color space conversion specified by type. To perform the transformation, pass the color transformation structure as an argument to the applycformfunction. The type argument specifies one of the conversions listed in the following table. Makecform supports conversions between members of the family of device-independent color spaces defined by the CIE, (International Commission on Illumination). In addition, makecform also supports conversions to and from the sRGB and CMYK color spaces Applycform: Apply device-independent color space transformationB = applycform(A,C) converts the color values in A to the color space specified in the color transformation structureC. The color transformation structure specifies various parameters of the transformation. ALGORITHM:

Step 1 Read the input image. Step 2 Perform image conversions using functions makecform andapplycform. Step 3 Take the inverse Fourier transform to get the filtered image. Step 4 Perform conversions like srgb2lab, lab2srgb, xyz2uvl, xyz2lab, xyz2xyl. Step 5 Observe the output image

IMAGE TYPE CONVERSION img1=imread('onion.png'); img2=double(img1); img3=makecform('srgb2lab'); img4=applycform(img2,img3); subplot(331); imshow(img4); title('SRGB2LAB'); img5temp=makecform('lab2srgb'); img5=applycform(img2,img5temp); subplot(332); imshow(img5); title('LAB2SRGB'); img6temp=makecform('srgb2xyz'); img6=applycform(img2,img6temp); subplot(333); imshow(img6); title('SRGB2XYZ'); img7temp=makecform('uvl2xyz'); img7=applycform(img2,img7temp); subplot(334); imshow(img7); title('UVL2XYZ'); img8temp=makecform('lch2lab'); img8=applycform(img2,img8temp); subplot(335); imshow(img8); title('LCH2LAB'); img9temp=makecform('lab2lch'); img9=applycform(img2,img9temp); subplot(336); imshow(img9); title('LAB2LCH'); img10temp=makecform('xyz2uvl'); img10=applycform(img2,img10temp); subplot(337); imshow(img10); title('XYZ2UVL'); img11temp=makecform('xyl2xyz'); img11=applycform(img2,img11temp); subplot(338);

imshow(img11); title('XYL2XYZ'); img12temp=makecform('xyz2lab'); img12=applycform(img2,img12temp); subplot(339); imshow(img12); title('XYZ2LAB'); CMPERMUTE load trees hsvmap=rgb2hsv(map); [dum,index]=sort(hsvmap(:,3)); [Y,newmap]=cmpermute(X,map,index); figure; subplot(221); image(X); colormap(map); title('Original image'); subplot(222); rgbplot(map); title('RGB plot of map'); subplot(223); image(Y); colormap(newmap); title('Image after cmpermute'); subplot(224); rgbplot(newmap); title('Image after cmpermute'); subplot(224); rgbplot(newmap); title('RGB plot of image after cmpermute'); CMUNIQUE load trees subplot(121); image(X); colormap(map); title('Original image'); axis off; axis image; [Y,newmap]=cmunique(X,map);

subplot(122); image(Y); colormap(newmap); title('Image after cmunique'); axis off; axis image; CMAPPROX load trees subplot(121); image(X); colormap(map); title('Original image'); axis off; axis image; [Y,newmap]=imapprox(X,map,0.5) subplot(122); image(Y); colormap(newmap); title('Image after cmapprox'); axis off; axis image;

IMAGE TYPE CONVERSION

CMPERMUTE

CMUNIQUE

CMAPPROX

EX NO: WAVELET BASED IMAGE COMPRESSION DATE: AIM: To write a MATLAB program to perform second level decomposition on image using

a) Haar wavelets, b) Daubechies wavelet and c) Bi-orthogonal wavelets

SOFTWARES USED: MATLAB Version 2013a THEORY: The term DWT refers to a class of transformations that differ not only in the transformation kernels employed, but also in the fundamental nature of those functions and in the way in which they are applied. The various transforms are related by the fact that their expansion functions are small waves of varying frequency and limited duration Each wavelet possesses the following general properties: Separability, Scalability, and Translatability. The kernels can be represented as three separable 2-D wavelets and one separable 2-D scaling function. H(x,y) = (x). (y) V(x,y) = (y). (x) D(x,y) = (x). (y)

H(x,y) ,V(x,y) ,D(x,y) are called horizontal, vertical and diagonal wavelets respectively and one separable 2-D scaling function. (x,y)= (x). (y) Each of these 2-D functions is the product of two 1-D real, square-integrable scaling and wavelet functions. j,k(x) =2j/2 (2j x-k) l,k(x)=2j/2 (2j x-k) Multiresolution Compatibility. The 1-D scaling function just introduced satisfies the following requirements of multiresolution analysis:

a. j,k is orthogonal to its integer translates.

b. The set of functions that can be represented as a series expansion of j,k at low scales or resolutions is contained within those that can be represented at higher scales.

c. The only function that can be represented at every scale is f(x)=0.

d. Any function can be represented with arbitrary precision as j

Wavelet j,k, together with its integer translates and binary scalings, can represent the difference between any two sets of j,k representable functions at adjacent scales. Orthogonality. The expansion functions form an orthonormal or biorthogonal basis for the set of 1-D measurable, square- integrable functions.To be called a basis there must be a unique set of expansion coefficients for every representable function. The fourier kernels, gu,v=hu,v for real, orthonormal kernels. For the biorthogonal case, hr, gs = rs = 1 r=s 0 otherwise And g is called the dual of h. foe biorthogonal wavelet transform with scaling and wavelet functions l,k(x) and j,k(x) the duals are denoted " l,k(x) and "j,k(x) respectively. Fast wavelet transform: An important consequence of the above properties is that both (x) and (x) can be expressed as linear combinations of double- resolution copies of themselves. That is, via the series expansions. (x) = h(n).2 (2x-n) (x) = h(n).2 (2x-n) Where h and h are called scaling and wavelet vectors, respectively. h(-n) Lowpass decomposition filters h(-m) Highpass decomposition filters Block containing a 2 & 2 a down arrow represent downsampling, extracting every other point from a sequence of points.

Mathematically, the series of filtering and downsampling operations used to compute WH(j,m,n) in the above figure, for example, WH(j,m,n) = h(-m)*[ h(-n)*W(j+1,m,n)|n=2k,k0] |m=2k, k0 The input to the filter bank is decomposed into four lower resolution components. The coefficients are created via two lowpass filters are thus called approximation coefficients { Wi for i=H,V,D } are horizontal, vertical and diagonal detail coefficients respectively W(j,m,n) = 1/MN[ !,!,!(,)!!!!!!!!!!!! ] Wi(j,m,n) = 1/MN[ (,)!!!!!!!!!!!! !,!,!! (,)] WH(j,m,n) = 1/MN[ (,)!!!!!!!!!!!! !,!,!! (,)] WV(j,m,n) = 1/MN[ (,)!!!!!!!!!!!! !,!,!! (,)] WD(j,m,n) = 1/MN[ (,)!!!!!!!!!!!! !,!,!! (,)] The 2-D forward wavelet transform can be computed in a fast way using an analysis filter bank. We can apply wavelet domain filtering methods after taking the wavelet transform of an image.

Compute the 2-D wavelet transform of an image. Make modifications to the transform coefficients. Compute the inverse.

DWT scaling vectors behave as lowpass filters and DWT wavelet vectors behave as highpass filters. Salient features of wavelets: Time and frequency resolution using wavelets

A wavelet basis function can be translated anywhere in the spatial domain. It can also have multiple scaled versions with the adjacent scales related by a factor of 2. The translated and scaled versions of these basis functions are used to detect and localise different frequency components in an image. A basis function at a higher scale can detect a high frequency in the image content. Localization of this high frequency is made possible by noting the translation of the basis function.

Multiresolution property of wavelet transform The concept of scale is close to concept of frequency interpretation in terms of capturing the level of detail. Basis functions at higher scales can take note of rapid variations in the signal and thus can capture high level of detail.

Basis function at lower level scale can capture a lower level of detail. The wavelets ability to capture multiple levels of details makes it possible to

have multiresolution decomposition of the image.

ALGORITHM Step 1 Read the input image from the MATLAB directory. Step 2 Generate the wavelet transform coefficient using dct2 command. Step 3 Generate a matrix from the obtained coefficient. Step 4 Perform the operation consecutively for progressive levels of compression. Step 5 Display the transformed image and input image. Step 6 For LPF operation, perform wavedec2 command and obtain the coefficients. Step 7 Separate out the first few coefficients and reconstruct the image using

waverec2 command. Step 8 For HPF reconstruct the last few values from the coefficients and display the

reconstructed output. Step 9 For wavelet based denoising and Gaussian noise to the input.

Step 10 Set a threshold and filter the noise and reconstruct the image. Step 11 Find out the approximate coefficients using appcoef.

DISCRETE WAVELET TRANSFORM USING HAAR clc; clear; img1=imread('pout.tif'); [p,q,r,s]=dwt2(img1,'haar'); wav1=[p,q;r,s]; [p1,q1,r1,s1]=dwt2(p,'haar'); wav2=[p1,q1;r1,s1]; wav3=idwt2(p1,q1,r1,s1,'haar'); subplot(221),imshow(img1),title('Original'); subplot(222),imshow(wav1,[]),title('DWT Decimation'); subplot(223),imshow(wav2,[]),title('DWT Decimation'); subplot(224),imshow(wav3,[]),title('Reconstructed'); USING DOUBECHIES clc; clear; img1=imread('pout.tif'); [p,q,r,s]=dwt2(img1,'db3'); wav1=[p,q;r,s]; [p1,q1,r1,s1]=dwt2(p,'db3'); wav2=[p1,q1;r1,s1]; wav3=idwt2(p1,q1,r1,s1,'db3'); subplot(221),imshow(img1),title('Original'); subplot(222),imshow(wav1,[]),title('Daubechies DWT Decimation'); subplot(223),imshow(wav2,[]),title('Daubechies DWT Decimation'); subplot(224),imshow(wav3,[]),title('Daubechies Reconstructed'); USING BIORTHOGONAL clc; clear; img1=imread('pout.tif'); [p,q,r,s]=dwt2(img1,'bior3.5'); wav1=[p,q;r,s]; [p1,q1,r1,s1]=dwt2(p,'bior3.5'); wav2=[p1,q1;r1,s1]; wav3=idwt2(p1,q1,r1,s1,'bior3.5'); subplot(221),imshow(img1),title('Original'); subplot(222),imshow(wav1,[]),title('Biorthogonal DWT Decimation'); subplot(223),imshow(wav2,[]),title('Biorthogonal DWT Decimation'); subplot(224),imshow(wav3,[]),title('Biorthogonal Reconstructed');

OUTPUT USING HAAR

USING DOUBECHIES

USING BIORTHOGONAL

EX NO IMAGE SEGMENTATION USING WATERSHED TRANSFORMATION DATE AIM To write a MATLAB code to perform

a) Detection of lines and points b) Thresholding operations on image using watershed transformation

SOFTWARE USED MATLAB Version 2013a THEORY Image segmentation is the process of subdividing an image into its constituents parts or region. The image segmentation algorithm is based on two basic properties of intensity values

i. DisContinuity ii. Similarity

a) Step edge b)Ramp edge c) Roof edge

a) STEP EDGE:

Digital step edges are used frequently as edge as edge models in algorithm development. A step edge is considered as ideal

b) RAMP EDGE Used when the edges are blurred due to defocussing and noisy due to electronic components. Ramp is practical edge model

c) ROOF EDGE Digitization of line drawings in thin features results in roof edges

Edge Linking ( Region Boundary decision ) An edge detection procedure identifies the set of edge points. The edge pixels by themselves cannot segment an image. The three methods based on whether they gather their evidence at local level, regional level or global level.

1. Local processing 2. Global processing 3. Regional processing using the hough transform.

ALGORITHM Step 1 Read the input from Matlab directory. Step 2 Convolve the required mask with the input image for detecting horizontal,

vertical, diagonal, lines and points using the imfiller command Step 3 To perform optimal thresholding, find out the gray level thresholding value using

graythresh command Step 4 Perform thresholding of the input image using im2low command and display the

output Step 5 To perform local thresholding, divide the image into blocks using blkproc

command Step 6 Find the localized threshold and perform threshold of individual blocks. Step 7 To find the global threshold, set a threshold of your choice depending on the

pixel values and perform thresholding

WATERSHED TRANSFORM clc; clear; img1=checkerboard(40); img2=imnoise(img1,'salt & pepper',0.1); wa1=watershed_old(img1,6); wa2=watershed_old(img2,6); subplot(221),imshow(img1),title('Image 1'); subplot(222),imshow(img2),title('Image 2'); subplot(223),imshow(wa1),title('Watershed of Image 1'); subplot(224),imshow(wa2),title('Watershed of Image 2'); OUTPUT