m.tech (sharpening , blurring ,noise of an image)

Detection & removal of blurring and Noise from PCB

1. Sharpening and Blurring an Image

To sharpen a color image, you need to make the luma intensity transitions more acute, while preserving the color information of the image. To do this, you convert an R'G'B' image into the Y'CbCr color space and apply a highpass filter to the luma portion of the image only. Then, you transform the image back to the R'G'B' color space to view the results. To blur an image, you apply a lowpass filter to the luma portion of the image. This example shows how to use the 2-D FIR Filter block to sharpen and blur an image. The prime notation indicates that the signals are gamma corrected.

1. Define an R'G'B' image in the MATLAB workspace. To read in an R'G'B' image from a PNG file and cast it to the double-precision data type, at the MATLAB command prompt, type

I= im2double(imread('peppers.png'));

I is a 384-by-512-by-3 array of double-precision floating-point values. Each plane of this array represents the red, green, or blue color values of the image.

2. To view the image this array represents, at the MATLAB command prompt, type imshow(I)

Now that you have defined your image, you can create your model.

3. Create a new Simulink model, and add to it the blocks shown in the following table.

Block Library Quantity

Image From Workspace

Video and Image Processing Blockset > Sources 1

Color Space Conversion

Video and Image Processing Blockset > Conversions

2

2-D FIR Filter Video and Image Processing Blockset > Filtering 1

Video Viewer Video and Image Processing Blockset > Sinks 1

4. Position the blocks as shown in the following figure.

5. Use the Image From Workspace block to import the R'G'B' image from the MATLAB workspace. Set the parameters as follows:

Main pane, Value = I Main pane, Image signal = Separate color signals

The block outputs the R', G', and B' planes of the I array at the output ports.

6. The first Color Space Conversion block converts color information from the R'G'B' color space to the Y'CbCr color space. Set the Image signal parameter to Separate color signals

7. Use the 2-D FIR Filter block to filter the luma portion of the image. Set the block parameters as follows:

Coefficients = fspecial('unsharp') Output size = Same as input port I Padding options = Symmetric Filtering based on = Correlation

The fspecial('unsharp') command creates two-dimensional highpass filter coefficients suitable for correlation. This highpass filter sharpens the image by removing the low frequency noise in it.

8. The second Color Space Conversion block converts the color information from the Y'CbCr color space to the R'G'B' color space. Set the block parameters as follows:

Conversion = Y'CbCr to R'G'B' Image signal = Separate color signals

9. Use the Video Viewer block to automatically display the new, sharper image in the Video Viewer window when you run the model. Set the Image signal parameter to Separate color signals, by selecting File > Image Signal.

10. Connect the blocks as shown in the following figure.

11. Set the configuration parameters. Open the Configuration dialog box by selecting Configuration Parameters from the Simulation menu. Set the parameters as follows:

Solver pane, Stop time = 0 Solver pane, Type = Fixed-step Solver pane, Solver = Discrete (no continuous states)

12. Run the model.

A sharper version of the original image appears in the Video Viewer window.

13. To blur the image, double-click the 2-D FIR Filter block. Set Coefficients parameter to fspecial('gaussian',[15 15],7) and then click OK.

The fspecial('gaussian',[15 15],7) command creates two-dimensional Gaussian lowpass filter coefficients. This lowpass filter blurs the image by removing the high frequency noise in it.

14. Run the model.

A blurred version of the original image appears in the Video Viewer window. The following image is shown at its true size.

In this example, you used the Color Space Conversion and 2-D FIR Filter blocks to sharpen and blur an image. For more information on these blocks, see the Color Space Conversion and 2-D FIR Filter block reference pages in the Video and Image Processing Blockset Reference. For more information on the fspecial function, see the Image Processing Toolbox documentation.

2. Removing Salt and Pepper Noise from Images

Median filtering is a common image enhancement technique for removing salt and pepper noise. Because this filtering is less sensitive than linear techniques to extreme changes in pixel values, it can remove salt and pepper noise without significantly reducing the sharpness of an image. In this topic, you use the Median Filter block to remove salt and pepper noise from an intensity image:

1. Define an intensity image in the MATLAB workspace and add noise to it by typing the following at the MATLAB command prompt:

