here, here and here...

ACTIVITY 19 - Restoration of Blurred Image

2009-10-12T02:44:00.002-07:00

This activity is a demonstration on how to restore an image which is corrupted with a known degradation function such as motion blur and additive noise.

The image degradation and restoration process can be modeled by the diagram shown below.

A degradation function H along with an additive noise terms, n(x,y) operates on an input image f(x,y) producing a degraded image g(x,y). With the given g(x,y) and some knowledge about the degradation function H and additive noise terms n(x,y), we can obtain an estimate restoration f'(x,y) of the original image.

The degraded image is given in the spatial domain

Thus, it can be written in an equivalent frequency domain by getting the Fourier transforms of the corresponding terms.

So we need to have our original image to be transformed in the frequency domain. Now, we will start the degradation of an original image by having our degradation function that will cause the original image to blur. H(u,v) is the Fourier transform of the degradation function given by

where a and b is the total distance for which the image has been displaced in the x- and y- direction, correspondingly and T is the duration of the exposure from the opening and closing of the shutter in the imaging process. We will use a = b = 0.1 and T = 1 and investigate also on other values for these parameters.

The additive noise terms will also be transformed in frequency domain.

To restore these corrupted images, we will apply the Weiner filter expressed by

This expression is also commonly referred to as the minimum mean square error filter or the least square error filter. The terms on the expression are as follows:

This expression is very useful when the power spectrum of the noise and the original image are known. Things can be more simplified when we are dealing with spectral white noise (the power spectrum of the noise is constant). However, the power spectrum of the original image is not often known wherein another approach can be used with the expression

where K is a specified constant. This expression yields the frequency-domain estimate. The restored image must be in the spatial domain which will be obtain by taking the inverse Fourier transform of estimation.

The image utilized for this activity is shown below

**Taken from: http://www.background-wallpapers.com/games-wallpapers/final-fantasy/final-fantasy-vii.html

The following images show the degradation of the original image with the corresponding parameters used. The first set of images has T = 1 and a = b = 0.001, 0.01, and 0.1.

Their corresponding restored images are also obtained and shown below.

We observed that by having small values of a and b, we are putting less blur on the image. Thus, its corresponding Weiner filtered image yields better image.

By keeping a and b constant, T was varied. (T = 0.01, 0.1, 10, and 100 )

Their respective restored image was shown below.

As observed, lesser exposure time makes the noise more obvious with constant values of a and b. On the contrary, greater exposure time will make the blur more visible. The Weiner filter, which works on the blur applied on the original image restores the image with higher exposure time much better.

For cases with unknown power spectrum of the original image, the constant K was varied with a = b = 0.01 and T = 1 . (K = 0.001, 0.01, 0.1 and 1, respectively)

Using a constant value of K shows a significant deviation on the restoration of the degraded image. It shows that knowing the power spectrum of the ungraded image as well as the power spectrum of the added noise is crucial in filtering blurred images. However, in instances that the two parameters are unknown, choosing a good value of K will yield a more enhanced image.

I will grade myself 9/10 for this activity. I was able to understand the activity and obtain the needed output given a short working time. However, I know that there are still so much to learn from this activity. I acknowledged Gilbert for helping me finish this activity.

The code below was use in implementing the Weiner filter on the degraded images.

image = gray_imread('FF7.bmp');
noise = grand(size(image,1), size(image,2), 'nor', 0.02, 0.02);

a = 0.01;
b = 0.01;
T = 1;

H = [];
for i = 1:size(image,1)
for j = 1:size(image,2)
H(i, j) = (T/(%pi*(i*a + j*b)))*(sin(%pi*(i*a + j*b)))*exp(-%i*%pi*(i*a + j*b));
end
end
F = fft2(image);
N = fft2(noise);

G = H.*F + N;
noisyblurredimage = abs(ifft(G));

scf(1);
imshow(noisyblurredimage, []);
imwrite(normal(noisyblurredimage), 'filename.bmp');

// Weiner filtering

Sn = N.*conj(N);
Sf = F.*conj(F);
K = Sn./Sf;
W = H.*conj(H);

Fres = ((1)./H).*((W)./(W+K)).*G;
Fres = abs(ifft(Fres));
scf(2);
imshow(Fres, []);
imwrite(normal(Fres), 'filename.bmp');

ACTIVITY 18 - Noise Models and Basic Image Restoration

2009-10-12T02:44:00.001-07:00

This activity aims to be able to be familiar with different noise models by applying them on an image and then restore the degraded image by implementing various spatial filters.

Noise are random variables that are characterized by a probability density function or PDF. In this activity, different noise models were applied on an ungraded image.

First is the Gaussian noise which is also known as normal noise model. The PDF of a Gaussian random variable, z, is given by
where z represents gray level, myu is the average value of z and sigma is its standard deviation.

Next is the Erlang or Gamma noise which is given by
The mean and variance of this density are given by
, respectively.

The Exponential noise has the PDF given by
and has the mean and variance given by
Then we have the Uniform noise with PDF given by
and has mean and variance given by
The Impulse or Salt-and-Pepper noise has PDF given by
Finally, we have the Rayleigh noise which has the PDF given by
The mean and variance of the Rayleigh noise is given by
These noises were created using the built-in function grand in Scilab and then applied on an ungraded image.

The corrupted images were then restored using different filters. First is the Arithmetic mean filter. represent the set of coordinates in a rectangular subimage window of size m x n, which has center at point (x,y). The arithmetic mean filtering process computes the average value of the corrupted image g(x,y) in the are defined by S sub xy. The value of the restored image f at point (x,y) is simply the mean computed using the pixels int he region defined by S sub xy.

The Geometric mean filter will restore an image with the use of the equation below.
The Harmonic mean filtering operations is given by the expression
This filter works better for salt noise than the pepper noise.

The Contraharmonic mean filtering operations yields a restored image based on the expression
where Q is the order of the filter. This filter is suited in treating salt-and-pepper noise. Positive values of Q will eliminate pepper noise while negative values omits salt noise. Thus, it cannot remove both noise simultaneously.

I was able to finish this activity and obtained MANY images. All files were deleted after the CSRC reset our computers. Unfortunately, I didn't have backup of my files. I guess, 5/10 is enough for me since I don't have pictures to show that I have finished this activity. :-(
Anyway, I want to thank Gilbert for guiding me in this activity.

ACTIVITY 17 - Photometric Stereo

2009-09-09T19:03:00.002-07:00

In this activity, we estimated and then extracted the shape of an object from shadow with the use of different sources and shading models.

First, we utilized the images of of synthetic spherical surfaces that are illuminated by a far away point source.

It looks like there are no significant difference among the pictures above but the shading of the images tells much information about the surface of the object. It gives the intensity captured by the camera at point (x,y). These images are captured from the surface of the object with the sources located respectively at
This numbers were put into matrix form where each row is a source and each column is the x,y, and z component of the source.
Now we are given with I and V which is related by
We can solve for the surface normal vector by first getting g with the use of the equation
This is the reflectance of the of the object at the point normal to the surface. The surface normal vector is obtained from g divided by its magnitude
From the surface normals, we computed the elevation z = f(u,v) and the 3D plot of the shape of the object was displayed.

The surface normals (nx, ny, nz) obtained using photometric stereo are related to the partial derivative of f(x,y) as
Then, the surface elevation z at point (u,v) which is given by f(u,v) is evaluated by a line integral
Finally, the 3D plot of the shape of the object was displayed.
The shape of the object with spherical surfaces was successfully extracted and displayed.

The Scilab code used in this activity was shown below. I want to acknowledge the help of Gilbert in working on this activity.

loadmatfile('Photos.mat');

// intensity captured by camera at point (x,y)
I1 = matrix(I1, 1, size(I1, 1)*size(I1, 2));
I2 = matrix(I2, 1, size(I2, 1)*size(I2, 2));
I3 = matrix(I3, 1, size(I3, 1)*size(I3, 2));
I4 = matrix(I4, 1, size(I4, 1)*size(I4, 2));
I = [I1; I2; I3; I4];

// location of the point sources
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];
V = [V1; V2; V3; V4];

