Think Tank Ni Cherry

A19 Restoration of Blurred Image

2009-10-12T08:19:00.000-07:00

--- brown out bakit mo binura files ko.

In the previous activity, we restored images that have additive noise.
Now we add another kind of degradation which is the motion blur.

The degradation/restoration process can be described by the following model.

Degradation can be represented as a function (H) that acts on an image f(x,y) and together with an additive noise, transforms it to a degraded image g(x, y). The goal is then to generate restoration filters that will transform the degraded image to an estimate of the original image f_hat(x,y).

In the spatial domain, the degradation process is a convolution with the image.

Therefore in the frequency domain it can be written as
MOTION BLUR

Suppose that this degradation is due to the uniform linear motion between the image and the sensor or camera. Then the camera would have captured the image motion in the duration of the exposure time T.
The blurred image can be expressed in Fourier space as
The degradation transfer function would then be computed using
where a and b is the total distance for which the image has been
displaced in the x- and y-direction, respectively. (Note: xo(t) = at/T and
yo(t) = bt/T)

WEINER FILTERING

This method considers images and noise as random processes and tries to minimize the MSE between orignal f and restored f_hat images using the following expression known as the Weiner filter

where
Assuming that the noise is just white noise and therefore constant, we have

Now for the application of the concepts....

For our original image we use

http://imageedit.infobind.com/examples/grayscale.jpg

Next we degrade the original image by blurring (transfer function given by Eq5) and adding Gaussian noise (Activity 18). We can get the degraded image using Eq2.

The parameters a, b, and T will determine the velocity of the motion in the x and y direction: vx=a/T and vy=b/T. Of course, increasing the velocities would just make the image more blurry as shown in the following images.

Doing the restoration using the actual noise pdf ( eqn 6 ), we get the following results.
Of course, the more blurred an image is, the less perfect the restoration. However we note that even for a=b=0.1 blurring, when image is no longer recognizable, filtering was still able to salvage some of the lost data.

Now we compare the results when we just assume white noise (Eq 7). As expected. better results were obtained when we did not assume white noise. K=0 results to almost all noise images. The filtering improved when K=0.001 and increasing K further does not seem to result to better restorations.

In this activity, I was able to do reconstructions of very blurry images so I give myself a grade of 10.

A18 Noise Models and Basic Image Restoration

2009-10-12T08:06:00.000-07:00

In this activity, we attempt to reconstruct or recover an image that has been degraded by using an a priori knowledge of the degradation phenomenon.

For the degradation process, we generate noise signals with different probability distribution functions and added them to the image. In actual image capture, noise could be caused by light levels, fluctuating temperatures, atmospheric disturbances and other factors.

The noises that we generated are those that are common in image processing applications and are given by the following formulas.

To remove additive noise, we implemented the spatial filtering method.

The filters that we used are

Below is our original image and its histogram.

Adding noise to the image changes this image histogram.

Gaussian Noise

Rayleigh Noise

Erlang (Gamma) Noise

Exponential Noise

Uniform Noise

Salt and Pepper Noise

For each noise pdf, we try to reconstruct the original image using the different filters. Our goal is to recover the appearance of the original image. A way of checking this is by comparing the reconstructed image's pdf with the original pdf. The images below show the reconstructions with their pdf.

Gaussian Noise

Rayleigh Noise

Erlang (Gamma) Noise

Exponential Noise

Uniform Noise
For the first 5 noise pdfs, all four filters were successful in reconstructing the image.
We can see, however, that only Arithmetic and Contraharmonic filters work for salt and pepper noise.

Salt and Pepper Noise with Q=0

Varying Q, we can see that negative values only clean salt noise, while positive values only clean pepper noise. Q=0 cleans both but not completely.
We do the same for another image, this time one that has a broader range of grayscale values.

Original Image

After adding noise:

Gaussian Noise

Rayleigh Noise

Erlang (Gamma) Noise

Exponential Noise

Uniform Noise

Salt and Pepper Noise

After reconstruction

Gaussian Noise

Rayleigh Noise

Erlang (Gamma) Noise

Exponential Noise

Uniform Noise

Salt and Pepper Noise w Q=0

Varying Q, we get the same effect as our first image.

In this activity, I was able to do spatial filtering to remove noise from an image. I therefore give myself a grade of 10.

A17 Photometric Stereo

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

Photometric stereo is the technique of extracting shapes from shadow.
We can estimate the shape of the surface by capturing multiple images of the sources at different locations. The information about the surface will be coded in the shadings obtained from the images.

In this activity we are given synthetic images of a sphere illuminated by a point source located respectively at

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

The figure below shows the multiple images

The program that I used is

//// four synthetic images of a sphere
loadmatfile('C:\Documents and Settings\VIP\Desktop\186 a17\Photos.mat');
I(1,:) = I1(:)';
I(2,:) = I2(:)';
I(3,:) = I3(:)';
I(4,:) = I4(:)';

scf(1);
subplot(2,2,1);
imshow(I1,[]);
subplot(2,2,2);
imshow(I2,[]);
subplot(2,2,3);
imshow(I3,[]);
subplot(2,2,4);
imshow(I4,[]);

///// Light source locations
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];