I= double(imread('circles.png'));I= imnoise(I,'salt & pepper',0.02);

I is a 256-by-256 matrix of 8-bit unsigned integer values.

2. To view the image this matrix represents, at the MATLAB command prompt, type

imshow(I)

The intensity image contains noise that you want your model to eliminate.

3. Create a Simulink model, and add the blocks shown in the following table.


Image From Workspace Video and Image Processing Blockset > Sources 1

Median Filter Video and Image Processing Blockset > Filtering 1


4. Position the blocks as shown in the following figure.

5. Use the Image From Workspace block to import the noisy image into your model. Set the Value parameter to I.

6. Use the Median Filter block to eliminate the black and white speckles in the image. Use the default parameters.

The Median Filter block replaces the central value of the 3-by-3 neighborhood with the median value of the neighborhood. This process removes the noise in the image.

7. Use the Video Viewer blocks to display the original noisy image, and the modified image. Images are represented by 8-bit unsigned integers. Therefore, a value of 0 corresponds to black and a value of 255 corresponds to white. Accept the default parameters.




10. Run the model.

The original noisy image appears in the Video Viewer window. To view the image at its true size, right-click the window and select Set Display To True Size.

The cleaner image appears in the Video Viewer1 window. The following image is shown at its true size.

You have used the Median Filter block to remove noise from your image. For more information about this block, see the Median Filter block reference page in the Video and Image Processing Blockset Reference.

3. Adjusting the Contrast in Intensity Images

This example shows you how to modify the contrast in two intensity images using the Contrast Adjustment and Histogram Equalization blocks.



Image From File Video and Image Processing Blockset > Sources 2

Contrast Adjustment Video and Image Processing Blockset > Analysis & Enhancement

1

Histogram Equalization

Video and Image Processing Blockset > Analysis & Enhancement

1


2. Place the blocks so that your model resembles the following figure.

3. Use the Image From File block to import the first image into the Simulink model. Set the File name parameter to pout.tif.

4. Use the Image From File1 block to import the second image into the Simulink model. Set the File name parameter to tire.tif.

5. Use the Contrast Adjustment block to modify the contrast in pout.tif. Set the Adjust pixel values from parameter to Range determined by saturating outlier pixels, as shown in the following figure.

This block adjusts the contrast of the image by linearly scaling the pixel values between user-specified upper and lower limits.

6. Use the Histogram Equalization block to modify the contrast in tire.tif. Accept the default parameters.

This block enhances the contrast of images by transforming the values in an intensity image so that the histogram of the output image approximately matches a specified histogram.

7. Use the Video Viewer blocks to view the original and modified images. Accept the default parameters.




10. Run the model.

The results appear in the Video Viewer windows.

In this example, you used the Contrast Adjustment block to linearly scale the pixel values in pout.tif between new upper and lower limits. You used the Histogram Equalization block to transform the values in tire.tif so that the histogram of the output image approximately matches a uniform histogram. For more information, see the Contrast Adjustment and Histogram Equalization block reference pages in the Video and Image Processing Blockset Reference

4. Adjusting the Contrast in Color Images

This example shows you how to modify the contrast in color images using the Histogram Equalization block.

1. Use the following code to read in an indexed RGB image, shadow.tif, and convert it to an RGB image.

[X map] = imread('shadow.tif');shadow = ind2rgb(X,map);



Image From Workspace

Video and Image Processing Blockset > Sources 1

Color Space Conversion

Video and Image Processing Blockset > Conversions 2

Histogram Equalization

Video and Image Processing Blockset > Analysis & Enhancement

1


Constant Simulink > Sources 1

Divide Simulink > Math Operations 1

Product Simulink > Math Operations 1

3. Place the blocks so that your model resembles the following figure.

4. Use the Image From Workspace block to import the RGB image from the MATLAB workspace into the Simulink model. Set the block parameters as follows:

Value = shadow Image signal = Separate color signals

5. Use the Color Space Conversion block to separate the luma information from the color information. Set the block parameters as follows:

Conversion = sR'G'B' to L*a*b* Image signal = Separate color signals

Because the range of the L* values is between 0 and 100, you must normalize them to be between zero and one before you pass them to the Histogram Equalization block, which expects floating point input in this range.