// calculation of surface normal vector
g = inv(V'*V)*V'*I;
magnitude = sqrt((g(1,:).^2) + (g(2,:).^2) + (g(3,:).^2))+.0001;
n = [];
for i = 1:3
n(i,:) = g(i,:)./magnitude;
end

// computation for the elevation z = f(x,y)
nx = n(1,:);
ny = n(2,:);
nz = n(3,:) + 0.0001;
dfx = -nx./nz;
dfy = -ny./nz;
z1 = matrix(dfx,128,128);
z2 = matrix(dfy,128,128);
Z1 = cumsum(z1,2); // integration from 0 to u
Z2 = cumsum(z2,1); // integration from 0 to v
z = Z1 + Z2;
scf(0);
plot3d(1:128, 1:128, z);

ACTIVITY 16 - Neural Networks

2009-09-09T19:03:00.001-07:00

This activity is again related from the two previous activities, Activity 14 and 15. The purpose of this activity is to classify objects from their corresponding class using neural networks. The features of of the samples from the two classes used in Activity 15 was also used in this activity. The Clorets mint candy was tagged with the value of 0 while the Pillows chocolate snack was tagged with the value of 1.

The code below was made to implement the Artificial Neural Network algorithm.

clorets_train = fscanfMat('clorets_train.txt');
pillows_train = fscanfMat('pillows_train.txt');
clorets_test = fscanfMat('clorets_test.txt');
pillows_test = fscanfMat('pillows_test.txt');

cp_train = [clorets_train; pillows_train];
cp_train(:,1) = cp_train(:,1)/max(cp_train(:,1));
cp_train = cp_train';
cp_test = [clorets_test; pillows_test];
cp_test(:,1) = cp_test(:,1)/max(cp_test(:,1));
cp_test = cp_test';

rand('seed', 0);

network = [4, 4, 1];
groupings = [0 0 0 0 0 1 1 1 1 1];
learning_rate = [1, 0];
training_cycle = 1000;

training_weight = ann_FF_init(network);
weight = ann_FF_Std_online(cp_train, groupings, network, training_weight, learning_rate, training_cycle);
class = ann_FF_run(cp_test, network, weight);

** the source code was from Cole Fabro's work

The training parameters, learning rate and training cycle were tuned. It was observe that for a given training cycle, the recognition is more accurate with large learning rate. On the other hand, with the learning rate being constant, the recognition is also more accurate.

I will give myself a grade of 10/10 for this activity. Although the code was already given, I fully understand the effect of tuning the training parameters on the accuracy of the recognition. I thank Gilbert for helping me on this activity.

ACTIVITY 15 - Probabilistic Classification

2009-09-09T19:01:00.003-07:00

This activity is related from the previous activity, Activity 14. Two classes from the pattern recognition activity was chose to be used in this activity. The Clorets and the Pillows classes will be the classified by applying the Linear Discriminant Analysis or LDA.

Like the Pattern Recognition, the purpose of LDA is to classify objects into groups according on a set of features that describe the object. Again, we need a training set with their features which will represent the predetermined groups.

The LDA process was comprehensively explained on http://people.revoledu.com/kardi/tutorial/LDA . The procedure can be explained also by the code made for this activity.

clorets_train = fscanfMat('clorets_train.txt');
clorets_test = fscanfMat('clorets_test.txt');
pillows_train = fscanfMat('pillows_train.txt');
pillows_test = fscanfMat('pillows_test.txt');

train = [clorets_train; pillows_train];
test = [clorets_test; pillows_test];

u1 = [mean(clorets_train(:,1)), mean(clorets_train(:,2)), mean(clorets_train(:,3)), mean(clorets_train(:,4))];
u2 = [mean(pillows_train(:,1)), mean(pillows_train(:,2)), mean(pillows_train(:,3)), mean(pillows_train(:,4))];

u = [mean(train(:,1)), mean(train(:,2)), mean(train(:,3)), mean(train(:,4))];

x01 = [clorets_train(1,:) - u; clorets_train(2,:) - u; clorets_train(3,:) - u; clorets_train(4,:) - u; clorets_train(5,:) - u];
x02 = [pillows_train(1,:) - u; pillows_train(2,:) - u; pillows_train(3,:) - u; pillows_train(4,:) - u; pillows_train(5,:) - u];

n1 = 5;
n2 = 5;

c1 = (x01'*x01)/n1;
c2 = (x02'*x02)/n2;

for r = 1:4
for s = 1:4
C(r, s) = (n1/(n1 + n2))*(c1(r, s) + c2(r, s));
end
end

invC = inv(C);

P1 = n1/(n1 + n2);
P2 = n2/(n1 + n2);
P = [P1; P2];

for k = 1:(n1 + n2)
f1(k) = u1*invC*test(k,:)' - (1/2)*u1*invC*u1' + log(P(1));
f2(k) = u2*invC*test(k,:)' - (1/2)*u2*invC*u2' + log(P(2));
end

f = [f1, f2];

The object with maximum f1 will be assigned to class of Clorets while the object with maximum f2 will be assigned to class Pillows.

The table below shows the corresponding feature vector of each sample from each class. The calculated mean feature for each class and the global mean vector was shown in the table.

The table below shows the results.

The values of the discriminant function obtained are very large. This is due to the large discrepancy between the pixel area and the normalized chromaticity values which were used as featured vector. However, it can be observed that the difference between the two discriminant function were so small.

I will grade myself 10/10 for completing this activity. I was able to implement the Linear Discriminant Analysis thus I was able to classify objects to their expected class. I want to acknowledged Gilbert for helping me finish this activity.

ACTIVITY 14 - Pattern Recognition

2009-09-09T19:01:00.001-07:00

This activity was done to be able to qualify different objects through their various characteristics such as shape, size and color by pattern recognition. A set of features of the objects will be used as pattern. We aim to identify from where class an unknown object belongs.

First, three sets of objects were assembled. Each set represent a class composing of 10 samples. This activity utilized Clorets mint candy, Pillows chocolate snack and Potchi gummy candy. The picture of the objects obtained was shown below.

Each of the three class was divided into two sets. The first five samples will be the training set while the remaining five will serve as the test set. The pixel area, the average normalized chromaticity values in red, green and blue will be used as features for pattern recognition. These features were obtained using the techniques that have been learned in previous activities. The pixel area was determined by thresholding, inverting and counting the number of pixels of the black and white image of the set objects. On the other hand, the chromaticity values were obtained by using the non-parametric segmentation technique. After obtaining each feature, they are arranged into matrix form producing the feature vector. The training feature vectors were separated from the test feature vectors. From the training feature vectors, the mean feature vector was determined from the expression
Here, N is the total number of samples in the class wj and xj is feature vector in the training set of the corresponding class. Basically, this is just the mean of the pixel area and the normalized chromaticity values for red, green and blue from 5 samples comprising the training set. Each sample from the test set will be compared to the mean feature vector, which is a 1 x 4 matrix. This will be done through minimum distance classification where the Euclidean distance is applicable given by
where x is the feature vector of the test set and j is the number of classes which in this case is 3.

The feature vector of every sample on each set and their corresponding mean feature vector is shown in the table below.
The resulting mean distance and the classification of the samples from the test set was shown in another table below.
As have been observed, the calculated mean distance, D is relatively larger when the test sample does not belong to the class. Relatively small mean distance tells that the test sample belongs to the class. However, there is a deviation between the Clorets and Potchi sample. Some Clorets test samples were classified as Potchi while some Potchi samples were classified as Clorets. We can say that the deviation was brought by the shape of both sample. Overall, the technique was useful in classifying objects of different characteristics.

I will give myself a grade of 10/10 in this activity. I was able to understand how to use the characteristics of objects as pattern in classifying them through pattern recognition. I had a hard time capturing pictures of the samples that can be threshold correctly in order to use the bwlabel function of Scilab in getting the pixel area. After obtaining the picture, acquiring the data was made easy with the help of Gilbert.

The code below was utilized in this activity.

image1 = 1-gray_imread('bwclorets1.bmp');

// Area computation for training set
[L, n] = bwlabel(image1);
area = [];
for i = 1:n
area(i) = sum(i==L);
end
mean_area = mean(area(1:5));

for i=1:10
image =imread('clorets'+string(i)+'.bmp');
patch = imread('patchclorets.bmp');

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

rp = patch(:,:,1);
gp = patch(:,:,2);
bp = patch(:,:,3);

R = r./(r+g+b);
G = g./(r+g+b);
B = b./(r+g+b);

Rp = rp./(rp+gp+bp);
Gp = gp./(rp+gp+bp);
Bp = bp./(rp+gp+bp);

Rmu = mean(Rp);
Gmu = mean(Gp);
Rsigma = stdev(Rp);
Gsigma = stdev(Gp);

// Non-parametric Segmentation
BINS = 256;
rint = round( Rp*(BINS-1) + 1);
gint = round (Gp*(BINS-1) + 1);
colors = gint(:) + (rint(:)-1)*BINS;
hist = zeros(BINS,BINS);
for row = 1:BINS
for col = 1:(BINS-row+1)
hist(row,col) = length( find(colors==( ((col + (row-1)*BINS)))));
end;
end;

rib = R*255;
gib = G*255;

[a, b] = size(image);
np = zeros(a, b);

for r = 1:a
for s = 1:b
c = round(rib(r, s)) + 1;
d = round(gib(r, s)) + 1;
np(r,s) = hist(c, d);
end
end

// Mean color per channel
imageR = [];
imageG = [];
imageB = [];

[x , y] = find(np ~= 0);
for j=1:length(y)
imageR = [imageR, R(x(j),y(j))];
imageG = [imageG, G(x(j),y(j))];
imageB = [imageB, B(x(j),y(j))];
end
mean_imageR(i,:) = mean(imageR);
mean_imageG(i,:) = mean(imageG);
mean_imageB(i,:) = mean(imageB);
end

mean_imageR_training = mean(mean_imageR(1:5));
mean_imageG_training = mean(mean_imageG(1:5));
mean_imageB_training = mean(mean_imageB(1:5));

M=[mean_area,mean_imageR_training,mean_imageG_training,mean_imageB_training];

// Area computation for test set
image2 = 1-gray_imread('bwclorets2.bmp');
[L, m] = bwlabel(image2);
area2 = [];
for i = 1:m
area2(i) = sum(i==L);
end

// Mean Distance
D = [];
X = [];
for i=6:10
X=[area(i-5),mean_imageR(i),mean_imageG(i),mean_imageB(i)];

d = X-M;
D = [D, sqrt(d*d')];

end

ACTIVITY 4 - Enhancement by Histogram Manipulation

2009-08-07T03:40:00.000-07:00

In this activity, grayscale images will be enhanced by manipulating their histogram which is the graylevel probabilit function or PDF when normalized. Histogram can be modified by having the cumulative distribution function (CDF) of the image and a desired CDF. The image was modified by backprojecting the grayscale values of the desired CDF.

A grayscale image with poor contrast was downloaded from the internet. Then the grayscale histogram of the image was obtained using Scilab.

grays = gray_ imread('gray_image.jpg'); //read from grayscale file

//compute and plot the histogram
j=1;
pix = [];
for i = 0:255
[x,y]=find(grays==i);
pix(j)=length(x);
j=j+1;
end

The grayscale image was show above along with its grayscale histogram. We then determine the CDF of the image from its PDF. The CDF is given by
where p1(r) is the PDF of the image. The CDF of the grayscale image above was shown at the left side below.

We are going to remap the grayscales of the image in a way that the resulting CDF of the reconstructed image will look like our desired CDF. The CDF of a uniform distribution is a straight increasing line. If we wanted our image to have a uniform distribution of gray values, we will use a straight line, shown above right as our desired CDF.

The process of backprojection was illustrated below.

Each pixel value has a CDF value. This value was traced in the desired CDF. The pixel value will then be replaced by the new pixel value in the desired CDF.

b = pix;
c = cumsum(b);
f = c/max(c);
x = 0:255;

imsize = size(grays);
dCDF = x;

for i = 1:imsize(1)
for j = 1:imsize(2)
ind= find(x == grays(i, j));
grays(i, j) = f(index);

The resulting image was shown below.
The transformed image shows a significant increase in contrast. This image is now called a histogram equalized image.To have more idea about the image, we displayed its grayscale histogram and its CDF.

Compared with the original histogram, the histogram of the transformed image showed a more uniform distribution of grayvalues. As with our goal, the CDF of transformed image looked like just the same as the desired CDF.
----------------------------------------------------------------------------------------------------------------
We have manipulated the histogram of a grayscale image with the use of a linear desired CDF. However, the human eye has a nonlinear reponse. So we can mimic the human eye response by using a nonlinear CDF. We can use a tanh function as our desired CDF which is nonlinear. Its plot was shown below.

x = 0:255;
tanhf = tanh(16.*(x-128)./255);
tanhf = (tanhf - min(tanh))./2;

Again, the backprojection was done. The CDF value of the pixel value was traced along the CDF value of the desired CDF. The pixel value in the desired CDF will be the new pixel value.

b = pix;
c = cumsum(b);
f = c/max(c);
x = 0:255;

imsize = size(grays);

for i = 1:imsize(1)
for j = 1:imsize(2)
ind = find(x == grays(i, j));
pixel1 = f(index);
pixel2 = find(tanhf<= pixel1); grays(i, j) = (pixel2(max(pixel2)));

The transformed image using a non-linear CDF was shown below.
Clearly, the transformed image is not as good as the image transformed using linear CDF. The image becomes darker with very poor contrast. We display its grayscale histogram and its CDF.

We can see from the grayscale histogram the distribution of gray values at a certain region at the center. The CDF shows that we were able to transformed the grayscale image base from the desired CDF. However, we were not able to enhance the contrast of the gray image.

I give myself a grade of 9 for this activity. I was able to easily understand the backprojection of pixels however, I had a hard time implementing it in a code. Also, I was able to show the effect of having a linear and non-linear CDF desirable for transforming a grayscale image. In this activity, I learned how to qualify an image with just looking on its grayscale histogram. The more uniform the distribution of the grayscale values, the better the contrast of the grayscale image. I acknowledged the help of Gilbert, who tirelessly helped me debug my code and waited for me until I gathered all my results.

ACTIVITY 12 - Color Image Segmentation

2009-08-06T02:19:00.007-07:00

In this activity, we are going to pick out a region of interest from the rest of the image through image segmentation.

A digital image of 3D objects, shown below, was utilized in this activity. Different brightly colored candies are shown in the image.

We cropped a monochromatic region of interest in the scene. In this case, we wanted the blue candies to be our region of interest.

We notice that these objects found in the image, as well as the cropped image have shading variations which is inherent in 3D objects. To separate brightness and chromaticity (pure color) information, it is better to represent the color space by the normalized chromaticity coordinates or NCC. The normalized chromaticity coordinates can be obtained by dividing each pixel from each channel by the summation of the pixel corresponding on each channel.

This was implemented by the code below.

image =imread('candy.jpg');

patch = imread('patch.jpg');

r = image(:,:,1);

g = image(:,:,2);

b = image(:,:,3);

rp = patch(:,:,1);

gp = patch(:,:,2);

bp = patch(:,:,3);

R = r./(r+g+b);

G = g./(r+g+b);

B = b./(r+g+b);

Rp = rp./(rp+gp+bp);

Gp = gp./(rp+gp+bp);

Bp = bp./(rp+gp+bp);

Parametric Segmentation

The Gaussian PDF in the r values was derived using the equation

where sigma is the standard deviation and mu is the average of the normalized chromaticity coordinate in red of the patch image. The same equation was used for g values.

Rmu = mean(Rp);

Gmu = mean(Gp);

Rsigma = stdev(Rp);

Gsigma = stdev(Gp);

pr = (1/(Rsigma*sqrt(2*%pi)))*exp(-((r-Rmu).^2)/(2*(Rsigma)^2));

pg = (1/(Gsigma*sqrt(2*%pi)))*exp(-((g-Gmu).^2)/(2*(Gsigma)^2));

Then, the joint probability was taken as the product of rho(r) and rho(g).

product = round(pr.*pg);

The resulting image was shown below.

Non-Parametric Segmentation

The 2D histogram of the ROI was obtained using the give code below.

BINS = 256;

rint = round( Rp*(BINS-1) + 1);

gint = round (Gp*(BINS-1) + 1);

colors = gint(:) + (rint(:)-1)*BINS;

hist = zeros(BINS,BINS);

for row = 1:BINS

for col = 1:(BINS-row+1)

hist(row,col) = length( find(colors==( ((col + (row-1)*BINS)))));

end;

scf(1);

mesh(hist);

To test the correctness of the histogram, we compare the location of the peaks with the rg chromaticity diagram (at the right). Clearly, we can see that the histogram of the ROI peaks at the are corresponds to the blue color in the rg chromaticity diagram. This histogram willl be important in segmenting the image using histogram bakcprojection.

This histogram backprojection is similar to what has done in Activity 4 excepth that in this case, the histogram is in 2D. Backprojection was done by replacing the value of the pixel location by its histogram value in chromaticity space. This was implemented by the code below.

rib = R*255;

gib = G*255;

[a, b] = size(image);

np = zeros(a, b);

for i = 1:a

for j = 1:b

c = round(rib(i, j)) + 1;

d = round(gib(i, j)) + 1;

np(i, j) = hist(c, d);

end

scf(2);

imshow(np);

The resulting image was shown below.

By implementing two different segmentation techniques, different parts of the region of interest was segmented. Parametric segmentation enables us to segment the outer part of the blue candies while non-parametric segmentation enables us to segment the inner body of the blue candies. The non-parametric segmentation favors in segmenting the region of interest although not all ROI were segmented.

I give myself a grade of 10 for finishing this activity. I was able to implement the parametric and non-parametric segmentation on an image composed of an ensemble of colored objects.

I would not have finished my blogs without the overwhelming help of Gilbert and Rommel. Gilbert was the one who patiently discussed every activity with me. He help me a lot in understanding previous activities. Rommel, after finishing his blog was able to lend me his laptop. It was a big help considering that I did not work on my blog in a computer shop for almost 4 hours.

:-) I acknowledged all my classmates who made me feel their concerns for me. I want to extend my deepest gratitude for all of you guys.

ACTIVITY 11 - Color Image Processing

2009-08-06T02:19:00.005-07:00

Primarily, the objective of this activity is to be able to enhanced an image that is wrongly white-balanced. Images of an ensemble of colorful objects were captured using a digital camera with different white balance settings.

White Balancing Setting: Fire

White Balancing Setting: Shade

White Balancing Setting: Fluorescent-1

White Balancing Setting: Fluorescent-2

White Balancing Setting: Fluorescent-3

White Balancing Setting: Incandescent

Different white balancing settings resulted to different qualities of images. The Fire and Shade are almost the same resulting to a slightly darker image than what was taken. Fluorescent-1 settings resulted to a brownish image. Fluorescent-2 and Fluorescent-3 produced shades of blue images. The Incandescent setting produced a more bluish image. Obviously, this image is wrongly balanced.

White Patch Algorithm

Using the image captured by the camera in Incandescent setting, the White Patch algorithm was implemented. First, a patch of an white object in real world which appears differently in the image was cropped.
The RGB values of pixels belonging to this white object: Rw, Gw, and Bw was taken. And then, all pixels in the red layer, green layer and blue layer of the image was divided by their corresponding Rw, Gw and Bw. This was implemented with the code below.

image = imread('filename.jpg');
w = imread('wpatch.jpg');

rw = sum(w(:,:,1))/length(w(:,:,1));
gw = sum(w(:,:,2))/length(w(:,:,2));
bw = sum(w(:,:,3))/length(w(:,:,3));

nr = image(:,:,1)/rw;
ng = image(:,:,2)/gw;
nb = image(:,:,3)/bw;

The resulting image was then displayed as shown below.

Compared with the wrongly white balanced image, the resulting image is less brighter as the bluish color decreases. White hues that appear bluish in the wrongly balanced image now appear more white. The White Patch algorithm assumes that the maximum response of the image is caused by the white patch. Thus, by dividing each channels of the image with the constants determined from the white patch we are essentially bringing back true colors of the image.

Gray World Algorithm

The Gray World algorithm was also implemented on the image captured using Incandescent setting. For this algorithm, the R, G and B layers of the unbalanced image were averaged and let to be Rw, Gw, and Bw, respectively. Then the original R, G and B layer values were divided by their corresponding constant.

image = imread('filename.jpg');

rw = sum(image(:,:,1))/length(image(:,:,1));
gw = sum(image(:,:,2))/length(image(:,:,2));
bw = sum(image(:,:,3))/length(image(:,:,3));

nr = image(:,:,1)/rw;
ng = image(:,:,2)/gw;
nb = image(:,:,3)/bw;

The resulting image was displayed below.
The image looks old after the implementation of Gray World algorithm. The blue hues also lessen and the white hues look grayish. The Gray World algorithm assumes that the average of the colors on each channels of the image taken in normal light is gray. Using the Incandescent setting in capturing the image, we have disrupted the Gray World assumptions. We force the Gray World assumption again by dividing each channel by their average. Thus, we are reaquiring the true color of the image in real world.

Doing both algorithm with the other images will result to the same image as shown above for white patch and gray world algorithm. Implementing both algorithms is reacquiring the true colors of the image based on certain assumptions. However, it turns out that the White Patch is better than the Gray World algorithm.
------------------------------------------------------------------------------------------------------------

In this part of the activity, the white patch and gray world algorithm were implemented on an image of objects with the same hue (in this case, green).
The image above was obviously wrongly white balanced. After implementing the two algorithm as in above procedure, the resulting images were shown below.

White Patch Algorithm

Gray World Algorithm

The white patch algorithm uses the white wall at the background of the image. Clearly, the original color was reacquired using white patch algorithm. Gray world algorithm allows the removal of the bluish hue in the image. However, the image becomes slightly reddish. This is because the unbalanced image mainly composed of green hues.

For this activity, I will get 10/10. By producing images from each algorithm, I was able to understand how the white patch and gray world algorithm assumes the color of the real world. Applying these algorithm on an image captured with colored lighting (i.e. Incandescent white balancing setting ) will reacquire the true colors of the image. However, after finishing the activity, it turns out that for the images used, the White Patch algorithm assumes a better color of the real world. I acknowledged Gilbert for discussing the activity with my and for lending me pictures he captured.

ACTIVITY 10 - Processing Text

2009-08-06T02:19:00.003-07:00

This activity aims to extract handwritten text from an imaged document with lines. In order for the handwriting to be recognized, individual letters must be extracted. We will again use all the image processing techniques we have learned.

The image below will be utilized for this activity.

A portion of the image was cropped with handwritten text together with lines in the form.

We can see from the horizontal lines that the image is tilted. With the use of mogrify function which is built-in function is Scilab, the image was rotated. The image below shows the rotated image.

Now that we have rotated the image, we will have to remove the horizontal lines from the form using image processing techniques. First we have to display the FT of the image in logarithmic form. In doing this we will have the idea where the frequencies of the horizontal lines lie, just like in the previous activities. We will design the filtering mask by blocking the frequencies the correspond to the unwanted horizontal pattern.

The image at the left is the FT of the image in logarithmic form and the image at the right shows the filtering image. We can see on the filter how we are able to block the frequencies of the horizontal line. The resulting image is shown below.
This image resulted from the filtering technique applied to the cropped portion of the original image. After the removal of the horizontal lines, the image was then inverted. We notice that the background becomes black and the texts become white. This was done in able for us to use the morphological operations we have learned. We recall that these operations applies only to the "white" portion of the image which is our object.

But before implementing morphological operation, we have to binarize the image first. We look for the best threshold such that the object is well separated with the background. And then, the dilate and erode functions were used. The combination of the two operations were done until the best extraction of the texts was produced.
The image above shows the final extraction of the text image. From this image, we can see the significant separation of each text in the word "remote control". The rest of the words, although the letters are being separated from each other somehow, are still unrecognizable. From the beginning, we have a very poor image. We can compare the separation of the letters by counting the number of blobs produced using the bwlabel function. Supposedly, there are 46 letters in the cropped portion of the image. The number of blobs produced after doing image processing techniques was found to be 31. Thus, the image processing techniques applied to the image has a significant effects on the separation of each text.
-------------------------------------------------------------------------------------------------
In this part, we will use the template matching technique we have learned in Activity 6.C to find the instances of the word "DESCRIPTION" in the whole image.

First, we binarize the whole image and find the best threshold. Then we cropped the word DESCRIPTION from the image and pasted it on a black background with the same size as the image which will be our template.

And then the correlation technique was applied. The FT of the template was multiplied with the conjugate of the FT of the image. Then the fftshift of the product was taken.
The image above shows three instances of the word DESCRIPTION in the image which is what we have expected. We can see these instances from the bright spots where the correlation is high.

I want to give myself a grade of 9 in this activity. Although I have used the image processing techniques I have learned, I was not able to come up with a more enhanced text image. Again, Gilbert was acknowledged for this activity.

ACTIVITY 9 - Binary Operations

2009-08-06T02:19:00.001-07:00

This activity is an integration of everything we have learned to determine the best estimate area in pixel count of simulated "cells". In addition, we are going to use more morphological operators such as the closing and opening operator for enhancing and analyzing binarized images.

The image above which is an image of scattered punched paper digitized using a flatbed scanner was utilized in this activity. We imagine that the circles are imaged cells on a slide. Our primary goal: estimate the area of ONE "cell".

We begin the task by dividing the whole image into 256 x 256 subimages. Each subimage was opened in grayscale. A sample subimage was shown below.
The threshold of the subimage was obtained from its histogram. The threshold is important in order to separate the background from the cell, which is our region of interest (ROI). Then the subimage was binarize using the Scilab function im2bw.
In order to emphasize the separation of ROI from the background, we implemented opening and closing operator using the dilate and erode functions which are built-in functions in Scilab.

//opening
image1 = erode(dilate(image));
Opening operator removes small objects inside the cell.

//closing
image2 = dilate(erode(image1));
While closing operator removes small holes on the background.

After doing morphological operations, we have now a cleaner image of the cells. Then, contiguous blobs are formed within each subimage. The bwlabel function was used to label each blob on the subimage. The area or the number of pixels of each blob was measured from each subimage and then tallied.

//area computation
[L, n] = bwlabel(image2);
area = [];
for i = 1:n
area(i) = sum(i==L);
end
From the histogram of the areas, the average of the area was taken from the range of areas with high occurrences. The calculated mean area was found to be 526 pixels with a standard deviation of 24.67. In order to verify this calculation, a single "cell" was taken from the whole image, binarized and then summed in order to get the area in pixel.
The area of a single cell was measured to be 535 pixels. In comparison to the calculated area, a 1.76% error was obtained.

I will give myself a grade of 10/10 for finishing this activity. Aside from obtaining a small percentage error, I understand most part of the activity. I was able to apply image processing and area calculation techniques I have learned in previous activity. I think that using bwlabel function in calculating the area of each blob in a subimage was a clever idea. As always, I want to acknowledged Gilbert in helping me understand the activity.

ACTIVITY 8 - Morphological Operations

2009-08-06T02:18:00.003-07:00

The goal of this activity is to verify the effect of morphological operations, dilate and erode in different shapes using varying structuring element.

Binary image of square (50 x 50), a triangle (base = 50, height = 30), a circle (r = 25), a hollow square (60 x 60, edges are 4 pixels thick) and a plus sign (8 pixels thick and 50 pixels long for each line) were created in MS Paint.

To be able to used the dilate and erode, structuring elements are needed. The following structuring elements were utilized for each images created.

1. 4 x 4 ones

2. 2 x 4 ones

3. 4 x 2 ones

4. cross, 5 pixels long and one pixel thick

The morphological operations were implemented with the use of the built-in function dilate and erode in Scilab.

A = dilate(image, a);

The dilation of A by B is denoted by

Thus, dilation will result to the expansion or elongation of the image according to the shape of the structuring element.

A1 = erode(image, a);

The erosion of A by B is denoted by

Using erosion will reduce the image according to the shape of the structuring element.

But before running the code, a prediction on what will be the resulting image was done. The following images show the resulting image after the implementation of morphological operations. The resulting images are shown according to the structuring element used (4x4, 2x4, 4x2, cross).

Square (50 x 50)

Dilated

Eroded

Triangle (base = 50, height = 30)

Dilated

Eroded

Circle (r = 25)

Dilated

Eroded

Hollow Square (60 x60, edges are 4 pixels thick)

Dilated

Eroded

Plus Sign (8 pixels thick and 50 pixels long for each line)

Dilated

Eroded

From the images, dilation indeed expands the image while erosion reduces the image depending on the structuring element.

-------------------------------------------------------------------------------------------------

Other morphological operations, thin and skel were explored using Scilab. The following images resulted after the implementation of these operations on the shapes created in the previous part.

A = thin(image1);

A1 = skel(image1);

Thin

Skel

Applying thin function resulted to thinning of the shapes while skel resulted to random patterns along the shape.

I give myself an 8 for this activity. It was Gilbert who taught me how the dilate and erode functions work. I had a hard time predicting on the outcomes of each morphological operation although I made the code with an ease. As I noticed, dilation expanded the image while erosion reduced the image depending on the structuring element being used. The thin and skel are just other morphological operations that can be used for further image processing techniques.

ACTIVITY 7 - Enhancement in the Frequency Domain

2009-08-06T02:18:00.001-07:00

The goals of this activity is to be able to remove unwanted repetitive patterns by creating filter masks to block frequencies of the unwanted patterns in the Fourier domain. In doing so, the desired frequencies of the image may be enhanced thus, enhancing the quality of the image at the same time.

Activity 7.A Convolution Theorem

An binary image of an aperture consisting of two dots (one pixel each) was created using MS Paint. Its FT was taken and then displayed.

The FT modulus resulted a sine function along an axis which is symmetric about the center, which is expected. As we know, the FT of a sine function will result to two dirac deltas which will peak at the frequency of the sine function. Conversely, if we take the FT of two dirac deltas represented by two one-pixel point symmetric at the center, a sine function will be obtained with frequency related to the separation of the points.

Next, the dots were replaced with circles of some varying radius.

When the two dots were replaced with two circles with certain radius, the FT resulted into an airy disk pattern with embedded alternating parallel lines. This was due to the convolution of the circular aperture with the dirac deltas. The convolution theorem states that the FT of a convolution of two functions in space is the product of the two functions' FT. When the circular aperture and the two points were convolved, its FT came from the product of each function's FT, which is an airy disk pattern and a sine function, correspondingly. We can also observe that as the radius of the circles increases, the resulting radius of the airy disk pattern decreases.

After with circles, squares of some varying width were utilized.

Again, this is a convolution of two function, the square aperture and the two dirac deltas with FT resulting from the product of FT of each function. The FT of a square aperture is a sync function and the FT of the two dots is a sine function. The FT modulus came from the product of the two FTs. As with the varying radius of the circles, the as the width of the square increases, the width of the FT images decreases.
-------------------------------------------------------------------------------------------------
Lastly, the dots were replaced with Gaussians with the form Gaussians with varying variance (sigma squared) were created. The peak location of these Gaussians are located at ±mu.

The figures above shows the Gaussians with increasing variance (sigma squared) alongside with its FT modulus. For a better view, the images below showed it in 3D.

We can say that this is a convolution of the Gaussian function and the two dots (dirac deltas). Taking its FT will again result to the product of the FT of each function. The Fourier Transform of a Gaussian function is also a Gaussian function and the FT of the dirac deltas is a sine function. Therefore, the resulting FT modulus is a Gaussian function with alternating parallel lines. As the variance of each Gaussians was increased, the radius of the Gaussian in the frequency domain decreases.
-------------------------------------------------------------------------------------------------

Activity 7.B Fingerprints : Ridge Enhancement

In this part of the activity, we tried to enhance an image of a fingerprint which was downloaded from the internet. The enhancement includes emphasizing the ridges of the fingerprint and removing its blotches.
The image was then opened in Scilab as grayscale image. Its FT was obtained by the procedure done in the previous activities. Then the FT was displayed in logarithmic scale in order for us to visualize where the frequencies of the fingerprint ridges lie. This will give us the idea on how to design the filter mask that will enhance the appearance of the ridges and at the same time remove the blotches.

I designed the filter mask below. The white blobs corresponds to the frequencies that will be enhanced relatively with the black areas which are frequencies that will be lowered/omitted.
The filtering was done by taking the FT of the fingerprint image and multiplying it to the filter mask image which was shifted using fftshift function. The product was then inversed and resulted to the enhanced image below.
From the enhanced image, we can see that the diagonal line is not as visible as with the original fingerprint. Although the ridges are not as sharp as with the original, we can notice that the blotches are removed.
-------------------------------------------------------------------------------------------------

Activity 7.C Lunar Landing Scanned Pictures : Line removal

This part of the activity focuses on the removal of the frequencies that produces vertical lines in the image. An image of the moon's surface from a lunar landing was utilized in this part. Parallel vertical lines are visible through out the image.
To remove these lines, we must know where the frequencies of the lines lie. We get the FT of the image and displayed it in logarithmic form. From this image, we have the idea that the frequencies correspond to the parallel lines lie in the bright region that forms the vertical line. As we know, the FT of two dots along horizontal is a sinusoidal function which corresponds to the parallel vertical lines. So in order to remove these lines, we block the bright horizontal line and have our filtering mask. We might as well block the bright vertical line so that some horizontal lines in the image may be removed. We must be careful not to block the center of the filter because there are so much information there that we needed. The image below was used as the filtering mask of the image.

As before, the enhanced image was obtained from inversed of the product of the FT of the image and the fftshift of the filter mask.

From the enhanced image above, the removal of the parallel lines is visible. The quality of the image was enhanced as well.
-------------------------------------------------------------------------------------------------

Activity 7.D Canvas Weave Modeling and Removal

The last part of the activity utilizes a canvas painting. We will use what we have learned in image enhancement to remove the canvas weave visible in the painting.
We begin our filtering by first getting the FT of the painting in logarithmic form. This shows where the frequencies of the unwanted pattern can be found. From the image below, we notice the presence of some bright spots along the center. Compared from the previous part, the location of the frequencies that correspond to the combination of parallel vertical and horizontal lines is distinct. In order to remove these frequencies, we design the filtering image by blocking these bright spots. The image below shows the filtering mask used.
The enhanced image was then obtained by from the inversed of the product of the FT of the image and fftshift of the filter mask.
Clearly from the image above, we can see the image was enhanced by the removal of the canvas weave pattern.

To show that what we have blocked using the filter mask is really the weave pattern, we tried to generate the pattern from the filter. First the filter was inverted and the inverse FT was taken. The FT modulus is closely similar to the canvas weave as shown below.

I grade myself a 10 out of 10 in finishing this activity. This activity shows me how the convolution of two functions affect their FT modulus. The FT of two convolved function will result to the superposition of the FT of each function. I was able to use this idea in removing unwanted patterns and enhancing an image. I acknowledged Gilbert who was always there discussing and working with me during class hours.

ACTIVITY 6 - Properties of the 2D Fourier Transform

2009-07-13T07:19:00.000-07:00

Activity 6.A Familiarization with FT of Different 2D Patterns

This activity is similar to the previous one. We created different patterns, took their respective Fourier Transform and then display their FT modulus. This patterns were done with the aid of MS Paint and Scilab made it possible to compute their Fourier Transform.

The first pattern is a square aperture and beside it is its FT. The FT of a square aperture is similar to the FT of a circle (from Activity 5.A) but instead of an "airy disk" pattern, it has a central square maximum and maxima and minima intensities along its four sides. This pattern is know as the sinc function.

The next pattern is an annular aperture. Again, this is similar to the pattern obtained from a circular aperture except that at some fringes are not present due to the circular blocking at the center.
Then, a square annular aperture. This was analogous to the circular and annular aperture. The pattern obtained was almost the same with the square aperture and as expected, there are fringes missing. This is similar to a diffraction from a slit only that it is along x and y.

Next is a two-slit pattern. Along its side is its FT which yields from the cancellation of the upper and lower sections from the aperture. Thus, we see a horizontal pattern which is due to the interference coming from two slits.

The last pattern is a two-dot pattern or a double circular aperture. As has been said, the result looks like that of a circular aperture with maxima and minima intensities.

Activity 6.B Anamorphic Property of the Fourier Transform

Using Scilab, a 2D sinusoid in the x direction was created, with frequency that can be varied.

nx = 100; ny = 100;
x = linspace(-1,1,nx);
y = linspace(-1,1,ny);
[X,Y] = ndgrid(x,y);

f = 4 //frequency
z = sin(2*%pi*f*X);
imshow(z,[]);

And then, just like in previous part its Fourier Transform was taken and its FT modulus was displayed.

The figure above shows the source signal and its FT in 2D and 3D, respectively. The first figure shows a sinusoidal signal with frequency equals to 5 and below it is a signal with frequency 10. They corresponding FT shows that the peaks moves farther apart as the frequency increases. This is expected because the FT of a sinusoidal signal will have its peak on its frequency. Thus if you increase it, the peaks will farther along its axis.

-------------------------------------------------------------------------------------------------

Then, a real image was simulated by adding a constant bias to the sinusoid created earlier. Its FT was also taken.

z = sin(2*%pi*20*X)+0.95
The figure above shows the sinusoidal signal with constant bias and its FT in 2D and 3D. On the contrary with the previous result, the FT of a sinusoidal signal with constant bias has 3 peaks. The two peaks with equal amplitude are from the frequency of the sinusoid and the peak at the center comes from the constant bias. We recall that the FT of a constant is a dirac delta. Also note that the sinusoid signal used has a frequency 20.
--------------------------------------------------------------------------------------------------

If we suppose to have an image of an interferogram in a Young's Double Slit experiment, we can use this routine to extract its actual frequencies. We just have to find where the FT peaked. If a non-constant bias was added like those very low frequency sinusoids, we just neglect the peaks at low frequencies.

--------------------------------------------------------------------------------------------------

The sinusoid was then rotated.

theta = 30;
z = sin(2*%pi*f*(Y*sin(theta) + X*cos(theta)));

As expected, the peaks of its FT are also rotated.

-------------------------------------------------------------------------------------------------

Then a combination of sinusoids along x and y are investigated.

z = sin(2*%pi*4*X).*sin(2*%pi*4*Y);

Again, we expect this results, a four-peak plot. The first two peaks are due to the sinusoid along x and the last two are due to the sinusoid along y.

-------------------------------------------------------------------------------------------------

Aside from a combination of sinusoids, we added rotated sinusoid to the signal.

z = sin(2*%pi*f*X).*cos(2*%pi*f*Y)+sin(2*%pi*f*(Y*sin(30) + X*cos(30)));

Before calculating and displaying its FT, I had a prediction that the rotated FT of the additional signal will add up to the four-peak FR of the two-sinusoid combination.

As I predicted, six peaks appear on the FT.

-------------------------------------------------------------------------------------------------

I will give myself a grade of 8/10 for finishing the blog late. Although I was able to finish the activity during class hours, I'm having hard time doing blog because I have no access to the internet at home. Thanks again to Raffy and Gilbert for always answering my questions and for always having a good discussions.

ACTIVITY 5 - Fourier Transform Model of Image Formation

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

Activity 5.A - Familiarization with Discrete FFT

The function fft2() was demonstrated by utilizing a 128x128 images. This FFT was used for an image of a 'circle' which was created with the given code:

x = [-1:0.01:1];
[X,Y] = meshgrid(x);
r = sqrt(X.^2 + Y.^2);
circle = zeros(size(X,1), size(X,2));
circle(find (r <=0.5)) = 1.0; imshow(circle,[]);

Because of being complex, the abs() function was used for the output of the FFT to be able to view the intensity values. The first image shows the output of fft2() which has interchanged quadrants along the diagonal.

image = imread('imagefilename');
gray = im2gray(image);
FT = fft2(gray);
a = abs(FT);

To compensate, the function fftshift() was used to bring the interchanged quadrants back which is show in the second figure. With a closer look, this image is consistent to the analytical fourier transform of a circle which is an airy disk pattern.

b = fftshift(abs(FT));

Then, fft2() was again applied and the intensity of the image was displayed.

c = abs(fft2(FT)
This procedure was also done for an image of letter 'A'.

The inversion of the image after FFT being applied was clearly seen from this sample than the image of a circle. Thus, applying FFT twice will make the image inverted.

Activity 6.B - Simulation of an Imaging Device

A 128X128 image of the letters "VIP" which represents an object and an image of a white circle against black background which represents the "aperture" of a circular lens were created using MS Paint. The images were opened as grayscale in Scilab, taking the 2D FFT of the "VIP" image using fft2() function and using fftshift() function for the aperture image (the aperture is already in Fourier space).

object = gray_imread('vip.jpg');
aperture = gray_imread('circle.jpg');
offt = fft2(object);
afftshift = fftshift(aperture);

The product their FFT was inversed to get the convolved image.

FOA = offt.*(afftshift);
IOA = fft2(FOA);
The images above show the results for different radii of white circles. From left to right, the radius of white circle decreases. Thus, for the largest circle resulted for the sharpest image and for the smallest circle resulted for the blurriest image. This shows that the system acts just like a microscope.

Activity 6.C Template Matching Using Correlation

A 128X128 image with the text "THE RAIN IN SPAIN STAYS MAINLY IN THE PLAIN" on it was created in MS Paint. Then another 128X128 image with letter "A" at the center was also created with the same type of font as the first image. These images were opened as grayscale in Scilab and then got their 2D FFT.

text = gray_imread('text.bmp');
A = gray_imread('atext.bmp');
TFFT = fft2(text);
TA = fft2(A);

Then the Fourier transform of the image with letter "A" was multiplied element per element to the conjugate of the Fourier transform of the text image. Lastly, the inverse FFT of the product was computed.

P = TA.*(conj(TFFT));
R = fftshift((fft2(P)));

The picture above shows the output image besides the original image. It noticeable that the output image shows hazy counterpart of each letter on the original image. There is a significant peaks (white dots) on the letter "A" counterpart. This template matching technique recognizes the pattern (letter "A") from the template (text image). However, this can be problematic when the pattern looks like any part of each letter on the text. Take for example, when we use letter "I" as our pattern the output image will shows peaks on parts of each letters with straight vertical line just like the pattern.

Activity 6.D Edge Detection Using the Convolution Integral

Using Scilab, a 3X3 matrix pattern of an edge which has a total sum of zero was created. Three variants of this pattern were created.

horizontal:
template = [-1 -1 -1; 2 2 2; -1 -1 -1];

vertical:
template = [-1 2 -1; -1 2 -1; -1 2 -1];

spot:
template = [-1 -1 -1; -1 8 -1; -1 -1 -1];

This pattern was convolve with a "VIP" image using the function imcorrcoef().

C = imcorrcoef(vip, template);

The image above shows the results. We can see there are sharp edges on the output image depending on the pattern used. The pattern was detected along the edge of the template.

It felt good that I finished this activity during class hours. However, I was not able to finish the blog right away because of lack of time. I will give myself 10/10 for this activity because I was able to produce expected output although I have published the blog late. Thanks again for the help of Gilbert and Raffy in discussing the activity.

ACTIVITY 2 - Area Estimation of Images with Defined Edges

2009-06-28T00:48:00.000-07:00

In this activity, our goal is to be able to compute for the area of images with the use of Green's Theorem. First, we created images (with black background and white as the object) using MS Paint.

Then, the areas of the object on each image were calculated using Green's equation given by
I create a code using scilab that computes for the area of the object in a black and white image. This code utilizes Green's equation. The computed area was then compared to the area obtained by summing up all 1's in the image (white object).

SOURCE CODE:

image = imread('tri 4900.JPG');//read image from file
bin = im2bw(image, 0.5);//convert image to black and white
[x,y] = follow(bin);//follow the contour of the object
plot2d(x,y);//plot of the contour

//Green's Theorem
area=[];
for i = 1:(length(y)-1)
area(i) = x(i)*y(i+1)-y(i)*x(i+1);
end
areatot =((sum(area))/2)

//pixel area
pixarea = sum(bin)-length(y)

//percentage error
%err = abs((areatot-pixarea)/pixarea)*100

By using the syntax 'follow', Greens's equation disregards the contour in computing for the area. In order to compensate the pixel area, we have to subtract the perimeter of the contour in the sum of the pixel area. The table below shows the computed areas and corresponding percent error. I give myself a 10/10 in this activity. I understand well the objective of the activity and thus being able to create a code. I acknowledged Raffy and Gilbert for agreeing with me about the fact that 'follow' disregard the number of pixels of the contour using Green's equation.

ACTIVITY 3 - Images Types and Basic Image Enhancement

2009-06-27T22:20:00.000-07:00

In this activity, we collected digitized images from the web and classified them into four types: binary images, grayscale images, indexed images and truecolor images. Using the imfinfo of Scilab-4.1.2, the properties of each image were determined.

BINARY IMAGE

FileSize: 344
Format: PNG
Width: 248
Height: 248
Depth: 8
StorageType: indexed
NumberOfColors: 2
ResolutionUnit: centimeter
XResolution: 72.000000
yResolution: 72.000000

***http://www.true-binary.com/true-binary.png

GRAYSCALE IMAGE

FileSize: 28244
Format: PNG
Width: 290
Height: 300
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: centimeter
XResolution: 14.960000
YResolution: 14.960000

***http://peps.redprince.net/peps/tiger-Q300.png

INDEXED IMAGE

FileSize: 6989
Format: GIF
Width: 491
Height: 334
Depth: 8
StorageType: indexed
NumberOfColors: 4
ResolutionUnit: centimeter
XResolution: 72.000000
YResolution: 72.000000

**http://www.springboardmagazine.com/SpringImage s/tiger.gif

TRUE COLOR IMAGE

FileSize: 31029
Format: JPEG
Width: 625
Height: 450

Depth: 8
StorageType: truecolor
NumberOfColors: 0
ResolutionUnit: centimeter
XResolution: 100.000000
YResolution: 100.000000

***http://animal.discovery.com/mammals/tiger/pictures/tiger-picture.jpg

----------------------------------------------------------------------------------------------------

I looked for a 3 1/2 diskette and had it scanned. Then I got its properties using imfinfo.
The image was then converted into grayscale. I created a code that will compute and plot the histogram of the scanned image. It is clearly shown from the histogram that the region of interest (ROI) is well separated from the background which is expected.With the use of im2bw, the image was converted into black and white using the best threshold (for this case, 0.5). For a nicer image, I used MS Paint. To get the area of the image, I applied the area calculation program I made for Activity 2. With this procedure, I got a 0.33 % error from the area calculated.

I will give myself a grade of 9/10 for this activity. I finished this activity late because I had a hard time looking for an object to be scanned. I thought that any little object I could think of might have already done by my classmates. I acknowledged again the help of Gilbert and Raffy for answering all questions I had in mind.

ACTIVITY 1 - Digital Scanning

2009-06-17T19:47:00.000-07:00

Primarily, this activity aims to find the numerical values of a digitally scanned hand-drawn plot with the use of ratio and proportion.

First, I looked for a hand-drawn graph from an old journal and I found this plot from Annals of Chemistry, 1940.

This graph relates the carbon dioxide output from washed potato tubers under aerobic and anaerobic conditions.

I started noting down the pixel values of each data point by first having a conversion factor which relates the number of pixels to a certain number of physical value along both x and y axis.

For the x-axis, the ratio is 222:1 pixels and for the y-axis, there is 1440:1 pixels ratio. With these ratios in hand, I was able to tabulate the number of pixels of each data points and their equivalent physical values on each axis.

Finally, a reconstruction of the graph was done in OpenOffice.org Calc.

The plot above shows a decent reconstruction of the original graph. With the original graph being placed at the background of the reconstructed graph, we can see the correspondence among each data points with insignificant deviations. The trendline imposed on the reconstructed graph also fits the trendline of the original graph.

I evaluate myself with a grade of 10/10 from being able to find the numerical values of a hand-written graph by utilizing the ratio of number of pixels to number of physical value. I exerted enough effort to finish this activity on time. I also acknowledge the help of Raffy, Gilbert and Kaye in discussing the way on how to begin with the activity.