//// eqn 10
g = inv((V')*V)*(V')*I;

//// eqn 11
//absg=abs(g);
absg = ((g(1,:).^2 + g(2,:).^2 + g(3,:).^2).^0.5);
n(1, :) = g(1,:)./(absg + 0.00000000000000001);
n(2, :) = g(2,:)./(absg + 0.00000000000000001);
n(3, :) = (g(3,:)./(absg +0.00000000000000001))+ 0.00000000000001;

////eqn 14
dfdx = -(n(1,:))./n(3,:);
dfdy = -(n(2,:))./n(3,:);

root=sqrt(length(absg))
dfdx = matrix(dfdx, [root,root]);
dfdy = matrix(dfdy, [root,root]);

//// eqn 15
z = cumsum(dfdx, 2) +cumsum(dfdy, 1);

scf(2);
plot3d(1:root, 1:root, z);

The reconstruction is

It shows a half hemisphere although there are some ridges due to the abrupt changes in the shading

In this activity, I give myself a grade of 10 since I was able to do the reconstruction.

A16 Artificial Neural Networks

2009-10-11T21:55:00.000-07:00

Artificial neural networks are modeled after the way our brain works. Just like our brain, ANN’s most defining feature is its ability to learn through successive trainings. Training of an ANN is done by presenting to the network a set of input and target pairs. The network will then adapt its weights or strengths of connections between neurons so that the difference between the target and the network’s output will be minimized.

Among the applications of ANNs is pattern recognition. The training set will have the features-matrix as input and the classes as target.

Some of the network parameters that can be manipulated are

1. Number of hidden layers/ neurons in the hidden layer

- Bigger networks can generally solve more complicated problems. However care must also be taken to limit network size so that memorization can be avoided.

2. Epoch

- Time when all patterns in the data set have been presented to the network. The weights are adjusted after each epoch.

3. Learning rate

- May be set by trial and error.

We still use the features extracted from the two previous activities…

… and the code from Cole’s blog.

The results of the training and testing classification for different learning rates are listed below.

Correct classification would be 0 for strawberries and 1 for blueberries. Notice that for both training and testing classification the values that the neural network outputs are not exactly 0 or 1. The sample is just classified to the class that is nearer to its own value. As the learning rate is increased the classification goes closer to 0 and 1. The same also happens when we increase the number of epochs.

I give myself a grade of 10 because all the classifications were correct.

A15 Probabilistic Classification

2009-09-21T19:50:00.000-07:00

In A14, we used Minimum Distance Classification. In this activity, we implement another kind of classification scheme, which is the linear discriminant analysis or LDA.

We have already done feature extraction in A14, so we only need to worry about LDA implementation.

In general, the probabilistic classification criterion is to minimize the total error of classification. That is it follows Bayes rule and assigns an object to the class with the highest conditional probability. So if for example

then object x will be classified to class i.

Most of the time, however, it is easier to find out the probability that a class will have a particular feature vector than the probability that the feature vector belongs to a class. These two quantities are related by the Bayes theorem.

where P(i) is the prior probability or the probability about the group i that is known without making any measurement. In practice we can assume the prior probability is equal for all groups or based on the number of sample in each group.

In practice, however, this implementation requires lots of data. Instead we just assume a distribution and get the probability that an object belongs to a certain class from there. Assuming that each class has a multivariate Normal distribution and all classes have the same covariance matrix, gives us the Linear Discriminant Analysis formula:

where object to group that has maximum

LDA assumes that the classes are linearly separable. (This is ok, since the plots from a14 show that the features are indeed linearly separable.) The classes can then be separated by a linear combination of features that describe the objects. A feature vector with only 2 elements will have a separator that is a line. Three features will be separated by a plane and more than three features will be separated by a hyperplane.

The actual implementation is as follows. We used the features extracted from A14.

n1=3;n2=3; //number of test elements for fruit1 and fruit2

////////the training set features in matrix form with objects as rows and features as columns x1=[perim1(1:3,:) mr1(1:3,:) mb1(1:3,:)];
x2=[perim2(1:3,:) mr2(1:3,:) mb2(1:3,:)];
x_all=[x1;x2];

/////// classification of the training set
y=[1;1;1;1;1;1;2;2;2;2;2;2];

////// mean features
mean1=mean(x1,1);
mean2=mean(x2,1);
mean_all=mean([x1;x2],1);/// global mean vector

/////mean corrected data (data - global mean vector)
mean_corr1=x1-ones(n1,1)*mean_all;
mean_corr2=x2-ones(n2,1)*mean_all;

///covariance matrix
c1=mean_corr1'*mean_corr1/n1;
c2=mean_corr2'*mean_corr2/n2;

//// Pooled covariance matrix
C=[];
[r,s]=size(c1);
for i=1:r
for j=1:s
C(i,j)=(n1*c1(i,j) + n2*c2(i,j))/(n1+n2);
end end

invC=inv(C);

////prior probability
p=[n1;n2]./(n1+n2);

//// Discriminant function
f1=mean1*invC*x_all' - 0.5*mean1*invC*mean1' + log(p(1));
f2=mean2*invC*x_all' - 0.5*mean2*invC*mean2' + log(p(2));
classify=1*((f1-f2)<0)+1;

////////////////////////// Testing

/////// the testing set
//ordered
//x_predict=[perim1(4:6,:) mr1(4:6,:) mb1(4:6,:); perim2(4:6,:) mr2(4:6,:) mb2(4:6,:)];
//alternating
x_predict=[perim1(4,:) mr1(4,:) mb1(4,:); perim2(4,:) mr2(4,:) mb2(4,:);perim1(5,:) mr1(5,:) mb1(5,:); perim2(5,:) mr2(5,:) mb2(5,:);perim1(6,:) mr1(6,:) mb1(6,:); perim2(6,:) mr2(6,:) mb2(6,:)];

f1_predict=mean1*invC*x_predict' - 0.5*mean1*invC*mean1' + log(p(1)); f2_predict=mean2*invC*x_predict' - 0.5*mean2*invC*mean2' + log(p(2));
classify_predict=1*((f1_predict-f2_predict)<0)+1;

The results are summarized in the following tables.

TRAINING

All the training objects are classified correctly. There are zero errors in training.
We can now use the computed separator for the testing of objects not used in training.

TESTING

100% accuracy of classification. I give myself a grade of 10. =)

Reference:
http://people.revoledu.com/kardi/tutorial/LDA/LDA.html#LDA

A14 Pattern Recognition

2009-09-12T11:35:00.000-07:00

In this activity, our task was to use image processing techniques in implementing pattern recognition. The task can actually be divided into two parts; first is the feature extraction and then the training and actual classification.

Let us first define some terms that are commonly used in pattern recognition.

Pattern - set of features

Features -quantifiable properties such as color, shape, size, etc.

Feature vector - ordered set of features

Class - a set of patterns that share common properties

For this activity, I chose to work with two classes of fruits: strawberries and blueberries.
There were 6 samples for each class. Of these, 3 will be used as a training set while the other 3 will be for independent testing. The images of the fruits are shown below.

FRUIT 1: Strawberry

FRUIT 2: Blueberry

PART 1: Feature Extraction

The features that I decided to extract were color ( as rg and also as RGB), perimeter and area.

First I had to separate the fruits from the background, so I used histogram backprojection (A12).
However the segmentation wasn't clean enough so I made use of my knowledge of opening and closing operations to fix it. Then I used follow() and bwlabel() to tag each sample. For each sample I then obtained the perimeter, area, perimeter-area ratio, rg and RGB.
The program that I used was as follows.