6. Use the Constant block to define a normalization factor. Set the Constant value parameter to 100.

7. Use the Divide block to normalize the L* values to be between 0 and 1. Accept the default parameters.

8. Use the Histogram Equalization block to modify the contrast in the image. Accept the default parameters.

This block enhances the contrast of images by transforming the luma values in the color image so that the histogram of the output image approximately matches a specified histogram.

9. Use the Product block to scale the values back to be between the 0 to 100 range. Accept the default parameters.

10. Use the Color Space Conversion1 block to convert the values back to the sR'G'B' color space. Set the block parameters as follows:

Conversion = L*a*b* to sR'G'B' Image signal = Separate color signals

11. Use the Video Viewer blocks to view the original and modified images. For each block, set the Image signal parameter to Separate color signals.




14. Run the model.

As shown in the following figure, the model displays the original image in the Video Viewer1 window.

As the next figure shows, the model displays the enhanced contrast image in the Video Viewer window.

In this example, you used the Histogram Equalization block to transform the values in a color image so that the histogram of the output image approximately matches a uniform histogram. For more information, see the Histogram Equalization block reference page in the Video and Image Processing Blockset Reference.

5. Understanding Sources of Noise in Digital Images

Digital images are prone to a variety of types of noise. Noise is the result of errors in the image acquisition process that result in pixel values that do not reflect the true intensities of the real scene. There are several ways that noise can be introduced into an image, depending on how the image is created. For example:

If the image is scanned from a photograph made on film, the film grain is a source of noise. Noise can also be the result of damage to the film, or be introduced by the scanner itself.

If the image is acquired directly in a digital format, the mechanism for gathering the data (such as a CCD detector) can introduce noise.

Electronic transmission of image data can introduce noise.

To simulate the effects of some of the problems listed above, the toolbox provides the imnoise function, which you can use to add various types of noise to an image. The examples in this section use this function.

6. Removing Noise By Linear Filtering

You can use linear filtering to remove certain types of noise. Certain filters, such as averaging or Gaussian filters, are appropriate for this purpose. For example, an averaging filter is useful for removing grain noise from a photograph. Because each pixel gets set to the average of the pixels in its neighborhood, local variations caused by grain are reduced.

See Designing and Implementing Linear Filters in the Spatial Domain for more information about linear filtering using imfilter.

7. Removing Noise By Median Filtering

Median filtering is similar to using an averaging filter, in that each output pixel is set to an average of the pixel values in the neighborhood of the corresponding input pixel. However, with median filtering, the value of an output pixel is determined by the median of the neighborhood pixels, rather than the mean. The median is much less sensitive than the mean to extreme values (called outliers). Median filtering is therefore better able to remove these outliers without reducing the sharpness of the image. The medfilt2 function implements median filtering.

Note Median filtering is a specific case of order-statistic filtering, also known as rank filtering. For information about order-statistic filtering, see the reference page for the ordfilt2 function.

jar:file:///C:/Program%20Files/MATLAB/R2010a/help/toolbox/images/help.jar!/ordfilt2.html

jar:file:///C:/Program%20Files/MATLAB/R2010a/help/toolbox/images/help.jar!/medfilt2.html

jar:file:///C:/Program%20Files/MATLAB/R2010a/help/toolbox/images/help.jar!/imfilter.html

jar:file:///C:/Program%20Files/MATLAB/R2010a/help/toolbox/images/help.jar!/imnoise.html

jar:file:///C:/Program%20Files/MATLAB/R2010a/help/toolbox/images/help.jar!/f16-14527.html

The following example compares using an averaging filter and medfilt2 to remove salt and pepper noise. This type of noise consists of random pixels' being set to black or white (the extremes of the data range). In both cases the size of the neighborhood used for filtering is 3-by-3.

1. Read in the image and display it.

I = imread('eight.tif');imshow(I)

2. Add noise to it.

J = imnoise(I,'salt & pepper',0.02);figure, imshow(J)

3. Filter the noisy image with an averaging filter and display the results.

K = filter2(fspecial('average',3),J)/255;figure, imshow(K)

4. Now use a median filter to filter the noisy image and display the results. Notice that medfilt2 does a better job of removing noise, with less blurring of edges.

