Counterspell

Act 19: Restoration of blurred image

2009-10-10T08:17:00.000-07:00

In this activity, we blur and noise an image, and using the knowledge of the process involved in the degradation of the image, we attempt to restore it.

First, we make use of this image

(source: http://www.misterguitar.us/news/images/tapestry1969.jpg)

We then degrade the image by blurring, which is governed by

where a and b are the total respective x- and y- displacement.
and adding Gaussian noise, using (grand, 'nor' function in Scilab), whose Fourier transform is represented as N(u,v). The degraded image is obtained from the equation

where F(u,v) is the Fourier transform of the original image.

We now try to vary the parameters and see the resulting image. First, we hold T=1, and vary a and b, a=1 b=1, a=0.1 b=0.1, a=0.01 b=0.01, a= 0.001 b=0.001. The resulting respective images are shown below.

It can be seen that as a and b are increased the image becomes less blurred, and the features become discernible once again.

This time we hold a=0.01 b=0.01, and vary T, T=0.001, T=0.01, T=0.1, T=1, T=10, T=1000

It can be seen that the image inverts at small T, while it reverts and approach a certain threshold as T is increased.

Next, we attempt to reconstruct the image using Weiner filtering.

where

Since the power spectrum of the undegraded image is known, we can use this filtering. We make use of the image a=0.01 b=0.01 T=1

Note that the above is only applicable when the power spectrum of the undegraded image is known, i.e. we have the original image at hand. Supposing it is unkown, we can guess a good value by letting the ratio of the power spectra become K, an arbitrary constant. In equation form:

Making use of K=0.1, K=0.0001, K=0.000001, we obtain these images

It can be seen that decreasing K improves the image, thus the ratio of the power spectra must be small.

I will give myself a grade of 10/10 for completing this activity. Again, I would like to thank Earl for the cooperative effort, and Gilbert for showing me that (1.)/ is correct for matrix inversion instead of just 1./.

Act 18: Noise models and basic image restoration

2009-09-16T19:05:00.000-07:00

In this activity, we make use of a grayscale image, apply noise to it, and using knowledge of the noise present in the image, try to recover its quality.

We make use of the image similar to the one provided in the Activity 18 manual and its pdf (above), as well as an image downloaded from the internet and its pdf (below):

Source: (http://www.stevennoble.com/closer_look/SLS_Corporate_Logo_th.jpg)

We apply different kinds of noise to it.
Gaussian:

Rayleigh:

Erlang or gamma:

Exponential:

Uniform:

Impulse or "salt and pepper":

Since the noises in the images were applied onto an original image, we try to reconstruct the images using four kinds of filters which are suited for additive noises. These are arithmetic mean filter, geometric mean filter, harmonic mean filter, and contraharmonic mean filter. Applying these filters for each image will yield the following (note that the images are sequenced in the with respect to the sequence of the filters mentioned above):

For the Gaussian noise:
Arithmetic

Geometric

Harmonic

Contraharmonic

(For the next sets of images, the order of the filter used follows suit.)
For the Rayleigh noise:

For the Erlang noise:

For the exponential noise:

For the uniform noise:

For the impulse noise:

It can be seen from the resulting images that the filters yielded somewhat similar reconstructions, save for the contraharmonic filter (where Q=2) which yielded images that had inverted colors. The harmonic and geometric filters had similar reconstructions. It is interesting to note that both images reconstructed using these two filters had black dots scattered at some parts of the image. Also, a subtle difference between the two is that the harmonic image is a bit darker. The arithmetic filter seems suitable for most applications in general; the images yielded by this filter looks fine in most cases.

We now investigate the effects of varying the order of the filter Q in the salt-and-pepper noise.
For Q=2 and Q=-2:

For Q=1 and Q=-1:

For Q=0.1 and Q=-0.1:

For Q=0.01 and Q=-0.01:

It can be seen that the contraharmonic filter attempts to mask the "pepper" noise by applying white patches on it when Q is positive, while the reverse happens for when Q is positive. Long blog is long. These patches become larger when the absolute value of Q is increased, but is barely noticeable when set too low. Based on my observation, it is better to eliminate "pepper" noise, since black on a grayscale image is more discernible.

I will give myself a grade of 10/10 for this activity since I have completely done all the steps. I would like to thank Earl for his help with the filters and Gilbert for providing me with the modnum toolbox necessary to generate Rayleigh noise.

Act 17: Photometric Stereo

2009-09-08T02:04:00.000-07:00

In this activity, we attempt to construct a 3-D image using four pictures of the same synthetic spherical image. These four images are for the four different locations of the point source namely:

V1 = {0.085832, 0.17365, 0.98106}
V2 = {0.085832, -0.17365, 0.98106}
V3 = {0.17365, 0, 0.98481}
V4 = {0.16318, -0.34202, 0.92542}

The image as displayed in Matlab is displayed below:

First, we compute the surface normal of the image, which is given in the following equation

where g is computed from

From the obtained surface normals, nx, ny and nz were used to obtain the partial derivatives of f(u,v) with respect to both x and y using the following equations:

To get f, the equation below was used

The Scilab function cumsum can be done in lieu of integration. The obtained surface normal was then plotted using plot3d, and the reconstruction is shown below.

I will give myself a grade of 10/10 since this activity was accomplished within the period. I would like to thank Earl for the cooperation and Martin for helping us with the final parts of the code.

Act 16: Neural Networks

2009-09-02T18:09:00.000-07:00

In this activity, we also classify objects, except this time we make use of neural networks. A neural network is a computational model of how neurons in brains work. In comparison to linear discriminant analysis, there is no need to set rules to classify. Rather, neural networks learn the rules by examples which it then applies to the objects to be classified.

For this activity, we make use of the two classes in Activity 15. Cole's neural network code was used for this activity. After setting a seed so that each run will be consistent, we first make a training set:

x = [0.38 0.39;
0.35 0.38;
0.33 0.38;
0.31 0.36;
0.13 0.27;
0.12 0.27;
0.09 0.2;
0.09 0.2]

Note that the first column is the pixel area/1000 of the object and the second column is the red color channel value of the object. We set the values for classifying the objects as

[0 0 0 0 1 1 1 1]

This means that the first four items correspond to the class 0, which is the white squash seed while the other items correspond to the small round seed. We can now run the test set since the neural network has learned how to classify the objects. Our inputs for the test set are

x1 = [0.35 0.38;
0.31 0.36;
0.12 0.27;
0.11 0.25;
0.11 0.24;
0.1 0.23;
0.1 0.22;
0.09 0.22;
0.09 0.2;
0.09 0.2;
0.33 0.38;
0.1 0.24;
0.3 0.36;
0.28 0.35;
0.26 0.31;
0.24 0.3;
0.13 0.27;
0.38 0.39;
0.27 0.35;
0.27 0.34]

We set the learning rate to 1.0 and the training cycle to 1000. By manual classification, the output should be

[0 0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 1 0 0 0]

The output of the neural network is:

[0.0081117 0.0258541 0.9832197 0.9897846 0.9904403 0.9936995 0.9940926 0.9957981 0.9962910 0.9962910 0.0134392 0.9932781 0.0346688 0.0675553 0.1581799
0.2973589 0.9757485 0.0039843 0.0923583 0.0977971 ]

Rounded off, this becomes:

[0 0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 1 0 0 0]

We can see that the neural network has correctly classified the objects.

The value of the learning rate was then adjusted. I found out that decreasing the learning rate decreases the accuracy of the network. When set too low, the output values all become zero. Setting the training cycle too low will also have the same effect.

I will give myself a grade of 10 for this activity. Again, I would like to thank Earl for helping me collect the data in Activity 15, since it was used for this activity.

Act 15: Probabilistic Classification

2009-09-02T18:08:00.000-07:00

In this activity, we make of use the results of Activity 14 and segregate two classes of objects in the image. In linear discriminant analysis (LDA) , this is done in two ways. First, a set of features that best distinguish an object is chosen, and then a classification rule or model is used to separate the objects. Much information for this activity was taken from http://people.revoledu.com/kardi/tutorial/LDA/.

We make use of the test image similar to Activity 14, except we eliminate all the largest seeds so that we will be left with only two groups.

The method for distinguishing the features of the objects used was also similar to that of Activity 14. From these data, we make use of LDA to classify the two objects into two separate classes. If LDA works, the separator between the two groups should be a line. Classifying the two groups with two discriminant functions will yield the plot below

It can be seen that the graph can easily be separated by a line. In fact, the two objects seem too distinct with each other.

I will give myself a grade of 10/10 for finishing this activity. I would like to thank Earl for this help in both data collection and programming.

Act 14: Pattern Recognition

2009-08-26T17:45:00.000-07:00

In this activity, we extract patterns from a given image using image processing in order to define a set of features that will allow us to separate the the set into classes, and to find the most suitable classifier for the task, since some objects can have similar parameters. This prompts us to search for other parameters that may be unique. We take the mean of the numerical values of each of these parameters, and we then compare each object's parameter to the respective mean parameter. For an object to belong to a certain class, their parameter should be close to the mean.

We make use of an assembly of three different kinds of bird seeds: small round seeds, white squash seeds and large reddish-brown seed.

The parameters that were took into account were the size of the seeds and their red color channel values. The graph below summarizes the objects parameter's qualities:

The red colored dot stands for the mean value of the small round seed, the blue for the white squash seed and the blue for the large reddish-brown seed. It can be seen that similar objects are clustered together, save for a few deviations in color, which is between the class of the small round seeds and the white squash seeds. The color discrepancy may be attributed to the uneven illumination of the objects when the image was taken. However, the sizes of the two smaller seeds are somehow distinct from each other, so we can still infer the class the correctly belong to. The largest seeds are very far apart from the other two classes in terms of size, so the somehow large deviations from the mean does not matter.

I will give myself a grade of 10/10 for this activity since the code has successfully classified the objects. I would like to thank Earl for his assistance in data collection and help in the code.

Act 13: Correcting Geometric Distortion

2009-08-17T17:58:00.000-07:00

In this activity, we correct a barrel distortion in a given image, in this case a grid, using two methods: bilinear interpolation and nearest neighbor method. The image to be reconstructed is shown below:

We compare the image with an ideal grid constructed computationally in Scilab, which shall serve as the reference image.

The vertices of the grid will serve as reference points for the reconstruction. Firstly, the most undistorted image was located from the image, and the number of pixels down and across one box was counted. For each box, c1 to c8 was computed from the four corner points of the box, which is given by the equation below.

which is in matrix-vector notation

Since we are looking for the coefficients, we manipulate the above equation to

We then determine the location of those points in the ideal rectangle using

The locations of the distorted image were found using Scilab's locate function. The results were also rounded off so that they become integer-valued.

Using nearest neighbor method, the reconstructed image looks like this:

while using bilinear interpolation yields the image below.

As expected, the bilinear interpolation has better quality as compared to the grid reconstructed using nearest neighbor method.

For this activity, I will give myself a grade of 10/10 for accomplishing this activity. I would like to thank Gilbert for his tremendous help in this activity.

Act 12: Color Image Segmentation

2009-08-07T05:45:00.000-07:00

In this activity, we try to single out a particular region in a given image by taking a cropped image of the region's surface, and implement it using both parametric segmentation and non-parametric segmentation methods and compare their outcomes. We make use of the image below:

Our region of interest is from that of the silver mouse:

Applying parametric segmentation on the original image using the above region of interest, we get the image below:

As said in the the activity manual, histogram backprojection is similar to what was done in Activity 4, except that the lookup histogram is now two-dimenstional. Thus for the nonparametric part, the following histograms were obtained from the p(r) and p(g) values of the ROI:

Applying histogram backprojection yields the result below

This time, we make use of a portion of the wooden table as a region of interest:

Using parametric segmentation:

The histogram for the nonparametric segmentation is shown below

And the resulting image from histogram backprojection is:

Note that the histograms above correspond properly to the normalized color chromaticity space shown below. The silver mouse appears much more bluish looking and shinier, hence it being closer to both the white and blue regions of the color chromaticity space. On the other hand, the wood ROI, while not exactly white, appears in a region where the colors mix.

It can be seen from the images that the parametric segmentation makes the region of interest much more visible. However, the nonparametric segmentation somewhat recovers specular reflection, as can be seen in both images. Parametric segmentation is more useful when you need to clearly outline the parts of the image that correspond to your region of interest. Nonparametric segmentation may be more useful for manipulating your image, such as changing the regions of interest's colors, hue, brightness, etc.

I will give myself a grade of 8/10 for this activity, due to having finished the exercise. The reduced grade is for not completely understanding the exercise. Hopefully, it will all be explained in the next meeting. I would like to thank Gilbert for helping me with the code in this exercise.

Act 11: Color Image Processing

2009-08-06T05:51:00.000-07:00

In this activity, we intentionally take two wrongly balanced images and apply two types of algorithms to properly balance them: the white patch and gray world algorithm.

The first image is an ensemble of colorful objects:

Applying the white patch algorithm:

Applying the gray world algorithm:

For this image it seems better to use the gray world algorithm; the white patch-rendered image seems too bright and oversaturated. The gray world-rendered image seems more natural compared to the former. This is due to the fact that the gray world takes the average of all the colors in the image, and there seems to be a good balance of colors in the assembled ensemble of objects.

For the next image, we make use of an image with different hues of green

The image below is rendered using the white patch algorithm:

The image below is rendered using the gray world algorithm:

For this case it seems better to use the white patch algorithm since the color saturation of the color green actually messes up the overall average color of the image. The color balance of the gray world image as a result is worse than the original.

I will give myself a grade of 8/10 for this activity for somehow being able to accomplish a good part of this activity, but I am hard pressed for time to take images that are set-up in other lighting conditions. I would like to thank Earl for his cooperative work on this activity as well as Rommel for helping me with setting up the objects for the image.

Act 10: Preprocessing Text

2009-08-06T05:22:00.000-07:00

In this activity, we use the given Untitled_0001.jpg and crop a portion from it. I chose this particular segment

The image was binarized so that it can be processed, and titled by using mogrify so that the lines become horizontal. Performing FFT on the tilted image yields the image for the frequency domain

We can make an appropriate mask to for the above image. I made use of

The masked frequency domain image was returned to the spacial domain using ifft, yielding the image

By applying the appropriate threshold, the image is binarized

Using the closing operator with structural element of a 4x1 matrix consisting of ones, i.e. [1; 1; 1; ], the image below was obtained

Using bwlabel, we can mark the blobs

For the last part of the activity, we are to find all the instances of the word 'DESCRIPTION' in the Untitled_0001.jpg. We apply the same routine used in Template Matching using Correlation section of Activity 5. We start by rotating the image using mogrify so that the image is in its proper orientation. We also crop a part of the image containing the word description and place it in a black background with the same size as the original image, like so

Again, we use the same routine as Activity 5, where we apply fft2 on both images. We the correlate the above image with the binarized and rotated Untitled_0001.jpg. The algorithm yields the image below:

It can be seen from the image that there are three white spots. Looking back at Untitled_0001.jpg, the spots appear at the locations of the word 'DESCRIPTION'. Thus, we can say that there are three instances where the word appears.

I've tried to implement an algorithm for automatically checking for the number of instances the word appears in the image. I made use of a for loop to check the the whole normalized image element per element for values sufficiently close to 1, and count them. Fortunately, a value of 3 instances was returned. Unfortunately, I have yet to check if those 3 actually correspond to the correlations. I'll try to get back at this problem sometime later.

For this activity I will give myself a grade of 8/10 since the final processed image seems rougher than I'd want (i.e. the handwriting isn't exactly 1-pixel thick), but I have properly done the last part. I would like to thank Earl for the helpful discussions, and Mimie for teaching me how to properly use bwlabel in tandem with jetcolormap in imshow.

Act 9: Binary Operations

2009-08-06T04:48:00.000-07:00

In this activity, we make use of the image below:

And determine the average size of the punched holes. First, we segment the image into a number of parts, which in my case was 9, and we set aside one of those images. I used the image below:

The image is used to determine the saturation level appropriate for the whole image in order to binarize the image and to be able to apply the closing operator. The closing operator works by first eroding the image, then dilating it with a structural element. The structural element I used was

which was a binarized cropped image of a punched hole from the image. This allowed the punched holes to somehow “normalize” to their proper size especially if the image does not seem to form a circle, and if possible, allow sufficiently close holes to separate themselves from each other. It was found that the image had an an average hole size of 512, and thus the code is now useable for the other cropped images. By using bwlabel to label the circles, the area of each circle in an image can be computed. The obtained values are tabulated below:

The histogram is plotted below:

The extremely large values can be attributed to the large accumulation of holes which unfortunately was not resolved by the closing operator. It is difficult to resolve overlapping holes since they sometimes do not exhibit a clear border. By limiting the allowable areas to 400 < x < 600 which is the realistic range of areas for a hole, the average was found to be 504 (503.904762).

I will give myself a grade of 9/10 for being able to completely accomplish all the tasks in this exercise. The reduced grade is for the somewhat large area values resulting from my processing, which I feel could be much better. Again, I would like to thank Earl for the discussions and Gilbert for his help in making a histogram for the areas.

Act 8: Morphological Operations

2009-08-05T19:53:00.000-07:00

In this activity, we investigate the effects of the morphological operations erode and dilate when used on an image. We use the following images in particular:

We make use of the following structuring elements on all images for both dilation and erosion operation:
a) 4x4 matrix
b) 2x4 matrix
c) 4x2 matrix
d) a cross 5 pixel long and 1 pixel thick