//// fruit 1 = strawberry
//// fruit 2 = blueberry
path = 'C:\Documents and Settings\2004-49537\Desktop\186 act14\';
img1 = imread(path+'fruits1.bmp');
objpatch1 = imread(path+'patch1.bmp');
imgseg1 = 1*(segment(img1,objpatch1)>0);
//scf(1); clf(1);
//imshow(imgseg1);
img2 = imread(path+'fruits2.bmp');
objpatch2 = imread(path+'patch2b.bmp');
imgseg2 = 1*(segment(img2,objpatch2)>0);
//scf(2); clf(2);
//imshow(imgseg2);
//// perform closing and opening
se1=[ 0 1 0 ; 1 1 1 ; 0 1 0 ]; se2=ones(7,5);
imgseg1=dilate(imgseg1,se2);
imgseg1=erode(imgseg1,se2);
imgseg1=erode(imgseg1,se1);
imgseg1=dilate(imgseg1,se1);
//scf(3); clf(3);
//imshow(imgseg1);
imgseg2=dilate(imgseg2,se2);
imgseg2=erode(imgseg2,se2);
imgseg2=erode(imgseg2,se1);
imgseg2=dilate(imgseg2,se1);
//scf(4); clf(4);
//imshow(imgseg2);
[L1,n1]=bwlabel(imgseg1);
[L2,n2]=bwlabel(imgseg2);
R1=img1(:,:,1);
G1=img1(:,:,2);
B1=img1(:,:,3);
I1=R1+G1+B1;
r1=R1./I1;
g1=G1./I1;
R2=img2(:,:,1);
G2=img2(:,:,2);
B2=img2(:,:,3);
I2=R2+G2+B2;
r2=R2./I2;
g2=G2./I2;

for i=1:n1

////// area
area1(i,:)=sum(sum(1*(L1==i)));
area2(i,:)=sum(sum(1*(L2==i)));

//// perimeter
perim1(i,:)=perim(1*(L1==i));
perim2(i,:)=perim(1*(L2==i));

////// color
[row1,col1]=find(L1==i);
[row2,col2]=find(L2==i);

for j=1:length(row1)
red1=[red1; R1(row1(j),col1(j))];
green1=[green1; G1(row1(j),col1(j))];
blue1=[blue1; B1(row1(j),col1(j))];
end

for j=1:length(row2)
red2=[red2; R2(row2(j),col2(j))];
green2=[green2; G2(row2(j),col2(j))];
blue2=[blue2; B2(row2(j),col2(j))];
end

mr1(i,:)=mean(red1);
mg1(i,:)=mean(green1);
mb1(i,:)=mean(blue1);
mr2(i,:)=mean(red2);
mg2(i,:)=mean(green2);
mb2(i,:)=mean(blue2);
end

apratio1=area1./perim1;
apratio2=area2./perim2;

where segment was a function that does histogram backprojection segmentation.

PART 2. Class Representative Vector

For each class, we used features from the first three samples to get the mean feature per class.

Noting that the greatest difference of mean features for the two classes and the least standard deviation of feature values within a class occurred for the perimeter, R, and B; I used these three to make up the mean feature vector per class.

The program is as follows.

/////// mean features
meanarea1=mean(area1(1:3,:));
meanarea2=mean(area2(1:3,:));
meanperim1=mean(perim1(1:3,:));
meanperim2=mean(perim2(1:3,:));
meanapratio1=mean(apratio1(1:3,:));
meanapratio2=mean(apratio2(1:3,:));
meanr1=mean(mr1(1:3,:));
meanr2=mean(mr2(1:3,:));
meanb1=mean(mb1(1:3,:));
meanb2=mean(mb2(1:3,:));

m1=[meanperim1 meanr1 meanb1]';
m2=[meanperim2 meanr2 meanb2]';

PART 3: Minimum Distance Classification

Class membership is then determined by assigning an object to the class that has a minimum euclidian distance from it in terms of the feature vectors. Or alternatively, we can compute

where x is the unknown object's feature vector and m sub j is the mean feature vector of class j.

The object will then be classified to the larger d

d1=x'*m1 - 0.5*m1'*m1;
d2=x'*m2 - 0.5*m2'*m2;

classify=1*((d1-d2)<0)+1;

The first testing set consists of 3 strawberries (fruit 1) and then three blueberries (fruit 2).
The classification is 100% correct.

The second testing set consists of alternating strawberries (fruit 1) and blueberries (fruit 2).
The classification is still 100% correct.

Plotting in feature space, we see that...
(Red = fruit1; Green = fruit2; Circles = unknown class features; Star = mean features)

R vs B

Perimeter vs R

Perimeter vs B
The features of the two classes are clearly separable.

For this activity, I give myself a grade of 10. My classifications are 100% accurate.

Image from:
http://img2.allposters.com/images/NIM/KE041.jpg

A13 Correcting Geometric Distortion

2009-08-24T18:54:00.000-07:00

Geometric distortions may result from the camera lens being spherical. Two common distortions are the barrel and the pin cushion distortions.

In barrel distortion, the image seems bloated in the middle and pinched at the sides.

The opposite happens for pin cushion distortion.

In this activity, we will try to correct pin cushion and barrel distortions.

First we need an image of a regularly repeating pattern like a grid or checkerboard as reference.
This will help us visualize the distortion that happens across the image.

Below, we show such a pattern for the barrel distortion

and for the pincushion distortion

Now, what we need to find is the transformation that will map the distorted image to the ideal image.

First we look at the transformation of pixel coordinates.

We assume that the coordinates are transformed in both directions simultaneously, so that r and s would be bilinear functions

The distorted coordinates would therefore be given by
To find the eight unknown coefficients c1-c8, we use the 4 vertices of a grid. These coefficients are valid only for points within the gird used and must therefore be generated for each grid in the image.

Using the four vertices, and rewriting the eight equations in matrix form we have
The distorted coordinates are easy to find. In Scilab, we just use the locate() function.
For the barrel distortion image above, the located points are marked with red crosses

Similarly for the pincushion
The ideal coordinates on the other hand are generated from the grid length down and across a grid from the most undistorted portion of the image (optical axis of the camera). In my program, I used

////count number of pixels down and across one box
//// choose diagonal points (origin and 1,1)
scf(1); clf();
imshow(im);
xy=locate(2,1);
//// ideal vertices
xoyo=xy(:,1);
xideal=(xoyo(1) + [-cols/2:cols/2]*xratio);
yideal=sort(xoyo(2) + [-rows/2:rows/2]*yratio);
a=ones(1:cols+3);
b=ones(1:rows+3);
xi=a'*xideal;
yi=yideal'*b;