L = medfilt2(J,[3 3]);figure, imshow(L)

8. Removing Noise By Adaptive Filtering

The wiener2 function applies a Wiener filter (a type of linear filter) to an image adaptively, tailoring itself to the local image variance. Where the variance is large, wiener2 performs little smoothing. Where the variance is small, wiener2 performs more smoothing.

This approach often produces better results than linear filtering. The adaptive filter is more selective than a comparable linear filter, preserving edges and other high-frequency parts of an image. In addition, there are no design tasks; the wiener2 function handles all preliminary computations and implements the filter for an input image. wiener2, however, does require more computation time than linear filtering.

wiener2 works best when the noise is constant-power ("white") additive noise, such as Gaussian noise. The example below applies wiener2 to an image of Saturn that has had Gaussian noise added.

1. Read in an image. Because the image is a truecolor image, the example converts it to grayscale.

RGB = imread('saturn.png');I = rgb2gray(RGB);

2. The example then add Gaussian noise to the image and then displays the image. Because the image is quite large, the figure only shows a portion of the image.

J = imnoise(I,'gaussian',0,0.025);imshow(J)

Portion of the Image with Added Gaussian Noise

3. Remove the noise, using the wiener2 function. Again, the figure only shows a portion of the image

K = wiener2(J,[5 5]);figure, imshow(K)

jar:file:///C:/Program%20Files/MATLAB/R2010a/help/toolbox/images/help.jar!/wiener2.html

Portion of the Image with Noise Removed by Wiener Filter

To Add noise in pic :- imnoise

Add noise to image

Syntax

J = imnoise(I,type)J = imnoise(I,type,parameters) J = imnoise(I,'gaussian',m,v)J = imnoise(I,'localvar',V)J = imnoise(I,'localvar',image_intensity,var)J = imnoise(I,'poisson')J = imnoise(I,'salt & pepper',d)J = imnoise(I,'speckle',v)

Description

J = imnoise(I,type) adds noise of a given type to the intensity image I. type is a string that can have one of these values.

Value Description

'gaussian' Gaussian white noise with constant mean and variance

'localvar' Zero-mean Gaussian white noise with an intensity-dependent variance

'poisson' Poisson noise

'salt & pepper' On and off pixels

'speckle' Multiplicative noise

J = imnoise(I,type,parameters) Depending on type, you can specify additional parameters to imnoise. All numerical parameters are normalized; they correspond to operations with images with intensities ranging from 0 to 1.

J = imnoise(I,'gaussian',m,v) adds Gaussian white noise of mean m and variance v to the image I. The default is zero mean noise with 0.01 variance.

J = imnoise(I,'localvar',V) adds zero-mean, Gaussian white noise of local variance V to the image I. V is an array of the same size as I.

J = imnoise(I,'localvar',image_intensity,var) adds zero-mean, Gaussian noise to an image I, where the local variance of the noise, var, is a function of the image intensity values in I. The image_intensity and var arguments are vectors of the same size, and plot(image_intensity,var) plots the functional relationship between noise variance and

image intensity. The image_intensity vector must contain normalized intensity values ranging from 0 to 1.

J = imnoise(I,'poisson') generates Poisson noise from the data instead of adding artificial noise to the data. If I 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.

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.

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.

Note The mean and variance parameters for 'gaussian', 'localvar', and 'speckle' noise types are always specified as if the image were of class double in the range [0, 1]. If the input image is of class uint8 or uint16, the imnoise function converts the image to double, adds noise according to the specified type and parameters, and then converts the noisy image back to the same class as the input.

Class Support

For most noise types, I can be of class uint8, uint16, int16, single, or double. For Poisson noise, int16 is not allowed. The output image J is of the same class as I. If I has more than two dimensions it is treated as a multidimensional intensity image and not as an RGB image.

ExamplesI = imread('eight.tif');J = imnoise(I,'salt & pepper',0.02);figure, imshow(I)figure, imshow(J)

OverviewWhen you create a modular tool and associate it with a target image, the tool automatically makes the necessary connections to the target image to do its job. For example, the Pixel Information tool sets up a connection to the target image so that it can display the location and value of the pixel currently under the pointer.