The images from left to right displayed below will correspond to a to d.
Square
Dilation:

Erosion:

Triangle:
Dilation:

Erosion:

Circle:
Dilation:

Erosion:

Hollow Square:
Dilation:

Erosion:

Cross:
Dilation:

Erosion:

What happens during dilation is that the image expands in the form of the structural element. An example is when the square is dilated using the cross structural element, the square not only expands but its shape also becomes crosslike. Erosion works similarly to dilation, except that it shrinks the image in its form. For example, the hollow square simply becomes four small squares that are positioned in each of the original hollow square's corners.

My submitted predictions were generally correct for the dilation part. Erosion was much harder to predict for me for the triangle, hollow square and cross due to their somewhat irregular shape.

I would grade myself a 9/10 for this activity for being able to perform the operations correctly and a few correct predictions. I would like to thank Earl for his help in this activity.

Act 7: Enhancement in the Frequency Domain

2009-07-13T19:44:00.000-07:00

In this activity, manipulating the frequency domain is used to enhance the image or mask unwanted or unneeded frequencies.

A. Convolution Theorem
We start with an image of two 1-pixel dots:

Using Fourier transform, we obtain this modulus:

Next, we use circles of various radius instead of dots.

Their corresponding FTs are shown below:

We then use two squares instead of circles:

Their corresponding FTs are shown below:

Lastly, we use pairs of Gaussians of variance 0.1, 0.2 and 0.4:

Their corresponding FTs are as follows:

B. Fingerprints: Ridge Enhancement
This time we are to enhance the quality of a fingerprint image. I make use of the image below:

I crop a portion of the image in order to better process it.

The corresponding image in Fourier space of the above image is shown below

The cover up the unwanted frequencies, we use the following mask:

After applying the mask, the image

While its contrast isn't as good as the original image, the fingermarks became much more evened out, and the blotches become less apparent and the ridges are better defined.

C. Lunar Landing Scanned Pictures: Line Removal
This time we are to remove the vertical lines in an image of a lunar landing. The image was reduced in size for faster processing.

Its FT is shown below:

We make use of this mask to hide the lines:

Using the mask, we render the image below:

It can be easily observed that the horizontal lines have been removed due to the mask removing the unwanted frequencies. Thus, we can say that the mask used was appropriate for this image.

D. Canvas Weaved Modeling and Removal
This time we make use of an image of a painting and apply the appropriate mask in order to eliminate the weaves and enhance the brushstrokes.

Its corresponding FT:

We make use of this mask to remove the weaves:

After applying the mask and ifft, the newly rendered image is shown below:

It can be seen that the weaves seem minimized and the brushstrokes are much more prominent as a result. The ifft of the mask is shown below