where xi and yi are matrices that contain the column and row values of the grid vertices respectively. For example xi(1,2) will give the column value of the vertex at topmost row and 2nd to the left column.

We now know both the ideal and distorted vertices.

For the succeeding parts, I will place my discussions inside the code using comments.
(Its rather hard to discuss it step by step since they are all inside common loops)

/// The 2 for loops go through each grid
for i=1:rows
for j=1:cols

///Now to compute the 8 coefficients for each grid, I made the following code.
//// Computation of Coefficients per grid
T=[xi(i,j) yi(i,j) xi(i,j)*yi(i,j) 1; xi(i+1,j) yi(i+1,j) xi(i+1,j)*yi(i+1,j) 1; xi(i+1,j+1) yi(i+1,j+1)xi(i+1,j+1)*yi(i+1,j+1) 1; xi(i,j+1) yi(i,j+1) xi(i,j+1)*yi(i,j+1) 1];
Xd=([xd(i,j) xd(i+1,j) xd(i+1,j+1) xd(i,j+1)])';
Yd=([yd(i,j) yd(i+1,j) yd(i+1,j+1) yd(i,j+1)])';
C1_4=inv(T)*Xd;
C5_8=inv(T)*Yd;
c=[C1_4;C5_8];

//// The vertices of the ideal grid are given by
Xi=([xi(i,j) xi(i+1,j) xi(i+1,j+1) xi(i,j+1)])';
Yi=([yi(i,j) yi(i+1,j) yi(i+1,j+1) yi(i,j+1)])';
xir=floor(Xi); yir=floor(Yi);

//Now we go through each pixel in the grid.
for l=min(yir):max(yir)-1
for m=min(xir):max(xir)-1

//Per pixel in the ideal grid the location of that point in the distorted image is given by
xdistort2=c(1)*m + c(2)*l + c(3)*m.*l + c(4);
ydistort2=c(5)*m + c(6)*l + c(7)*m.*l + c(8);
xdr2=floor(xdistort2);
ydr2=floor(ydistort2);

////// Gray Level Interpolation
// ////The final part of the problem is to find the gray level value at the ideal pixel location.
//////This should just be a matter of assigning to the ideal coordinates the pixel value at the corresponding //////distorted coordinates (calculated using the two equations above).
//////However, the two equations above would not give exact integers all the time and so we need to //////interpolate the graylevel value. The interpolation that will be done here is the bilinear interpolation, //////whereas the gray level value at (x,y) is given by

////// a b c d can be obtained from the four nearest pixels of the location rather like the way we calculated the //////unknown coefficients c1-c4.
V=[im(ydr2,xdr2); im(ydr2+1,xdr2); im(ydr2,xdr2+1); im(ydr2+1,xdr2+1)];
Tv=[xdr2 ydr2 xdr2*ydr2 1; xdr2 (ydr2+1) xdr2*(ydr2+1) 1; (xdr2+1) ydr2 (xdr2+1)*ydr2 1; (xdr2 +1) (ydr2 +1) (xdr2 +1)*(ydr2+1) 1];
abcd=inv(Tv)*V;
im2(l,m)=(abcd(1)*xdistort2 +abcd(2)*ydistort2 + abcd(3)*xdistort2.*ydistort2 + abcd(4));

end
end

end
end

After correction the barrel distorted image now looks like (only the center 4 rows and columns)

while the pin cushion image looks like (only the center 4 rows and columns)

I also tried correcting distortions on more complicated images, like the cd rack below

and here is the result

Alternately, undistorted images can be distorted using the same procedure. We just have to superimpose a distorted pattern over an undistorted image, apply correction to the lines and voila! The image becomes distorted.

For this activity, I give myself a grade of 10. I was able to implement the correction for the barrel and pincushion distortion.

Images from
http://www.astrosurf.com/buil/iris/tutorial19
Ref
Activity 13 Manual

A12 Color Image Segmentation

2009-08-07T07:35:00.000-07:00

In this activity, we color segment an image using parametric and non parametric segmentation.

For the non parametric segmentation, we did histogram backprojection wherein based on a color histogram of the ROI a pixel location is given a value equal to its histogram value in chromaticity space.

The parametric segmentation was done by assuming a gaussian pdf independently along r and g values of the ROI.

Since we are using 2D histograms, we first check if we are indeed getting the right colors.
Here the cropped portion is blue. Comparing our histogram with the chromaticity diagram below, we can see that the histogram is indeed correct. (I rotated the axis of the chromaticity so as to coincide with the histogram origin whichis at the upperleft corner.)

The results for the two methods are shown below.

A. Mugs

The image is

The cropped ROI is

For the non parametric segmentation, the result is

while for the parametric segmentation

B. Obama Lantern
The portion that I cropped is the light yellow part.

The result for the nonparametric was
For the parametric the pdf and the segmented image are

C. Starry Starry Night

The image is

The cropped color is
The non parametric segmentation result is

The parametric segmentation pdf and result is

We can see that the parametric segmentation is a lot stricter than the non-paramertic segmentation. Parametric would work better for when we want to segment shades of colors that are very much alike. For less stricter segmentations use non parametric.

In this activity, I give myself a grade of 10 because I understood and was able to do everything that was required.

A11 Color Camera Processing

2009-08-07T07:21:00.000-07:00

White balancing ensures that an object that is white will appear white in an image no matter what the light source is. In an ordinary digital camera, some of the white balance settings would include daylight, cloudy, fluorescent and incandescent.

In this activity, we investigate the two different white balancing algorithms: White Patch and Gray World.
This is the correctly balanced image.

The image below was taken under fluorescent light sources but was white balanced using incandescent.

For this case both algorithms work well.

Gray World

White Patch

For a sample with low variety of colors

The properly white balanced (fluorescent) image is
When wrongly balanced using incandescent
Whitebalancing it again results to

Gray World
White Patch

We can see that the gray world only works when the gray world assumption holds. That is when there are indeed comparable areas that have reds, greens and blues in the image.

A10 Preprocessing Text

2009-08-07T07:10:00.000-07:00

For activity 10, we were given an image of a receipt.
I cropped only a portion of the image.
Its fft is

We can see that the points corresponding to the lines are slanted. From here we can estimate the angle to be around 3 degrees.

Rotating the image, we have

The corresponding fft is now straighter.

