ap186 blog ni momoy...

Activity 19: Restoration of Blurred Image

2009-10-12T03:17:00.000-07:00

In this activity, we will apply Weiner filtering to restore an image of known degradation (in this case, blur) and additive noise. The process we followed for this activity is shown below:

In the Fourier space, this can be written as

where G, H, F, and N are the Fourier transforms of g (resulting blurry image), h (spatial degradation function), f (original image) , and n (noise), respectively. H is also given as

The original image and the resulting blurry image are shown below. Note that for this blurry image, I used a = b =0.1and T =1.

To restore the image, we use the Weiner filter given below:

with

or

where K is a specified constant.

For this activity, I used both equations. For the first equation, the result is shown below. Notice that improved image was obtained.

For the second equation (with different K values), the results are shown below:

Notice that for this particular image, the minimal blur was obtained with K = 0.001, 0.005, 0.01, and 0.05. For higher K values, the blur is clearly seen.

For this activity, I give myself a 10/10 for meeting the primary objectives of the activity. Thank you to Gilbert for the insights. ^__^

Activity 18: Noise Model and Basic Image Restoration

2009-09-16T18:39:00.000-07:00

In this activity, we are to model noise on a three-value grayscale image and restore those images using different filters.

NOISE MODEL

The noise model used were Gaussian, Rayleigh, Erlang or Gamma, Exponential, Uniform, and the Impluse or Salt and Pepper noise, the probability distribution function of each are shown below:

Rayleigh Noise was modeled using the genrayl function in the modnum toolbox. Salt and Pepper Noise was modeled using the function imnoise and the rest were modeled using the function grand. To verify the added noise, we examined the histogram of each resulting image. It is expected that the histogram follows the shape of the noise added and since we have 3 grayscale values, we will see 3 peaks depending on the parameters used and the interval between the grayscale values. Note that a convolution of the 3 peaks will be observed for smaller grayscale value intervals. Shown below are the histogram of the original image and the images with noise and the corresponding images on the inset.

IMAGE RESTORATION

After noise modeling, we restore the images by using different filters. We apply the filters to mxn (3x3, for my case) subimage window gi centered at point (x , y) and let it run through the whole image. Four filters were used in this activity and these are shown below:

Applying the above filters (in order as that above), the following images resulted:

Salt and Pepper

It is seen that Q>0 in the contraharmonic filter indeed minimizes pepper noise more, Q<0 eliminates the salt noise more, and Q=0 minimizes both salt and pepper noise. For this activity, I give myself a 10/10 since the objectives of the activity were met. Thanks to Jaya for helping me debug my code and Gilbert and Earl for the help.

Activity 17: Photometric Stereo

2009-09-11T19:29:00.000-07:00

For this activity, we are to reconstruct a 3d image from a 2d image taken at different positions of the point source. The images used together with the location of the point source are shown below:
From these 2d images, we will get the depth (z axis) of the images and construct a 3d image. To do this, we consider the intensity of the images are directly proportional to the brightness at that point.
where
and S1 is the position of the point source.

I and V are known from the 2d images. To compute for g we use

and then normalized it by dividing with its length. The resulting normal vectors, we can get the surface elevation.

The resulting 3d image is shown below.
For this activity, I give myself a 10/10 since I was able to reconstruct a 3d image that is accurate enough :D

Many thanks to Earl for helping me a lot in this activity.

Activity 16: Neural Networks

2009-09-11T07:59:00.000-07:00

For this activity, we again classify objects but this time using neural networks. A neural network consists of three parts - the input layer, hidden layer, and the output layer. For our purposes, the input layer consists of the features of the test objects, hidden layer consists of the features of the training objects, and the output layer is the classification of the input layer after it is compared with the hidden layer. In Scilab,to do the classification by neural networks, we need to load the ANN_toolbox and a code courtesy of Jeric Tugaff. The same features from the two previous activities were used in order to compare the efficiency of the techniques we have learned so far. It is imporatant to note that the features should be normalized to be able to classify objects using this method. After implementing the code to the test objects, the output are as follows:

After rounding off the output of the program, we can see that we got a perfect classification. ^_^

For this activity, I give myself a 10/10. Thank you to Gilbert for helping me in this activity.

References:
Maricor Soriano, PhD. Activity 16 - Neural Networks. AP 186 manual.

Activity 15: Probabilistic Classification

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

In this activity, we again classify objects into classes but this time we will use probabilistic classification instead. Specifically, we used Linear Discriminant Analysis or LDA. LDA basically minimizes total error of classification by making the proportion of object that it misclassifies as small as possible [1]. It works by making the features within members of a class near each other and as far as possible to the features of another class. An object is classified into a class where the total error of classification is minimum. As what was done in the previous activity, predetermined features from objects of known classes were used.

Four features were used in this activity. The area and the red, green and blue color from the images. Recall that by using the Euclidian mean, poor classification was obtained for the red feature of the test objects. In this activity, two features are considered for classification. We expect a better classification using this method. The results obtained are as follows:

A perfect classification resulted from this method and with these features. I tried using the blue and green feature for classification also. Recall from Activity 14 that the green feature gives poor classification and blue gives a perfect classification. The results are:
Also a perfect classification was obtained. However, when I tried to use the Red and Green feature, the same classification as that in Activity 14 was obtained. We can say that the red and green feature values of the beads and coins are near each other. Hence we cannot classify them perfectly using the said features. To compensate this, we can use a feature that is distinct for each class and combine it with the problematic feature. This is the technique I have used and it worked.

For this activity, I give myself a 10/10 for this activity for doing it alone and for being able to get a perfect classification.

CODE:
x=[214 0.58 0.54 0.45;
236 0.6 0.56 0.46;
308 0.62 0.56 0.49;
322 0.63 0.56 0.5;
293 0.63 0.56 0.5;
2616 0.29 0.24 0.13;
2604 0.35 0.31 0.14;
2602 0.35 0.31 0.14;
2589 0.29 0.25 0.13;
2613 0.19 0.18 0.09];

test = [247 0.57 0.52 0.44;
208 0.54 0.51 0.42;
192 0.55 0.53 0.43;
194 0.52 0.5 0.41;
193 0.52 0.5 0.41;
2736 0.33 0.3 0.14;
2835 0.43 0.4 0.2;
2904 0.47 0.42 0.22;
2925 0.47 0.42 0.24;
2874 0.45 0.42 0.24];

y=[ 1 1 1 1 1 2 2 2 2 2];
y=y';

x1=x(1:5,:);
x2=x(6:10,:);

mu1 = [sum(x1(:,1))/5 sum(x1(:,2))/5];
mu2 = [sum(x2(:,1))/5 sum(x2(:,2))/5];

mu = [sum(x(:,1))/10 sum(x(:,2))/10];

x1o=[x1(:,1)-mu(:,1) x1(:,2)-mu(:,2)];
x2o=[x2(:,1)-mu(:,1) x2(:,2)-mu(:,2)];