As another example, the Overview tool sets up a two-way connection to the target image:

Target image to the Overview tool — If the visible portion of the image changes, by scrolling, panning, or by changing the magnification, the Overview tool changes the size and location of the detail rectangle to the indicate the portion of the image that is now visible.

Overview tool to the target image — If a user moves the detail rectangle in the Overview tool, the portion of the target image visible in the scroll panel is updated.

The modular tools accomplish this interactivity by using callback properties of the graphics objects. For example, the figure object supports a WindowButtonMotionFcn callback that executes whenever the mouse button is depressed. You can customize the connectivity of a modular tool by using the application programmer interface (API) associated with the tool to set up callbacks to get notification of events.

For example, the Magnification box supports a single API function: setMagnification. You can use this API function to set the magnification value displayed in the Magnification box. The Magnification box automatically notifies the scroll panel to change the magnification of the image based on the value. The scroll panel also supports an extensive set of API functions. To get information about these APIs, see the reference page for the modular tool.

Example: Building an Image Comparison Tool

To illustrate how to use callbacks to make the connections required for interactions between tools, this example uses the Scroll Panel API to build a simple image comparison GUI. This custom tool displays two images side by side in scroll panels that are synchronized in location and magnification. The custom tool also includes an Overview tool and a Magnification box.

function my_image_compare_tool(left_image, right_image)

% Create the figurehFig = figure('Toolbar','none',... 'Menubar','none',... 'Name','My Image Compare Tool',... 'NumberTitle','off',... 'IntegerHandle','off'); % Display left image subplot(121) hImL = imshow(left_image);

% Display right imagesubplot(122)hImR = imshow(right_image);

% Create a scroll panel for left imagehSpL = imscrollpanel(hFig,hImL);set(hSpL,'Units','normalized',... 'Position',[0 0.1 .5 0.9])

% Create scroll panel for right imagehSpR = imscrollpanel(hFig,hImR);set(hSpR,'Units','normalized',... 'Position',[0.5 0.1 .5 0.9])

% Add a Magnification box hMagBox = immagbox(hFig,hImL);pos = get(hMagBox,'Position');set(hMagBox,'Position',[0 0 pos(3) pos(4)])

%% Add an Overview toolimoverview(hImL)

%% Get APIs from the scroll panels apiL = iptgetapi(hSpL);apiR = iptgetapi(hSpR);

%% Synchronize left and right scroll panelsapiL.setMagnification(apiR.getMagnification())apiL.setVisibleLocation(apiR.getVisibleLocation())

% When magnification changes on left scroll panel, % tell right scroll panelapiL.addNewMagnificationCallback(apiR.setMagnification);

% When magnification changes on right scroll panel, % tell left scroll panelapiR.addNewMagnificationCallback(apiL.setMagnification);

% When location changes on left scroll panel, % tell right scroll panelapiL.addNewLocationCallback(apiR.setVisibleLocation);

% When location changes on right scroll panel, % tell left scroll panelapiR.addNewLocationCallback(apiL.setVisibleLocation);

The tool sets up a complex interaction between the scroll panels with just a few calls to Scroll Panel API functions. In the code, the tool specifies a callback function to execute every time the magnification changes. The function specified is the setMagnification API function of the other scroll panel. Thus, whenever the magnification changes in one of the scroll panels, the other scroll panel changes its magnification to match. The tool sets up a similar connection for position changes.

The following figure is a sequence diagram that shows the interaction between the two scroll panels set up by the comparison tool for both changes in magnification and location.

Scroll Panel Connections in Custom Image Comparison Tool

To use the image comparison tool, pass it two images as arguments.

left_image = imread('peppers.png');right_image = edge(left_image(:,:,1),'canny');my_image_compare_tool(left_image,right_image);

The tool opens a figure window, displaying the two images side by side, in separate scroll panels. The custom compare tool also includes an Overview tool and a Magnification box. When you move the detail rectangle in the Overview tool or change the magnification in one image, both images respond.

m.tech (sharpening , blurring ,noise of an image)

Documents

configuration dialog box

matlab command prompt

video viewer1 window

video viewer window

step solver pane

fir filter block

left scroll panel

selecting configuration parameters