Next we remove the lines by masking out the part of the fft that corresponds to it.
The filter used was

and the resulting image is

A9 Binary Operations

2009-07-29T19:49:00.001-07:00

In this activity, we are tasked to get the best estimate of one "cell". As can be noticed some of these cells are overlapping or incomplete. This task will therefore take all that we have learned so far to get a pretty good estimate of the area.

First, we cropped the image into 12 subimages.

Next we used im2bw to threshold the image and separate background from the cells.

From the image above, we can see thatsome parts of the background were still included. We remove this noise but still preserve the area of the larger pixels by doing morphological cleaning. This is done by first applying erosion to remove the small dots and then performing dilation to restore the cells into their original sizes. The structuring elements should be large enough to remove the dots but not the cells. The structuring element that I used is

se1=zeros(9,9);
se1(:,4:6)=1;
se1(4:6,:)=1;

Next I performed closing on the images by first dilating then eroding the image. The structuring element that I used is a cross three pixels long and 1 pixel thick.
I used bwlabel to name each contiguous blob and did pixel summing for the area. The histogram of the areas is

We can see that the spread is very large. Knowing that the very large or very small areas are from the overlapping and incomplete cells respectively, we can safely limit our histogram to the most likely areas which are in this case 400 to 600 pixels

From here we can get

best estimate of area = 524.90909
standard deviation = 35.852444

Cropping some single random cells, I found that their areas range from 519 to 525, so my estimate is correct.
It is also possible to remove the overlapping cells, by opening to remove the individual cells and leave just the overlapping cells. If we subtract this to the original binary image, what will be left are just the non-overlapping cells. However I have yet to find the right, structuring element to do this.

I give myself a grade of 10 because, I was able to get a good estimate of the area and and a standard deviation that is just 6.83% of the mean.

References:
[1]http://homepages.inf.ed.ac.uk/rbf/HIPR2/open.htm
[2]http://homepages.inf.ed.ac.uk/rbf/HIPR2/close.htm

A8 Morphological Operations

2009-07-27T17:56:00.000-07:00

Morphological operations are operations that affect the shape of an image. Two such operations that we could use for binary images are the erode and dilate.

If A is the image and B is the structuring element then dilation is defined as

Dilation involves all z's which are translations of a reflected B that when intersected with A is not an empty set. The result is an expansion or an elongation of A.

Erosion, on the other hand, is defined as
This operation includes all points z such that B translated by z is still contained in A, The resulting image is the image A reduced by B.
In this activity, we erode or dilate some common shapes ( square, triangle, circle, hollow square and cross) using 4 different structuring elements. In the images that will follow, the leftmost image is the eroded image, the center image is the original image while the rightmost image is the dilated image.

Structuring Element 1: 4 X 4 ones

Structuring Element 2: 2 x 4 ones

Structuring Element 3: 4 x 2 ones

Structuring Element 4: Cross , 5 pixels long and 1 pixel thick

Before simulation, I first tried to predict the results of erosion and dilation and they were correct. Here they are...

I also explored other morphological operations like skel and thin.

Skel stands for skeletonization. According to the Scilab Help, the skeletons are computed using the euclidian metric and are connected over all scales of simplification. When applied to the previous images, the results are...

The function thin performs border deletion using Zhang Suen technique. According to the Scilab Help, the resulting image is not always connected and is very sensible to noise. Thin works well with thin images, but not so well with thicker images.
I give myself a grade of 10 because I fully understood the activity.

References
[1] Morphological Operations, Ap 186 Activity 8 Manual
[2] Scilab Help Browser

A7 Enhancement In The Frequency Domain

2009-07-13T17:39:00.000-07:00

Convolution is the smearing of one function against another so that the output looks a little like both. Mathematically it can be written as

In Fourier space, however, the convolution becomes a multiplication. That is the FT of a convolution of two functions in space is the product of the two functions’ FTs.

FT [ f ∗g ]=FG

This is called the convolution theorem. It is this property of the convolution that makes it very convenient to do image enhancements and suppressions in the Fourier domain. We can just create a filter mask to remove or enhance some frequencies, multiply it to the image’s FT and do the inverse transform.

In this activity we first demonstrate some examples of convolution then use the theorem to enhance images.

A7A. Convolution Theorem

An image of a dot that is one pixel thick can be used to represent a dirac delta.We get the FT of two dots (dirac deltas) symmetric about the and see that it is a sinusoid pattern.

From the formula above, we can solve that the convolution of a dirac delta and a function f(t) results in a replication of f(t) in the location of the dirac delta.

A convolution of the two dirac deltas, above and a circle would just result to two circles in the locations of the peaks. From the convolution theorem, it can be predicted that the FT of this would just be a product of an Airy disk and the sinusoid pattern.

As the circle’s radius is reduced, the Airy disk becomes smaller. This can be seen in the images below. The sinusoid pattern however remains unaffected.

We already know from previous activities that the FT of a square is a sync pattern. The FT of the convolution of a square and two dirac deltas would therefore be just a sinc pattern with sinusoid linings. Increasing the square size reduces the size of the sinc pattern. The sinusoid retains its frequency.

Next the squares are replaced by Gaussians of varying variance. The resulting FT is that of a Gaussian with sinusoid patterns. Like the circle and square pairs the FT pattern becomes smaller as the variance becomes bigger.

Lastly, the values of the Gaussian were inverted as imaged below. Checking its fft, I found out that the values were just the negative of that of the fft of the original Gaussian.

The program that I used for this part is as follows.

clc;

x = [-1:0.005:1];

[X,Y] = meshgrid(x);

/////dots

rad=0.25;

r1 = sqrt((X-0.5).^2 + Y.^2); r2 = sqrt((X+0.5).^2 + Y.^2);

dots = zeros(size(X,1), size(X,2));

dots(find (r1 <=rad )) = 1.0; dots(find (r2 <=rad )) = 1.0;

//one pixel dots

//dots(find(X==0.5 & Y==0))=1;dots(find(X==-0.5 & Y==0))=1;

//////squares

d=0.25;

square= zeros(size(X,1), size(X,2));

square(find(abs(X-0.5)<=d & abs(Y) <=d))=1.0;

square(find(abs(X+0.5)<=d & abs(Y) <=d))=1.0;

/////// gaussian

sigma=0.005;

r1=sqrt((X-0.5).^2 +Y.^2);r2=sqrt((X+0.5).^2 +Y.^2);

