Prelab 6 - Image Enhancing
In this prelab, you get familiarized with two common tasks in image processing: histogram equalization and 2-D convolution.
Refer to the Submission Instruction page for more information.
Digital images are made up of picture elements, more commonly known as pixels arranged in a rectangular grid. Three frequently encountered image formats are:
Binary image: are 2D arrays which has only two values 1 or 0 where 1 corresponds to white and 0 corresponds to black.
Intensity or grey scale image: are 2D arrays where pixel intensities have a n-bit representation. For example, an 8-bit image has a variation from 0 to 255 where 0 represents black, 255 represents white and intermediate values correspond to gray levels that span the range from black to white.
RGB color image: are 3D arrays that assign three numerical values to each pixel, each value correponds to the red, green, and blue image channel, respectively.
Part 1 - Image Enhancement
One simple image enhancement method is increasing the image brightness. For grayscale images, we could increase the image brightness by adding some constant value to every single pixel of the image. Use the following Python script to load the image
cameraman.tif, and implement the
imadd() function to increase the brightness of the image.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
import numpy as np from scipy import misc import matplotlib.pyplot as plt import copy %matplotlib inline # Implement this function def imadd(pic,brightness=50): # Add brightness to each pixel return pic # Read the image cameraman_origin = misc.imread('cameraman.tif') # Create a copy of the origina image for us to manipulate cameraman_bright = copy.deepcopy(cameraman_origin) # Call imadd to perform enhancement cameraman_bright = imadd(cameraman_bright,50) # Show the results fig_cam_origin = plt.figure(1) fig_cam_origin.suptitle('Original Image') plt.imshow(cameraman_origin,cmap='gray',vmin = 0, vmax = 255) fig_cam_bright = plt.figure(2) fig_cam_bright.suptitle('Brightened Image') plt.imshow(cameraman_bright,cmap='gray',vmin = 0, vmax = 255) plt.show()
Increase the brightness of 'cameraman.tif' by
brightness = 50. Then try increasing brightness by 300. Repeat for image
- What is the dynamic range (the number of distinct pixel values in an image) of the orginal and the enhanced image?
- What will happen if we increase brightness by 300.
- Could you enhance the quality of the image
eco.tifby simply increasing its brightness?
cameraman.tifis a grayscale image, with single channel and pixels of type
eco.tifis a grayscale image, with single channel and pixels of type
Part 2 - Histogram Equalization
Histogram equalization is one of the most commonly used image contrast enhancement technique. The approach is to design a transformation(or colormap) in such a way that the gray values in the output image are uniformly distributed. More detailed explanation can be found here: Histogram Equalization Tutorial
Use the following Python script to load the image 'eco.tif', and apply histogram equalization. You will have the chance to implement this function in lab 6.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
import matplotlib.pyplot as plt import numpy as np from scipy import misc from skimage import exposure import copy %matplotlib inline # Read the image eco_origin = misc.imread('eco.tif') # Apply Histogram Equalization here! # Show the results fig_cam_origin = plt.figure(1) fig_cam_origin.suptitle('Original Image') plt.imshow(eco_origin,cmap='gray') fig_cam_bright = plt.figure(2) fig_cam_bright.suptitle('HistEq Image') plt.imshow(eco_histeq,cmap='gray') plt.show()
Use the skimage.exposure.equalize_hist() function to process the image 'eco.tif' and show the results. Note that this histeq function will return images with float pixel values between 0 and 1.
Can you improve the result of enhancement by repeating the histogram equalization? Why?
Part 3 - 2-D Convolution
2-D Convolution, or image filtering, is an important method to process the image. The concept is very similar to 1-D convolution that we have been using before. In 1-D convolution, we compute the value of x[t] based on some linear combination of values of range x[t-k:t]; in 2-D convolution, we compute the value of pixel(row,col) based on some linear combination of its neighboring pixels. This linear combination is represented by a kernel.
In image processing, a kernel, convolution matrix, or mask, is a small matrix that we used as filter to process the image. There are all kinds of kernels to serve different purposes, such as gaussian kernel (low-pass filter), sharpening kernel (high-pass filter), etc. More explanation and examples of Kernel
The computation of 2-D convolution is also straightforward, for each pixel, we update its value based on the combination of its neighbouring pixels specified by the kernel. More explanation and examples of 2-D Convolution
Use the following Python script to load the image
kitten.png, and use
scipy.signal.convolve2d to apply an Gaussian Smoothing Filter to the image. Different from 1-D convolution, we want the filtered image to be the same size as before.
import numpy from scipy import misc from scipy import signal import matplotlib.pyplot as plt # Gaussian Kernel Following the Descriptiong: # http://www.mathworks.com/help/images/ref/fspecial.html def gengaussian(size=5,sigma=3.0): if size%2==0 or size<2: print('Size Not Valid') return None kernel = numpy.zeros((size,size)) for x in range(size): for y in range(size): kernel[x][y] = numpy.exp(-((x-(size-1)/2)**2 \ +(y-(size-1)/2)**2)/(2*sigma**2)) kernel = kernel / numpy.sum(kernel) return kernel # Read Image and Display kitten_origin = misc.imread('kitten.png') # Create a copy of the origina image for us to manipulate kitten_blur = copy.deepcopy(kitten_origin) # Generate Kernel kernel = gengaussian(5) # Apply Convolution Here! # Display Results fig_kitten_origin = plt.figure(1) fig_kitten_origin.suptitle('Original Kitten.png', fontsize=14, fontweight='bold') plt.imshow(kitten_origin,vmin = 0, vmax = 255) fig_kitten_blur = plt.figure(2) fig_kitten_blur.suptitle('Blurred Kitten.png', fontsize=14, fontweight='bold') plt.imshow(kitten_blur,vmin = 0, vmax = 255) plt.show()
Use the signal.convolve2d() function to process the image
kitten.png and show the results. Change the sigma value of the gaussian kernel and describe its effects.
kitten.png is a RGB image, with three channels and pixels of type
Prelab 6 will be graded as follows:
Assignment 1 [0.75 point]
Plots of brightness enhanced images [0.5 point]
Short answer question [0.25 point]
Assignment 2 [0.75 point]
Plots of histogram equalized images [0.5 point]
Short answer question [0.5 point]
Assignment 3 [0.5 point]
Plots of gaussian filtered images with different sigma value [0.5 point]