c1 = (x1o'*x1o)/5;
c2 = (x2o'*x2o)/5;

C=(c1*5 + c2*5)/10;
Cinv = inv(C);

p = [1/2; 1/2];

f1=[];
f2=[];

for i = 1:10;
xk = test(i, :);
f1(i) = mu1*C*xk' - 0.5*mu1*C*mu1' + log(p(1));
f2(i) = mu2*C*xk' - 0.5*mu2*C*mu2' + log(p(2));
end

class = f1 - f2;
class(class >= 0) = 1;
class(class < 0) = 2;

Reference:
[1] http://people.revoledu.com/kardi/tutorial/LDA/LDA.html

Activity 14: Pattern recognition

2009-09-09T17:38:00.000-07:00

In this activity, we are to classify objects to classes using the Euclidian mean approximation. A training set is used to extract certain features present in all the classes and is distinct within each class. The mean feature of the training set is used to classify objects of unknown class. The objects I used for this activity are beads from a rosary and 25-centavo coins. These are shown below.

From this set of objects, 5 coins and 5 beads were used as a training set. To extract the features, I used parametric segmentation used in activity 12. The features extracted are the average red (R), green (G), and blue (B) color in the image. Also extracted was the area obtained from the segmented image by first inverting the image using GIMP and then binarizing it in Scilab. The resulting features and the mean features are shown in the table below.

The remaining 5 images of each class were used as the test set. The same processes were done to extract the features of test objects. Afterwhich, the features from each objects were subtracted from the mean feature obtained in the training set. Specifically,

where Dj is the distance of one feature of the test object x from the mean feature mj of each class.

An object is classified as the object in a class where Dj is minimum. The classification in this case was done in Excel. The results are as follows:
Note that 1 = bead and 2 = coin for the classification. From the tables, it can be readily seen that a 100% classification is obtained by examining the area and the blue color present in the images. For the green and red colors, poor classifcation was obtained. This is because the obtained red and green features from the test objects have almost nearvalues. We can conclude that classification by using the Euclidian mean is effective only to a certain extent.

I give myself an 8/10 for this activity for poor classification from the red and green colors and for doing the acivity alone. ^_^

Activity 12: Color Image Segmentation

2009-08-06T18:37:00.000-07:00

For this activity, we are to select a region in the image with a particular color. First we have to transform the color space into a normalized chromaticity coordinates. To do this the following transformations are used:
Since 1=r+g+b, b=1-r-g. Therefore we can transform the color space (3-D) into two coordinate space (2-D), with the brightness associated with I. The image and patch used is shown below:

(Image taken from http://www.magicbob2000.com/resources/Cups%20&%20Balls%20Blue.jpg)

Patch

Two methods were used in this activity - parametric and nonparametric. For parametric a Gaussian Probability Distribution is used. The equation of which is given by
for the red values. The same is true for the green values (p(g)). The probability that a given pixel is inside the region of interest is dictated by prob=p(r)*p(g). For the nonparametric method, histogram backprojection is used. The pixel value in the histogram is used to backproject the value for a particular pixel. The histogram , result of parametric and nonparametric estimation of the image used is shown below:

Histogram

Parametric

Nonparametric

Although both estimations would suffice, a better segmentation is achieved with parametric estimation. It is also interesting that even the red "thingy" is well seen for parametric estimation. For the image used, the objects were separated from the background and from each other. Note however that we are only interested in segmenting the blue cups. Strictly speaking we did not segment the red "thingy". It just so happened that the background is violet (both with red and blue) which are the colors of the object that is why a gray color can be observed. Recall that when segmenting, what happens is that the region of interest becomes white. Any other color has different value.

Code:
stacksize(4e7);
chdir("C:\Documents and Settings\mimie\Desktop\186-12"); patch = imread("patch.jpg"); image = imread("cups.jpg"); ave = patch(:,:,1)+patch(:,:,2)+patch(:,:,3)+1e-7;
R = patch(:,:,1)./ave;
G = patch(:,:,2)./ave;
B = patch(:,:,3)./ave;

r = R*255;
g = G*255;

ave2 = image(:,:,1)+image(:,:,2)+image(:,:,3)+1e-7;
r2 = image(:,:,1)./ave2;
g2 = image(:,:,2)./ave2;
b2 = image(:,:,3)./ave2;
f = zeros(256,256);
for i=1:size(r,1)
for j=1:size(r,2)
x = abs(round(r(i,j)))+1;
y = abs(round(g(i,j)))+1;
f(x,y) = f(x,y)+1;
end
end
//imshow((frequency+0.0000000001));
//mesh(frequency);
//xset("colormap",jetcolormap(256));

\\\\parametric
rmean = mean(R);
rdev = stdev(R);
gmean = mean(G);
gdev = stdev(G);
rprob = (1/(rdev*sqrt(2*%pi)))*exp(-((r2-rmean).^2)/2*rdev);
gprob = (1/(gdev*sqrt(2*%pi)))*exp(-((g2-gmean).^2)/2*gdev);
prob = rprob.*gprob;
prob = prob/max(prob);
scf(0); imshow(image);
scf(1); imshow(prob,[]);

\\\\nonparametric
R2 = r2*255;
G2 = g2*255;
s = zeros(size(image,1),size(image,2));
for i = 1:size(R2,1)
for j = 1:size(R2,2)
x = abs(round(R2(i,j)))+1;
y = round(G2(i,j))+1;
s(i,j) = f(x,y);
end
end
scf(1); imshow(log(s+0.000000000001),[]);
scf(2); imshow(image);

Note:
Comment the parametric to use nonparametric

For this activity, I give myself an 8/10 since I'm not sure if I fully understand the activity.

Activity 11: Camera Processing

2009-08-06T16:58:00.000-07:00

In this activity, we observed the effect of different white balancing options in cameras. Also, we applied the white patch and gray world algorithms on improperly white balanced images. Both RGB objects and objects with same color but different hues were used. It was found that for all images used, it is better to use the white patch algorithm.

For the first part, the same set of images were captured under different white balancing options in the camera. The white balancing options used were cloudy, daylight, fluorescent, fluorescentH, and tungsten. Capturing the images under these conditions is like illuminating the object with a light source with the same color temperature as the white balancing conditions. The images are shown below. The image captured under automatic white balancing is also included for comparison. Note that in the images the order is as follows

automatic white balanced
cloudy daylight fluorescent
fluorescentH tungsten

RGB

GREEN

From the images it can be observed that image taken under the tungsten condition is obviously improperly white balanced. The supposedly white paper appeared blue.

The white patch and gray world algorithms is then applied to these images to for white balancing. Each image has RGB values. In the white patch algorithm, we get a patch from the image that is supposedly white. The RGB value of this patch is used to divide the RGB value of the whole image such that Rn = R/Rw, Gn=G/Gw and Bn=B/Bw where Rn,Gn, Bn are the white balanced RGB values, R,G,B are the original RGB values and Rw,Gw,Bw are the RGB values of the patch.

For the gray world algorithm, it is assumed that the average color is gray. The key term here is "average". To operate the gray world algoirthm, we used average of the R,G, and B values and used this to divide the RGB values of the original image.

The following images are the result of the white patch and gray world algorithms on the images.

RGB IMAGES
Cloudy
Daylight
Fluorescent
FluorescentH
Tungsten

Notice that better images result from the white patch algorithm. The gray world algorithm produces a very bright image. This is maybe because white dominates in the image where it was applied.

GREEN IMAGES

Cloudy
Daylight
Fluorescent
FluorescentH
Tungsten

Like in the RGB images, the white patch algorithm obviously works better. Again, brighter images are observed in the gray world algorithm. Notice though that yellow green notebook became yellow when both algorithms were applied. This may be because the yellow color of the notebook is stronger than that of its green color.

The code:
stacksize(4e7)
rgbwp=imread("F:\186-11\wp.jpg");
rgb=imread("F:\186-11\green\tungsten.jpg");

rw=rgbwp(:,:,1);
gw=rgbwp(:,:,2);
bw=rgbwp(:,:,3);

r=rgb(:,:,1);
g=rgb(:,:,2);
b=rgb(:,:,3);

//white world
Rw = sum(rw)/(size(rgbwp,1)*size(rgbwp,2));
Gw = sum(gw)/(size(rgbwp,1)*size(rgbwp,2));
Bw = sum(bw)/(size(rgbwp,1)*size(rgbwp,2));

//gray world
Rg = mean(r);
Gg = mean(g);
Bg = mean(b);

rr=r/Rw;
rg=g/Gw;
rb=b/Bw;

gr=r/Rg;
gg=g/Gg;
gb=b/Bg;

chuva = [];
chuva(:,:,1)=rr;
chuva(:,:,2)=rg;
chuva(:,:,3)=rb;
chuva(chuva>1) = 1;
//scf(0), imshow(chuva);
//scf(1), imshow(rgb);

chuva2 = [];
chuva2(:,:,1)=gr;
chuva2(:,:,2)=gg;
chuva2(:,:,3)=gb;
chuva2(chuva2>1) = 1; //pin values to 1
//scf(1), imshow(chuva2);

imwrite(chuva,"F:\186-11\result\green\tungstenw.jpg");
imwrite(chuva2,"F:\186-11\result\green\tungsteng.jpg");

Notice that the image values are all pinned to 1.

For this activity, I give myself a 10/10 since I believe I was able to perform the task asked for this activity. Thank you to Neil and Earl for the discussion we had.

Activity 10: Preprocessing Text

2009-08-05T19:28:00.005-07:00

For this activity, we used imaging techniques we've learned so far to process a handwritten document. The goal for the first part is to isolate each letter from each other and from the lines of the form. To remove the lines, we designed a filter such that it blocks the lines. Since the lines are repetitive in the form, they will have intense lines in the Fourier space. Moreover, since I cropped the image such that only horizontal lines are seen, we used a vertical filter. Prior to filtering, the image was rotated using Gimp to make the horizontal lines straight. The original image (cropped and rotated), the filter used, and the resulting image are shown below.
Notice the lines in the form are not visible as it was before although some lines can still be seen in the resulting image. The next part is to isolate the letters from each other by using morphological operators. Prior to that, the image is inverted since the operations work on the white part of the image. By examining the histogram, a threshold value was obtained and was applied to the image to further isolate the text with the background. Afterwhich, morphological operations were applied to isolate each letter and make it 1 pixel thick each. For this particular case I used

erode(erode(dilate(erode(inviconv,se),se),se),se2)

since this gave me the best result so far. The binarized image and the resulting image (after morphological operations were implemented) are shown below.
Notice in the figure that not all letters are 1 pixel thick and some letters are not visible anymore. This is the downside of the morphological operations on the letters. Since in the binarized image the thickness of each letter varies significantly, when morphological operations are applied, some letters (or parts of it) which are originally thin, are erased. A better image is expected if we have almost the same thickness for the letters :P

To make the handwritten more readable, we have to compensate the thickness. Using this operator instead

ero=erode(dilate(erode(inviconv,se),se),se)

give a more a readable result and the erased the remaining lines visible in the binarized object. Although some of you may object that it is not readable enough, my claim is that thatpart is subjective :P

For the second part, we are to perform the correlation of the word "DESCRIPTION" in the text. Assuming that the word has the same size in the image althroughout, strictly speaking, only 3 intense bright spots (corresponding to high correlation) should be observed in the Fourier Transform (FT) since "DESCRIPTION" was appeared only 3 times. However if we are to look at the FT, we have other bright spots. This is because there are white parts that can acoomodate the whole area of "DESCRIPTION". This results to higher correlation and hence a bright spot. An example is the logo on top of the form.
To verify this result, I cropped the image such thatthe logo is annot included anymore. Here we observed the 3 intense spots as what was expected.

For this activity, I give myself a 7/10 since I was not able to isolate the letters from each other, and make a readable 1 pixel thick letter. For me, this seems to be the hardest activity.

Many thanks to Ma'am Jing, Gilbert and Neil for the insights :)

Activity 9: Binary Operations

2009-08-05T19:28:00.003-07:00

In this activity, we are to estimate the size of one punched paper by examining an ensemble. By applying the closing and opening operators in Scilab, we tried to separate nearly touching circles and clean the edges of circles. From here, we plotted the obtained areas and the peak which corresponds to more frequent areas within the ensemble is taken as the area of an individual circle.

The figure below is the image of the ensemble of punched papers. This image is further subdivided into 256x256 subimages. For our discussion, we will refer only to one subimage. All subimages undergone the same morphological operations.

ORIGINAL

SUBIMAGE

The subimage is binarized. The proper threshold value is obtained from its histogram. In depth discussion of which is found in the previous activities. If we are to consider a subimage with only one circle, thresholding is enough. However, an ensemble of circles needs further operations since overlapping of circles may occur. Another reason for further operation is that the area of each circle may vary. The opening and closing operators were implemented on the subimages. Bwlabel in scilab renders a particular color to a blob. A blob is anything white in the binarized image. So long as one circle is connected even with only 1 pixel, bwlabel reads that as one blob. Note that the structuring element used is a circle with a diameter of 4 pixels.

After the subimage undergone the operation it looked like the one below. The subimage (original and binarized) was also posted for comparison.
In the binarized image we can see that the circles were well separated from the background. However, there are still circles that are overlapping. After applying the operator we could see that we were able to separate one circle as one blob which corresponds to a particular area. Note that the extracted areas were the areas of blobs. By tallying the areas we obtained the most occuring area for each subimage. This was done for all 13 subimages. The resulting histogram (below) shows that the most occuring area is at around 541 pixels. To verify this area, I isolated one circle and measured its diameter. The diameter obtained was 26 which orresponds to an area of 530. This is near the value extracted from the histogram.

HISTOGRAM

For this activity I give myself an 8/10 since I am not sure if the operation I used is enough.
Collaborators:
neil, gary, gilbert

Activity 7: Enhancement in the Filter Domain

2009-07-19T09:52:00.000-07:00

In this activity, the convolution theorem is used to enhance images. In the first part of the activity, we explored the convolution theorem. The succeeding parts deals with ridge enhancement, line removal, and canvas weave modeling and removal from images. All of which were done by exploiting the convolution theorem in the Fourier space.

A. Convolution Theorem
For this part, the Fourier transform (FT) of images were done. The images used are two dots of 1 pixel each, circles of different radii, squares of different area symmetric about the center. A Gaussian function of varying variance also was used instead of dots. The following are the images described above and their corresponding FTs.
It can be observed from the above images that with increasing area for circles and squares, the FT becomes smaller. It can also be seen that the FTs are sine and a sinc for circles and a squares, respectively. For FTs for the Gaussian functions decreases in area with increasing variance (or effectively increasing area).

B. Ridge Enhancement
Using the FT of an image, we can create a filter such that only the high frequencies can pass. This is what we did here. High frequencies in your image correspond to bright areas in your Fourier space. These high frequencies are repetitive in your image. Particularly for a fingerprint, these are the ridges. This is the reason why the particular filter below was used. The following shows the original fingerprint, the enhanced fingerprint, the filter used and the FT of the original image. Notice that in the reconstructed image, the blotches were minimized. they were acutally spread out, thus a more enhanced ridges were obtained. However, there is a downside with this enhancement. The reconstructed image was blurry on other areas. This maybe due to the filtered frequencies that should not be filtered out.

C. Line Removal
For this part, The inverse of part B was done. Here, we actually filtered out the bright areas in the image. This bright areas correspond to the lines you like to remove in the image. We designed a filter such that these high frequencies cannot pass. Indeed, we obtained an image without the lines. Again, the following are the image,its FT, the filter used, and the reconstructed image.
D. Canvas Weave Modeling and Removal
The same technique as that in C is applied here. The repetitive patterns of the canvas weave correspond to high frequencies in the Fourier space. To remove the canvas weave in the image, we designed a filter such that these high frequencies are blocked. In the canvas weave modeling, the filter (only the black dots) used is basically the canvas weave patterns. So taking its inverse FT is like modeling the canvas weave itself. However, results showed that the canvas weave model is angled either 90 or 180 degrees with respect to the original canvas. Results are shown below.

Canvas Weave Removal

Canvas weave Model

*** To enhance the image properly, make sure that the FT of the image coincides with the filter design. The problem I encountered was I cannot get an enhanced image. This is because my filter did not actually filtered the frequencies I wanted since it did not coincide with the FT of the image.

I give myself an 8/10 for this activity since I am not sure if I did the ridge enhancement properly. Remember that a blurry image was formed.

Thank you to Gary and Gilbert for suggesting to use "imwrite" instead of" imshow" in obtaining the FTs and designing the filters.

Activity 6: Properties of the 2D Fourier Transform

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

In this activity, the properties of the 2D Fourier Transform (FT) were investigated. For the first part, the FT of a square, donut, square annulus, two slits, and two dots were obtained. The following images show the images with its corresponding FT's.
The second part is to create a 2d sinusoids with different frequencies and obtain their FT's. Results showed that as you increase the frequency, the spacing between the dots in the FT's also increases. This is because at higher frequencies, the spacing between the sinusoids decreases. This is equivalent to an increase in the spacing of the delta function (or in this case, the dots) in the frequency domain. Note that the FT of a sinusoid is a delta function.

On the next part of the activity, we investigated the effect of adding a constant bias on the sinusoid. From the results, it can be seen that adding a negative or positive value of bias does not change the FT as long as the magnitudes are equal. Note that frequency = 4 for all was used.
When the sinusoids are rotated from 0-120, their FTs also rotates, which is in accrodance to the Introduction part of the manual. [1] (frequency = 4)
The product of two sinusoids is a checkerboard with circles or ellipses. Circles are obtained when both the coefficients for X and Y are the same, otherwise, an ellipse. The FTs produced are dots arranged in a square (for circles) and in rectangles (for ellipses) . Notice also that the distribution of the dots has the same shape as the component of the checkerboard. What follows are the images of the generated sinusoids and their corresponding FT's.
For the last part of the activity, the FTs of combinations of the sinusoids with varying rotating angle and the product of two sinusoids were first predicted. Superposition of the waves were basically done. From the linearity property of FT, the FT of the sum of two waves is just the FT of the first wave plus the FT of the second wave. Here, we expect to get the same result as the previous only this time they are rotated. Results verified this linearity property.
For this activity, I give myself an 8/10. Thank you to Raffy for introducing the 'mesh()' function. It was fun to look at the sinusoids in 3D! :D Thank you also to Ma'am Jing for the code :)

**Scilab code can be found in Reference 1.
Note that to see better results, open the image on a new tab :)

Reference:
Dr. Maricor Soriano. AP 186 Activity 6 Manual

Activity 5: Fourier Transform Model of Image Formation

2009-07-06T17:40:00.001-07:00

For this activity, Fourier Transform was implemented on images. The first part of the activity is to get the FFT of a circle and the letter 'A'. Shown below are the original image, the shifted FFT of that image, and the FFT of its FFT. Notice that the third image is just a reconstruction of the original image, only this time it is inverted. This is a property of the inverse FFT - that the inverse FFT is just the same as the forward FFT with the image inverted. [1] This is not readily seen in the circle since it is symmetric in all directions.

The second part of the activity deals with convolution of two images. The system resembles an imaging system with the circle serving as an aperture and the text 'VIP' as the object. The radius of the circle is varied and the following results were obtained.

r=5

r=10
r=15
r = 48.5

As can be seen, the larger the radius of the aperture, the better the reconstruction. This is because the number of frequencies that can pass through is dependent on the size of the aperture. For larger apertures, more frequencies can pass through. Hence a better reconstruction is obtained as opposed to that of apertures with smaller radii.

The third part of the activity is to find the correlation of the letter 'A' in the sentence "THE RAIN IN SPAIN STAYS MAINLY ON THE PLANE." To do this, the FFT of 'A' is multiplied element per element with the FFT of the text. The result shows that the letter A's in the text are highlighted because of high correlation.
The figure above shows the text (1st), the letter 'A' with the same font style and font size, and the resulting image when their FFTs are multiplied element per element.

The last part of the activity shows edge detection using the convolution integral. Four patterns were used (horizontal, vertical, diagonal, and spot). The following results were obtained.
The pattern allows only certain components to be seen. For example, the reconstruction for the horizontal pattern allows only almost horizontal components. Most vertical components are missing in the horizontal pattern, most horizontal components are missing in the vertical pattern, other vertical and horizontal patterns are missing in the diagonal pattern, and most components are present in the spot pattern.

The code (taken from Reference 1):

//first part
I=imread("C:\Documents and Settings\2004-28298\Desktop\activity 5\circle.bmp");
Igray=im2gray(I);
FIgray= fft2(Igray);
fc=abs(fftshift(FIgray))/max(abs(fftshift(FIgray)));
ffc=abs(fft2(FIgray))/max(abs(fft2(FIgray)));
imwrite(fc,"C:\Documents and Settings\mimie\Desktop\activity 5\fc.bmp");
imwrite(ffc,"C:\Documents and Settings\mimie\Desktop\activity 5\ffc.bmp");

//2nd part
o=imread("C:\Documents and Settings\mimie\Desktop\activity 5\vip.bmp");
I=imread("C:\Documents and Settings\mimie\Desktop\activity 5\30r.bmp");
lgray=im2gray(I);
ogray=im2gray(o);
fl=fftshift(lgray);
fo=fft2(ogray);
col=fo.*(fl);
icol=fft2(col);
fimage=abs(icol);
fimagenorm=fimage/max(fimage);
imwrite(fimagenorm,""C:\Documents and Settings\mimie\Desktop\activity 5\vip30r.bmp");

//3rd part
t=imread("C:\Documents and Settings\mimie\Desktop\activity 5\text.bmp");
a2=imread("C:\Documents and Settings\mimie\Desktop\activity 5\A2.bmp");
tgray=im2gray(t);
a2gray=im2gray(a2);
ft=fft2(tgray);
fa2=fft2(a2gray);
cft=conj(ft);
cta2=fa2.*(cft);
fcta2=fft(cta2);
ta2=fftshift(abs(fcta2))/max(fftshift(abs(fcta2)));
imwrite(ta2,"C:\Documents and Settings\mimie\Desktop\activity 5\ta2.bmp");

//last part
i=imread("C:\Documents and Settings\mimie\Desktop\activity 5\vip.bmp");
igray=im2gray(i);
pattern1=[-1,-1,-1; 2,2,2; -1,-1,-1];
pattern2=[-1,2,-1; -1,2,-1;-1,2,-1];
pattern3=[-1,-1,-1; -1,8,-1;-1,2,-1];
pattern4=[2,-1,-1;-1,2,-1;-1,-1,2];

c1=imcorrcoef(igray,pattern1);
c2=imcorrcoef(igray,pattern2);
c3=imcorrcoef(igray,pattern3);
c4=imcorrcoef(igray,pattern4);

c1norm=c1/max(c1);
c2norm=c2/max(c2);
c3norm=c3/max(c3);
c4norm=c4/max(c4);

imwrite(c1norm,"C:\Documents and Settings\mimie\Desktop\activity 5\c1norm.bmp");
imwrite(c2norm,"C:\Documents and Settings\mimie\Desktop\activity 5\c2norm.bmp");
imwrite(c3norm,"C:\Documents and Settings\mimie\Desktop\activity 5\c3norm.bmp");
imwrite(c4norm,"C:\Documents and Settings\mimie\Desktop\activity 5\c4norm.bmp");

**Remember to comment the part of the code you don't need.

Many thanks to Ma'am Jing for providing the code which guided me through this activity. Thank you also to Kaye and Miguel for the discussions we had, and to Raffy for helping me. I give myself a 9/10 for this activity because I did what was expected from the activity.

[1] Dr. Maricor Soriano. Activity 5 Manual.

Activity 4: Enhancement by Histogram Manipulation

2009-07-06T05:30:00.000-07:00

For this activity, a poor contrast image is enhanced by histogram manipulation by following the steps below. The code (if applicable) used and the results accompany the steps.

1. Get an image from the internet or from own collection. Crop if necessary.

I=imread('C:\Documents and Settings\mimie\Desktop\New Folder (2)\activity 4 images\crop.bmp');

2. Change image to grayscale and get its histogram and corresponding Cumulative Distribution Function (CDF).
I=im2gray(I);
gcrop=I/max(I);
imwrite(gcrop, "C:\Documents and Settings\mimie\Desktop\New Folder (2)\activity 4 images\gcrop.bmp");

xsize=size(I,1);
ysize=size(I,2);

x = matrix(0:255,[1,256]);
y = x.*0;
a = 1;

for i = 0:255
m = find(I== i);
y(a) = length(m);
a = a + 1;
end

cs=cumsum(y);
csnorm=cs/max(cs);

3. Backproject the CDF of original image to a linear CDF. Get resulting image, its histogram and its cdf.

//linear desired cdf

for i=1:xsize
for j=1:ysize
n=find(x==I(i,j));
newI(i,j)=cs(n);
end
end

4. Backproject to a nonlinear CDF and get resulting image, histogram, and CDF of reconstructed image.
//nonlinear

z = [0:255];
g = tanh(30.*(x-128)./255);
g = (g - min(g))./2;

plot(x,g);
for i = 1:xsize
for j = 1:ysize
n1 = find(x == I(i,j)); //get index of x from image
y1 = csnorm(n1); //get corresponding y value
n2 = find(g<=y1); //equate with y in desired cdf
newI2(i,j) = csnorm(n2(max(n2)));
end
end

The original image has poor contrast since its pixel values does not cover the entire 0-255 values. By backprojecting its original CDF to a linear CDF with pixel values from 0-255, a better contrast is obtained. When we say backproject, it means that it follows the new CDF, but not perfectly, of course. This can be seen from the CDF of the reconstructed image using a desired linear CDF. When the nonlinear CDF (for this case, hyperbolic tangent) is used, the quality of the image degraded. Notice that the histogram of the reconstructed image is narrower than that of original image. Hence a poorer image contrast was obtained. We can conclude in this activity that image contrast of an image can either be improved or degraded depending on the CDF to which these images are backprojected.

For this activity, I give myself an 7/10. Thank you to Ma'am Jing, Ma'am Gay, Raffy, Kaye, and Neil for the help.

***

Note that to get the histogram and CDF of the reconstructed image, we have to multiply the image to 255 since we had it normalize to 255 before displaying it.
to change the color of plot to green : plot(x,y,,['g']) may apply to other colors as well :)

References
1. Dr. Maricor Soriano. Activity 4 manual.
2. image taken from: http://yrekahigh.com/Portals/1/YrekahighPics/Misc_%20Pictures/Old%20Yreka%20High.bmp

Activity 3: Image Types and Basic Image Enhancement

2009-06-24T07:31:00.000-07:00

True Color (RGB)

FileSize: 139787
Format: JPEG
Width: 800
Height: 771
Depth: 8
StorageType: truecolor
NumberOfColors: 0
ResolutionUnit: inch
XResolution: 72.000000
YResolution: 72.000000

http://us.fun.marinov.net/store/Village%20Scenery/Village%20Scenery%20-%201.jpg

Indexed

FileSize: 28933
Format: GIF
Width: 500
Height: 344
Depth: 8
StorageType: indexed
NumberOfColors: 8
ResolutionUnit: centimeter
XResolution: 72.000000
YResolution: 72.000000

http://www.wingo.com/opinion/watch_out_kid.gif

Grayscale

FileSize: 97685
Format: JPEG
Width: 450
Height: 342
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: inch
XResolution: 72.000000
YResolution: 72.00000

http://gsc.nrcan.gc.ca/labs/ebeam/images/sem8.jpg

Binary

FileSize: 38062
Format: BMP
Width: 775
Height: 380
Depth: 8
StorageType: indexed
NumberOfColors: 2
ResolutionUnit: centimeter
XResolution: 118.430000
YResolution: 118.430000

http://baec.tripod.com/AUGUST01/pics/binary_counter.bmp

************************************************
For the second part of the activity, a scanned image was enhanced using the threshold value from the histogram. Thresholding is basically making the region of interest (ROI) of the image well separated from the background. In this activity, a scanned image of a leaf was used.

The image cropped using gimp. The colors were also inverted since I wanted the leaf to be the region of interest. Using scilab, the image was converted to grayscale. Its histogram and image properties were also obtained using the code below. The results then followed.

I=imread("C:\Documents and Settings\mimie\Desktop\leafginv.jpg");
I=im2gray(I);

//histogram
a = 1;
x= [];
y= [];
for i = 0:256
m = find(I== i);
x(a) = i;
y(a) = length(m);
a = a + 1;
end

scf(1)
plot(x,y/max(y)) //end of histogram routine

imshow(I)
imfinfo('C:\Documents and Settings\mimie\Desktop\leafginv.jpg')

Image Properties:
filename: C:\Documents and Settings\mimie\Desktop\leafginv.jpg
filesize:7359
format: jpeg
width: 207
height: 138
depth: 8
storage type: indexed
number of colors: 256
resolution unit: inch
x resolution: 0
y resolution: 0

The histogram of a grayscale image runs from 0 to 255, 0 being black and 255 being white. From the histogram obtained, it can be seen that the ROI (around the second peak) is well separated from the background (the first peak). Also,the threshold value when this image is to be converted into binary is somewhere between 50/255 to 120/255. I used the average [(120+50)/2]/255 as the threshold value and obtained

Converting to binary image (in the command window):

i=im2bw(I,85/255);
imshow(i)

Using the area calculation from 1, the area obtained using Green's theorem, by pixel counting, and the relative error between the two are:

area = 15979
theo = 15978
%error: 0.0062586

To verify the threshold values obtained using scilab, Gimp can be used.

1. Click 'Colors' -->'Threshold' (This will turn the grayscale image into black and white.)
2. Adjust the arrows (or the values) until the ROI is well separated from the background
3. The threshold value for the image is just the minimum/maximum.

Acknowledgemets to Jeric Tugaff for the histogram code (posted in Ma'am Jing's blog) and Ma'am Jing for her suggestions.

I give myself a 9/10 for this activity.

Activity 2: Area Estimation for Images with Defined Edges

2009-06-24T07:19:00.000-07:00

For this activity, Green's theorem is used to estimate the area of a binary image with defined edges. The edges of the images were obtained using the "follow" command in Scilab. Area estimation of Green's theorem is
The theoretical value for the area was obtained by counting how many pixels with values of 1.

The code

1 Image=imread("C:\Documents and Settings\mimie\Desktop\hand.bmp"); //read image file
2 I = im2bw(Image,1); //convert image to binary
3
4 [x,y]=follow(I); //get the contour of the image
5 A=[];
6 lx=length(x);
7 ly=length(y);
8
9 //close the contour
10 x(lx + 1)=x(1);
11 y(ly + 1)=y(1);
12
13 for i=2:lx;
14 A(i) = (x(i)*y(i+1))-(x(i+1)*y(i)); //area of the ith triangle
15 end
16
17 Area = (0.5*sum(A)) //Green's Theorem
18 theo = sum(I)
19 err = abs((Area-theo)/theo);
20 %err = 100.*err //percent error

The above code is implemented on the images below:

with the following results

The error is mainly because of the "follow" command. Since this command is a contour follower, the effective area as estimated by the Green's theorem is lessen by the pixel counts containing the contour. For example a 100x100 square image should have an area of 10000. Using the code above, an area of 9806 is obtained which corresponds to about 99x99 square. This means that the calculation for area starts inside the contour and not at the contour itself. To compensate this, an extra 0.5 lx term is subtracted from the pixel count (line 18: theo = sum(I) - 0.5*lx). The relative error is lessened when this is done.

Raffy and Cherry helped me in this activity. Thank you also to Miguel for troubleshooting the SIP toolbox. For this activity, I give myself a 9/10.

Activity 1: DIGITAL SCANNING

2009-06-17T20:25:00.000-07:00

In this activity, ratio and proportion was used to find the numerical values of a digitally scanned plot above. The following steps were followed:

1. The plot was cropped using Paint.
2. Paint was used to find the pixel locations of the data points considered in the plot.
3. MS Excel was used to determine the numerical values in the scanned plot.

All pixel locations were adjusted such that the pixel location of the origin (121,452) becomes (0,0). Hence all pixel locations of the data points were adjusted using the formula

X = Xpixel - 121
Y = 452 - Ypixel

where Xpixel and Ypixel are the pixel locations of the data points.

The numerical values were determined using the formula

Xphys = (X*Xp)+5
Yphys = Y*Yp

where Xp = 5/107.1429 and Yp = 2/53.30769 are number of pixels per division in the X and Y axis, respectively.

Note that the +5 in Xphys value is due to the fact that the original plot started at (5,0) and not at (0,0).

The reconstructed plot superimposed with the original plot is shown below:

Notice also that the reconstructed plot has a minimum of -12 instead -10 in its axis. This is because the lowest point in the plot has a y value of less than -10 as can be seen from the original plot. The formula used to get the numerical values are applicable only if the plot considered has axes of equal intervals per division. It can also be used without the +5 offset if the plot considered has an origin at (0,0)

For this activity, I give myself a score of 8/10 since I didn't finish it during class hours. I would also like to acknowledge Janno and Raffy for teaching me how to superimpose the original and reconstructed plots using Open Office and Kaye for her suggestions on offsetting the pixel locations.

The original plot was taken from the book "Outlines of Biochemistry" by Gortner, R. published in 1938. **

**no title page was available from the book