g1=exp((-(r1).^2)/sigma^2) ;g2=exp((-(r2).^2)/sigma^2);

gaussian = zeros(size(X,1), size(X,2));

gaussian= g1 + g2;

gaussian=gaussian/max(gaussian);

/////// invert gaussian

invgaussian=1-gaussian;

image=square;

scf(1);

subplot(1,2,1);

imshow(image,[]);

//scf(2);

subplot(1,2,2);

imshow(fftshift(abs(fft2(image))),[]);

A7B Fingerprint Ridge Enhancements

Below is an image of a fingerprint. Notice that some of the ridges are indistinct and that some parts are smudged.

Our task was to do filtering in the frequency domain such that the smudges are removed and the ridges are enhanced. The fft of the fingerprint is as shown below

I interpreted the higher frequency areas to be from the ridges while the rest are from the noise.

For my first set of filters, I thought of using the im2bw() command to threshold the fft image so that only the high frequency areas are imaged. The image below shows the mask, the masked fft and the enhanced fingerprint for 0.2, 0.3 and 0.4 threshholds. We can see that for 0.2 and 0.3 although the ridges are enhanced so are the smudges. Threshold 0.4 clears the smudges but some information are also erased.

Next I tried the contrast enhancement and the thresholding of GIMP to create the filters. The firrst two filters did enhance the ridges...

but my best result was

Lastly, taking an idea from the first part of activity A, I tried an inverted Gaussian filter.

A7C. Line Removal
The image of the lunar landing below has a series of vertical lines in it.

We know from our previous activities that these lines would correspond to the bright spots aligned horizontaly on the fft.

We therefore use the filter

The enhanced image is now free of lines.

A7D Removal Of Canvas Weave

The painting image below has its canvas weave pattern showing through.
From previous activities, we know that the cross hatch pattern are just crisscrossing sines and will therefore show up in the fft as pairs of dots.
To filter out the dots, we use
The enhanced image is

We expect the filtered out pattern to look like the weave when it is inversed fft.
In this activity, I give myself a grade of ten because I was able to do all that is required.

A6 PROPERTIES OF THE 2D TRANSFORM

2009-07-11T22:42:00.000-07:00

In A5 we familiarized ourselves with the 2D transform. In this activity we take a more in depth look at some of the properties of the 2D transform.

A6A Familiarization with FT of Different 2D Patterns

The FT of a 2D image will give us the resulting diffraction pattern for an aperture of the same shape. It is therefore important to familiarize ourselves with the FT of some common 2D patterns.

Annulus

The FT of an annulus looks like the FT of a circle (Airy disk) with some of the fringes missing.

Figure 1

Square

Mathematically, the FT of a square are sync functions along the x and y axes. This can be seen below.

Figure 2

Square Annulus

The FT is similar to that of the square, but with some fringes missing.

Figure 3

Two Slits

This is actually a simulation of Thompson Young’s Double slit experiment, and our results agree with the experimental results.

Figure 4

Two Dots

The FT looks like that of the circle but with vertical fringes due to destructive interference from the signals coming from the two dots.

Figure 5

The 2D patterns are generated in Scilab using the following code

/////// 6A

x = [-1:0.01:1];

[X,Y] = meshgrid(x);

/////////// annulus

r = sqrt(X.^2 + Y.^2);

annulus = zeros(size(X,1), size(X,2));

annulus(find (r <=0.3 & r>=0.2)) = 1.0;

////// square

square= zeros(size(X,1), size(X,2));

square(find(abs(X)<=0.4 & abs(Y) <=0.4 ))=1.0;

////// square annulus

square2=square;

square2(find(abs(X)<=0.25 & abs(Y) <=0.25 ))=0.0;

//////slits

slits= zeros(size(X,1), size(X,2));

slits(find(abs(X)>=0.47 & abs(X) <=0.5 ))=1.0;

//////dots

r1 = sqrt((X-0.5).^2 + Y.^2); r2 = sqrt((X+0.5).^2 + Y.^2);

dots = zeros(size(X,1), size(X,2));

dots(find (r1 <=0.05 )) = 1.0; dots(find (r2 <=0.05 )) = 1.0;

image=dots;

subplot(1,2,1);

imshow(image,[]);

subplot(1,2,2);

imshow(fftshift(abs(fft2(image))),[]);

A6B Anamorphic Property of the Fourier Transform

The FT of a sinusoid is two peaks located at its positive and negative frequency values. Increasing the frequency therefore makes the peaks farther apart. We can also say that because the spacing between dark and light bands becomes narrower, since the FT is in inverse space, the spacing between the peaks will be wider. This is shown in the images below. The images in the first row are the sinusoids while those below are the FTs.

Figure 6

Real digital images do not have negative values. Therefore if we want to simulate a digital image, we must add a constant bias to our sinusoids.

Figure 7

The results of the FTs when bias is added to the sinusoid are shown above. As we can see, no matter what the constant bias, its FT will always be a peak in the origin. So to find the frequency of the sinusoid we just have to ignore the central frequency.

The same is true when the bias is a sinusoid with very low frequencies. We already demonstrated above that the lower the frequencies, the closer to the origin the peaks will be. The image below is the FT of a sinusoid with frequency = 4 with a sinusoid bias of frequency = 0.25. The peaks of the original sinusoid are unchanged; however, there are now to extra peaks very close to the origin and almost looking like the single peak of the constant bias. Therefore to find the original frequencies we also just ignore the central and “almost” central frequencies.

Figure 8

In the 2D FT a rotation of the sinusoids results to a rotation in the FTs. This is shown below. The sinusoid is rotated from 0˚ to 45˚ to 90º to 135º.

Next we created a pattern of sinusoids in x and y using the following formula

sine = sin(2*%pi*4*X).*sin(2*%pi*4*Y). The resulting pattern and FT are shown below.

Figure 10

We then added several rotated sinusoids to this pattern and predict the FT. Knowing that the FT has the property of linearity, we can predict that adding the sinusoids from Figure 9 to the sinusoid in Figure 10 will result to just the superposition of their FTs. Taking the actual FTs, we indeeed had correct predictions.

Figure 11

Then just for fun, I tried adding all the sinusoids together.

Figure 12

In this activity, I understood all that I did so I give myself a grade of 10.

A5 Fourier Transform Model Of Image Formation

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

This activity is a demonstration of the many uses of the Fourier Transform.

We did this part by part and here are my results.

5.A FAMILIARIZATION WITH DISCRETE FFT