It can be seen that the pattern is similar to the canvas weaves, and thus, the mask is fitting for this image.

I will give myself a grade of 10/10 for accomplishing all the steps in this activity completely. I would like to thank Raffy and Earl for their help as well as their ideas regarding this activity.

Act 6: Properties of the 2D Fourier Transform

2009-07-08T19:30:00.000-07:00

This activity was divided into two parts. First we were to apply FFT to different 2D patterns and then we were to apply it to various sinusoid forms.

A. Familiarization with FT of different 2D Patterns

In this part, we were to apply the 2D FT to the following patterns (square, annulus, square annulus, slit, dots, respectively):

Applying the FT to these images yields the corresponding outputs:

What happens is that the initial images act as apertures. The second set of images are the output of the apertures.

B. Anamorphic property of the Fourier Transform
This time, we are to apply FT to this image of frequency 4:

which was produced by

z = sin(2*%pi*f*X);

and its various distortions.
For the initial FT, the result was:

Varying the frequency (f = 1, 2, 3, 5, 6) results to

This time, we apply a constant bias of 1, 3, 6, and 9 to the original sinusoid by and apply FT. This results to

Next, we rotate the sinusoid by an angle of 30, 45, 60 and 90. This results to

This time we make use of combination of sinusoids in X and Y. The used combinations are as follows:

1st: z = sin(2*%pi*f*X).*sin(0.5*%pi*f*Y);
2nd: z = sin(2*%pi*f*X).*sin(2*%pi*f*Y);
3rd: z = sin(0.5*%pi*f*X).*sin(0.5*%pi*f*Y);

The output is as follows:

Finally, we add several combinations of sinusoids. The following combinations of varying frequencies were used:

1st:
z = sin(2*%pi*f*X).*sin(2*%pi*f*Y);
a = sin(2*%pi*f*(X*sin(theta)+Y*cos(theta)));
z = z+a;
2nd:
z = sin(2*%pi*f*X).*sin(2*%pi*f*Y);
a = sin(2*%pi*f*(X*sin(theta)+Y*cos(theta)));
b = sin(4*%pi*f*(X*sin(theta)+Y*cos(theta)));
z = z+a+b;
3rd:
z = sin(2*%pi*f*X).*sin(2*%pi*f*Y);
a = sin(2*%pi*f*(X*sin(theta)+Y*cos(theta)));
b = sin(4*%pi*f*(X*sin(theta)+Y*cos(theta)));
c = sin(0.5*%pi*f*(X*sin(theta)+Y*cos(theta)));
z = z+a+b+c;
4th:
z = sin(0.5*%pi*f*X).*sin(0.5*%pi*f*Y);
a = sin(2*%pi*f*(X*sin(theta)+Y*cos(theta)));
b = sin(4*%pi*f*(X*sin(theta)+Y*cos(theta)));
c = sin(0.25*%pi*f*(X*sin(theta)+Y*cos(theta)));
z = z+a+b+c;