The FFT of an image is a transformation into inverse space or spatial frequency.

The function is built into Scilab and here are our results when fft2 is applied to a circle and to the letter A.

Original Image

FFT and zoomed Shifted FFT

FFT of FFT

Original Image

FFT and zoomed Shifted FFT

FFT of FFT

The output of fft2 has the quadrants along the diagonals interchanged; therefore fftshift is needed to realign the quadrants back. As expected the fft of a circle resulted to an Airy disk. Applying fft2 twice just resulted to an inverted copy of the original image.

5.B SIMULATION OF AN IMAGING DEVICE

The convolution model predicts the image produced when an object is viewed using an imaging sytem. Convolution is the smearing of one function with another such that the resulting function looks a little like both. In Fourier space, the product of the FTs of the image and the imaging system will give us the FT of the resulting image.

To simulate, we used the word “VIP” for our image and a circle to represent the aperture of an imaging device.

Original Image

We then applied fft2 to the image and fftshift to the aperture since the aperture is already in Fourier plane). The results after convolving are shown below. It was observed that as the diameter of the aperture gets bigger, the image becomes sharper. This is because a larger circle results to a smaller Airy disk.

Apertures

Resulting Images

5.C TEMPLATE MATCHING USING CORRELATION

Correlation measures the degree of similarity between two functions. The correlation value peaks at points where there is an exact match.

For example to find the letter A in the text…

…we use the template

We then element per element multiplied the fft of the template and the conjugate of the fft of the text. The image of the inverse fft is

The text is now inverted but we can still check that the bright peaks occur at the locations of the letter A.

5.D EDGE DETECTION USING THE CONVOLUTION INTEGRAL

Another application would be edge detection. We can convolve an image with a matrix pattern of an edge using the function imcorrcoef in Scilab.

When the edge pattern is horizontal the horizontal edges are emphasized.

Likewise for a vertical edge pattern.

Spot pattern gives me the best result

I give myself a grade of 10 because I was able to do all that was required in this activity.

A3.2 Image Types and Background Enhancements

2009-07-06T17:51:00.000-07:00

This is the second part and last part of Activity 3.

This is my original scanned image.

Using the command imfinfo(), I found out about the properties of my original image.

Size: 345 rows X 887 columns
Indexed Image
FileName: C:\Documents and Settings\VIP\Desktop\Acads 09-10\186\a3 image types and basic image enhancements\scanned images\che.bmp
FileSize: 307438
Format: BMP
Width: 887
Height: 345
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: centimeter
XResolution: 59.060000
YResolution: 59.060000

As we can see, the image is already in grayscale (8 bit depth) so there is no need to convert it.

To find out if my region of interest (ROI) is well separated from its background, we look at the image histogram. This can be done either in Gimp or using the Scilab program

Path2='C:\Documents and Settings\VIP\Desktop\Acads 09-10\186\a3 image types and basic image enhancements\scanned images\che2.bmp';
I=imread(Path2);
[nr,nc]=size(I);
range=[0:1:255];
hist=[];

//count histogram
for i=1:256
[x,y]=find(I==(i-1));
hist(i)=length(x);
end;

scf(1)
plot(range,hist/(nr*nc));
a=gca(); a.data_bounds = [0,0;255,max(hist/(nr*nc))]; a.tight_limits='on';

The image below is my ROI (white part) surrounded by the black background. Following it is a plot of the normalized image histogram. As expected, the histogram shows two distinct parts: the low value background and the high value ROI.

To get the area of my ROI, we can use thresholding by converting the image to binary using im2bw().

We can then get the area using the Green’s theorem just like what we did in A2.

Agreen= 55037 sq. pixels

We can also get the area by counting the number of white pixels.
In this case the area = 55058 sq. pixels

The discrepancy could be attributed to the fact that our second method also counted white pixels that are not part of the ROI. For this case the area calculated using Green’s theorem is the more correct one. In any case, the values that we obtained differ only by a very small amount.

For this activity, I fully understood the differences between the 4 basic image types. I learned about the different ways to check an image's properties and see its image type. I was also able to do histogram thresholding to separate the background from the ROI. I therefore give myself a grade of 10.

A4 Enhancement By Histogram Manipulation

2009-07-01T18:20:00.000-07:00

Just by looking at an image histogram, we will be able to know about the image's contrast, exposure and tonal range and thus be able to know if and what adjustments to make.

An image histogram represents the spread of the pixel values of a digital image. For a gray scale image (bit depth = 8bits ) , each pixel can have a brightness value from 0 for black and 255 for white. The histogram is a count of how many pixels are at each brightness value.

http://www.cambridgeincolour.com/tutorials/histograms1.htm

When the histogram is normalized by the total number of pixels we have the probability distribution function. From the pdf we can obtain the cumulative distribution function or the cdf.

In this activity, our aim is to improve the contrast of an image by remapping pixel values of the old cdf so that the resulting cdf will have the desired pdf. Step by step this is how it is done.

For each pixel value …
find the original cdf value.
Trace this original cdf value in the desired cdf.
Replace the original pixel value with the pixel value that will give the same probability in the desired cdf graph

Here are some of my results.

For a desired uniform distribution pdf the cdf is a straight line.

This is the original image...

http://www.janellegreenwood.com/images/grayscale.jpg

and the original PDF...

and the original cdf.

Notice that most of the pixel values are in the middle tones and that no very bright or very dark values exist. This is a very poor contrast image. However after a remapping of the pixel values...

Here is the contrast enhanced image.

The image now has whites and blacks instead of just middle grays.
In fact, the pdf shows that the range of pixel values now extend to all the possible levels. A check of the new cdf reveals that it is indeed linear.

New PDF

New CDF

Here are the results for the other images.

Before and After

http://www.drgdiaz.com/pat/gallstones.shtml

http://www.american-indian-artwork.com/restoration/grayscale-picture-650.jpg

http://www.american-indian-artwork.com/restoration/grayscale-photograph.jpg

Now notice that for some of the enhanced images there are parts that looked rather saturated and noisy. This happens especially for images with a limited range of pixel values because the algorithm forces the image histograms to stretch over the entire range of pixel values. A solution to this is to remap only on the original histogram range.

Another way is to find another cdf that suits the image better.

Using a parabolic function (positive half only) I got a better result for the image of the lady.

For this activity, I give myself a grade of 10. I was able to do image enhancement and I fully understood the activity.

Link for grayscale images

2009-06-29T17:57:00.000-07:00

Guys I found a link that contains grayscale ultrasound images.

http://www.drgdiaz.com/pat/images.shtml

A2.2 Area Estimation of Images with Defined Edges

2009-06-24T19:59:00.000-07:00

Today, we used Green's theorem to estimate the area of the images that we created last tuesday (see A2.1) and compared it with the theoretical area which was obtained from the pixel count.

Green's theorem relates a double integral to a line integral using this equation:

where the functions F1, F2 and their derivatives are continuous in the region containing the area that we want to find.

If we apply the theorem to for these 2 cases (1) F1=0, F2=x and (2) F1=-y, F2=0, we can get an equation for the area of an enclosed region using

In discrete form it becomes

where (xi, yi) are the contour points of the region.

The program that I used in Scilab is as follows

close (); clc;

Im=imread('C:\Documents and Settings\2004-49537\Desktop\cherry\a2 images\car.jpg');

Im_bw= im2bw(Im,0.5);

[x,y]=follow(Im_bw);

//////// Close the contour
x(length(x) + 1)=x(1); y(length(y) + 1)=y(1);

//figure()
plot(x,y);

//////// Area According to Green's Theorem
s=length(x);

Agreen= round(0.5 * (sum(( x(1:(s-1)).*y(2:s) - y(1:(s-1)).*x(2:s)))+s))

//////Checking

Acheck1=sum(floor(Im_bw))

The added term in the green's area calculation is because the follow command only counts the lower left contour, 0.5 s will make the upper right corner boundary included in the area.

The table below shows the comparison between the area computed using the Green's theorem and the area computed using pixel count for the images that I posted in A2.1. I also tried this for other more unsual shapes like the ones below and it still worked. In fact this will work for all regions with well defined edges or those that have no empty spaces in between (See what happens when image is a loop).

Image	Area (Green)	Area (Pixel Count)
triangle	11, 685	11, 685
square	26, 732	26, 732
rectangle	12, 640	12, 640
ellipse	13, 548	13, 548
circle	50, 000	50, 000
car	18, 383	18, 383
name	8, 766	8, 766
loop	7, 469	4, 952

I give myself a score of 10 because I fully understood and enjoyed the activity.
Reference: A2 Handout

Acknowledgement: Thanks to Miguel Sison for making my SIP toolbox work. Thanks also to Jay Samuel Combinido, Jica Monsanto and Miguel Sison for answering my questions about the activity.

A3.1 The Different Image Types

2009-06-23T01:33:00.000-07:00

As part of the third activity, we studied about the 4 different image types and looked for sample images for each type.

Binary images have only 1 bit per pixel and are therefore black OR white images.

http://www.planetoftunes.com/dtp/dtp_media/bitdepth/cat1bit.gif

http://www.pages.drexel.edu/~brooksdr/DRB_web_page/howto/BW_image/BW_program.htm

They should not be confused with Grayscale images which are black AND white images. Grayscale images have 1byte per pixel. This means that each pixel can have can have any value from 0 (black) to 255 (white). Grayscale images are usually used for medical images like the retina ultrasound below.

http://www.drgdiaz.com/images/eye-rbn.shtml

When three grayscale channels, one each for red, green, and blue intensities, are overlaid, a Truecolor image can be produced. Because there are 3 bytes / pixel, Truecolor images can have 256 X 256 X 256 or over 1.6 million possible colors. Images from digital cameras are truecolor images.

http://r0k.us/graphics/kodak/kodim15.html

Because truecolor images require greater memory sizes, sometimes an image may be Indexed to save space. An indexed image contains the image itself and its colormap. All the colors in the image will then be represented by a number which is an index in the colormap.

http://www.sketchpad.net/basics6.htm
http://www.webdesign.org/img_articles/15717/dx-flower-final-other-colors.gif

Reference: Activity 3 Handout

A2.1 Area Estimation of Images with Defined Edges

2009-06-22T20:21:00.000-07:00

The first part of these activity tasked us to create regular shapes
with analytical sizes.

Here are the shapes that I created using Paint.

A1 DIGITAL SCANNING

2009-06-22T17:58:00.000-07:00

WHAT?

The aim is to use ratio and proportion to find the numerical values of a digitally scanned hand-drawn plot using the following softwares Paint, MS Excel, and Gimp.

HOW?

First I used the Rotate function of GIMP to properly align and crop the plot.

A1 – DIGITAL SCANNING

The plot was then opened in Paint where the pixel locations can easily be found by selecting points using the mouse cursor. Note that in Paint the (0,0) pixel location is at the upper left corner of the image.

The plot origin (x0, y0) was located at the pixel point (1, 1173).

Next I computed for the ratio of the physical unit (number of tick marks) and the pixel unit (number of pixels included between tick marks). To minimize the error due to uneven grid lines and the “arbitrariness” of the pixel location (I had to decide where the edge of the grid line should be), I decided to take the average of several measurements.

A1 – DIGITAL SCANNING

x (phy unit)	y (phy unit)	x (pixels)	y (pixels)	x ratio	y ratio
0	0	1	1173
1	1	150	1025	0.00671	0.00676
2	2	300	880	0.00669	0.00683
3	3	450	732	0.00668	0.00680
4	4	595	586	0.00673	0.00681
			average	0.00670	0.00680

I can now compute the physical value of any point in the graph using the following formulas:

x_phy = (x_pixel-1)*x_ratio + x_phy_origin

y_phy=20*(1173 - y_pixel)*y_ratio + y_phy_origin

In this case the physical origin is at (0 days,80 grams). In the plot a y tick mark corresponds to increments of 20 grams, therefore the second equation has a 20 factor.

DID IT WORK?

The plot below shows the reconstructed plot (yellow) superimposed with the scanned plot.
The reconstructed plot follows the scanned plot very closely except in some portions of the grid lines.
An exact match is not really expected because the original graph is hand-drawn and is therefore has some misalignments and uneven lines.
I give myself a score of 8 because although I had a good reconstruction of the plot, I was absent during the activity and I submitted my work late. (Bigay ko po excuse letter ko sa class. =) )

Acknowledgement:
Thanks to Ms. Kaye Vergel for helping me post my blog and to Dr. Gay Jane Perez for giving us the scanned copies of our plots.

Reference:
The graph that I used was copied from the a 1923 book, Practical Chemistry 8th ed by Philip Hawk printed by P. Blakinston Son & Co, Philadelphia, USA.