The output should be the similar to the previous, except that there should be a corresponding rotation. The output is as follows

As shown from the above, the results are in agreement with my prediction.

I will grade myself 10/10 in this activity for completing all the steps in this activity.

I would like to thank my adjacent seatmates Earl and Rommel for their advice and assistance in this activity.

Act 5: Fourier Transform Model of Image Formation

2009-07-06T19:42:00.000-07:00

In this activity, the various applications of the fast Fourier transform (FFT) were applied. The FFT was implemented using Scilab 4's various FFT functions.

A. Familiarization with discrete FFT
First we were required to perform 2-D FFT, inverse FFT, as well as performing 2-D FFT twice on the same image.

The first image used was this circle:

And the outputs produced were:

The next image used was the letter "A":

And the outputs produced were:

B. Simulation of an Imaging Device
The second part of the activity requires the convolution of this image

to circles of various sizes

The circle is to act as the aperture for the "VIP" image, since a lens basically acts as an FFT to an image. The output is as follows

C. Template Matching using correlation
The third part of the activity makes use of correlation in order to find patterns in an image. This was shown by correlating these two images:

so that the A's in the image can be seen. The output of the correlation is this image:

D. Edge detection using the convolution integral
The final part of the activity requires the convolution of various 3x3 matrices with this image:

The matrices used were as follows:
vertical: horizontal: diagonal: spot:
[-1 -1 -1] [-1 2 -1] [-1 -1 2] [-1 -1 -1]
[ 2 2 2] [-1 2 -1] [-1 2 -1] [-1 8 -1]
[-1 -1 -1] [-1 2 -1] [ 2 -1 2] [-1 -1 -1]

The output images are as follows:

What happens is that the matrix pattern highlights the edge that is related to it. For example, in the first image, the original image was convolved with a horizontal matrix, thus resulting to the horizontal parts of the edge of the image being highlighted.

I would like to grade myself 10/10 for fully accomplishing this activity in the given time. Also, I would like to thank Earl and Raffy for helping me improve my code.

Act 4: Enhancement by Histogram Manipulation

2009-07-06T18:13:00.000-07:00

In this activity, we make use of a small (256x256 pixel) image:

Its graylevel probability distribution function (PDF), and cumulative distribution function (CDF) are shown below:

above: PDF, below: cdf
Since the CD of a uniform distribution is a straight increasing line. A straight line was then plotted to serve as an idealized CDF. The image was then backprojected onto this new CDF and a new CDF was obtained. Their respective plots are shown below:

above: ideal CDF, mid: new PDF, below: new CDF
And the resulting image is shown below

For the nonlinear response, instead of a straight line, we make use of cubic function (x^3). The idealized CDF, the backprojected histogram and the new CD resulting from the backprojection is shown below:

And the resulting image is shown below:

It can be observed that the linear response has higher contrast compared to the nonlinear distribution, but the image quality of the nonlinear image is much better compared to the linear one.

I will grade myself 10/10 for being able to successfully backproject and render the image for both linear and nonlinear functions. I would like to thank Earl for the discussions and Gilbert for the snippet which enabled me to continue with the code properly.

Act 3: Image types and basic image enhancement

2009-06-22T19:35:00.000-07:00

For this activity, we were required to collect images of various formats. For this, I have chosen the following:

Binary: the "John Hancock" signature
(image courtesy of http://upload.wikimedia.org/wikipedia/commons/thumb/9/90/JohnHancockSignature.svg/384px-JohnHancockSignature.svg.png)

Greyscale: Charlie Chaplin
(image courtesy of http://www.europeancourier.org/118.htm)

Indexed: Van Gogh's "Starry Night"
(image courtesy of http://www.wpclipart.com/art/Paintings/Van_Gogh/VanGogh_starry_night.png.html)

True Color: the Great Barrier Reef
(image courtesy of http://www.gmcc-09.com/welcome-to-melbourne/the-country/)

Aside from finding various images on the internet, we are also required to scan an object, preferably with a distinct border. Along with Earl, I used a map of Japan:

except in my activity, I chose Kyushu to be my region of interest. The image was binarized, and the following image was obtained:

It is now possible to apply the follow function in order to obtain the contour of the image so that it becomes possible to apply the Green’ s theorem and obtain the area of the image. The area can also be computed by taking the sum of the image since the binary image is simply composed of ones, which represent the white parts of the image, and zeroes, which represent the black parts of the image. Hence, the area of the image is effectively its sum.

The obtained values were:
using Green's theorem: 17946 pixels
using summation: 18600 pixels
% deviation: 3.5161%

The values obtained are sufficiently close to each other. By taking the length of the scale in terms
of pixels, the area of Kyushu can then be calculated by mere conversion.

I will give myself a grade of 10/10 for this activity since the previously learned lessons were successfully applied for this activity. I would like to thank Earl for sharing with me his scanned image of Japan.

Act 2: Area Estimation of Images with Defined Edges

2009-06-22T19:09:00.000-07:00

For this activity, I have used MS Paint to construct the following images:

1. Square

The square has one side measuring 298 pixels, thus the square has 88804 sq. pixels.

2. Rectangle
The rectangle has dimensions 400 x 298 pixels, thus the rectangle's area is l x w = 119200 sq. pixels.

3. Circle
The circle has radius of roughly 147 pixels, thus its area is pi*radius^2 = 67886.676..., which we round down to 67887 sq. pixels.

4. Triangle
The triangle has base of 350 pixels and height of 217, thus its area is 0.5*base*height=37975 sq. pixels.

All images are 500x500 pixels and are originally in bitmap (.bmp) format. I compressed them to jpeg (.jpg) format to make uploading easier.

In order to find the area of the shapes, Green's function was to be used:
In a nutshell, what Green's function does is to slice up a certain figure, take the area of each individual slice, and take the sum of all the slices, yielding the total area of the figure.

To implement Green's function computationally, the following Scilab 4 code was used:

[fig, figmap] = imread('F:/Applied Physics 186/Activity 02/shape.bmp');
[x, y] = follow(fig);
n=length(x);
B=0;
for i=1:n-1,
A = (0.5*(x(i)*y(i+1)-x(i+1)*y(i)));,
B = B+A;,
end;
B

The function follow gives the coordinates of the contour of the figure, while the for loop basically implements the above equation using the contour obtained from follow. B simply displays the output of the summation, or rather, the total area of the figures.

The output of the code, as well as the percent error compared to the manually calculated area is tabulated below:
For this activity, I will grade myself 10/10 for having % error values less than 1%, which means that the Green's function is highly accurate, and is suitable for finding the area of irregular shapes, so long as it has a definite and continuous contour.

I would like to acknowledge Earl and Gary for their insightful discussions with me regarding this activity.

Act 1: Digital Scanning

2009-06-21T05:05:00.000-07:00

In this activity, we were to recreate a hand-drawn graph into digital form using a scanned copy of the said graph and a spreadsheet program such as OpenOffice or Excel.
Due to my assumption that linear graphs were ideal for this activity, I opted to use one. Unfortunately, the graph that I got had its axes in logarithmic scale and as a result, accomplishing it was much more difficult than I expected. After exhausting almost the whole period on the graph, I decided it would be much easier to use a different one. Fortunately, Earl had another graph on the second page of his scanned copy, and thus I was able to use it instead. The source of the new graph was Fesbach’s and Lomon’s The Boundary Condition Model of Strong Interactions at page 63. Also, I was told the original graph can be used in the special project since it was challenging, and at the same time, nobody has done it before (as far as I know). In any case, the process goes as follows: The image was cropped in order to isolate the graph from the rest of the scan using Nero PhotoSnap Viewer Essentials. From there, the dimensions of the graph in terms of the number of pixels were recorded.

Since my graph had two parts with different y-axis dimensions, I chose to split and separately accomplish both graphs. For both cases I chose to crop each of the main plots, discarding the values of the axes in the outside. This is because obtaining the pixel coordinates is much easier this way, and at the same time, the cropped images can be readily used as background for the reconstructed graphs later. I recorded the coordinates of the points on the graph as well as a number of representative points for the trend line using MS Paint. Since the axis of the y-axis is inverted, i.e. downwards is the positive direction, I subtracted the obtained values for the y-coordinates from the total height of the image in terms of its pixels. The ratio of the total length of the graph over the total number of pixels was obtained and used as a multiplying factor for the coordinates, which yields the physical values for the graph. The pixel coordinates for both the points and the trend line's representative points are tabulated below:

This was done for both the points and the trend line plot, except that error bars had to be added to the points.

I plotted the points on an X-Y scatter graph using Microsoft Excel. The scales were formatted so that the ticks and the values resemble those which are on the original graph. The two split graphs were then reconnected.

The representative points in the trend line are shown in the image below:

In order to better show the quality of the reconstruction, the plot area’s background was set to the cropped images:

While not perfect, it can be observed that the obtained digital plot resembles the original hand-drawn plots of the book. One of the major problems encountered in the new graph was that I had no idea how to change the y-axis scale. Thus, I simply chose to reconstruct it by accomplishing two different graphs and the grouping the two together.

Overall, I would give myself a grade of 9/10. The graph was reproduced, points, trend line, error bars and all. The main gripe I have is that I used MS Excel 2007 for plotting, which may have made the process tad easier. Also, the scale’s values weren’t the same as the original, but it was merely a matter of visual display and it doesn’t really affect the actual scale of the original graph itself.

Again, loads of thanks to Earl, for giving me the new graph, as well as for Gilbert, for a few tips on the activity, as well as uploading my blog site to the AP186 Google Group.

Hello world!

2009-06-15T19:46:00.000-07:00

Magandang araw sa inyong lahat!