Applied Physics 186

A19 - Probabilistic Classification

2008-10-08T18:29:00.006+08:00

I used the test image data in Activity 18.
group 1 - one peso coins
group 2 - 25 centavo coins

x - features of all data

66511	0.926294
66473	0.949915
66511	0.777889
45555	1.163125
48126	0.777889
47958	0.930314

y - group of the object of all data.
y = [1;1;1;2;2;2]

x1 - group 1
x1 = [66511 0.926294;66473 0.949915; 66511 0.777889];

x2 - group 2
x2 = [45555 1.163125; 48126 0.777889; 47958 0.930314];

u1 - mean of features of group 1
66498.333
0.8846993

u2 - mean of features of group 2
47213.
0.9571093

u - mean features of all
56855.667
0.9209043

x0 - mean corrected data

Therefore,

x01	x02
9655.333	-11300.7
0.00539	0.242221
9617.333	-8729.67
0.029011	-0.14302
9655.333	-8897.67
-0.14302	0.00941

c1 and c2 are covariance of each group.
c1 =

92981341	-349.939
-349.939	0.007108

c2 =

94360206	-524.168
-524.168	0.026404

C - group Covariance
C =

93670774	-437.053
-437.053	0.016756

We then find the inverse of C
InvC =

1.215D-08	0.000317
0.000317	67.94902

f1 and f2 are the Linear Discriminat Functions

f1	f2
74.81613	72.76803
76.69272	74.62444
62.76609	60.89518
71.22988	73.33025
42.74908	44.76578
54.94263	56.81285

We will use a test image( a 25 centavo coin). Let's pretend that we did not know what it is.
T = [48392 0.7848263]

The Linear Discriminant Functions are
f1T = 43.601981
f2T = 45.554149

From the graph, it shows that the test function is close to the 25 centavos. So I think our prediction is right. :)

Acknowledgments:
Linear Discriminant Analysis Lecture

Grade: 10/10 because I think that my result is right.

A18 - Pattern Recognition

2008-09-18T10:30:00.010+08:00

Pattern recognition is the act of taking in raw data and taking an action based on the category of the data.(Wikipedia)

For this activity, the goal is to classify images of one peso coins and 25 centavo coins using features extracted from the training images. I have three training images from both the one-peso coin and 25-centavo coin.

The features I extracted from the images are their area and RED-GREEN contrast. To find the area, I binarize the image and to pixel counting.

I assigned 1 for piso and 2 for 25 centavos.

The result of pattern recognition is:
There is a 100% accuracy in determing the right coin.

Acknowledgments:

Aiyin, April - for the help.

Grade: 10/10 although I had difficulty in making this activity, I think I made a correct activity.

A17 – Basic Video Processing

2008-09-04T21:11:00.002+08:00

This activity is all about video processing.

Video is a sequence of still images representing scenes in motion. Video processing is the use of different image processing techniques for each still images in a video.

In our video, we are concern with the diffusion of ink in water. Diffusion is the natural process of intermingling of the molecules of two substances. We are concerned with the area of the ink that is diffused in water.

Using the images below,

image 1

Finding the threshold of the image, using the image below

image 2

After finding the threshold, we can change the images to binary.

image 3

Our region of interest is the ink in the middle of the water. Finding the area of the ROI for each images by pixel counting. We can find the plot below

image 4

We will compare image 4 with the image below.

image 5

We will consider image 5 as the theoretical values for area. This plot is from 'Ink diffusion in water' by Lee S. et. al, 2004.

We can see that there is error in the area of the diffusion of ink in water. It is because of the other part of the images that is not part of the ROI but is still considered in pixel counting.

//code//
t=108/255;
c=[];
for i=1:9
im=imread('vid000'+string(i)+'.jpg');
imb=im2bw(im, t);
c(i)=sum(abs(1-imb));
end
for i=10:99
im=imread('vid00'+string(i)+'.jpg');
imb=im2bw(im, t);
c(i)=sum(abs(1-imb));
end
plot(c);

Acknowledgements:
Instru Lab- for the place
Gerold - for the code
Benj and Billy - for being my groupmates.. :)
http://mitgcm.org/eh3/Tracer_work/papers/ejp4_2_020.pdf

Grade: 10/10
because I think I did what is needed to do. :)

A16 – Color Image Segmentation

2008-09-02T08:59:00.011+08:00

In image segmentation, a region of interest (ROI) is picked out from the rest of the image such that further processing can be done on it. Selection rules are based on features unique to the ROI.

normalized chromaticity coordinates
- represent color space not by the RGB but by one that can separate brightness and chromaticity (pure color) information

Per pixel, let I = R+G+B. Then the normalized chromaticity coordinates are

We note that r+g+b = 1 which implies r,g and b can only have values between 1 and 0 and b is dependent on r and g since b = 1-r-g.from R G B, the color space has been transformed to r g I where chromatic information is in r and g while brightness information is in I.
Parametric vs Non-Parametric Probability Distribution Estimation

Segmentation based on color can be performed by determining the probability that a pixel belongs to a color distribution of interest.

The probability that a pixel with chromaticity r belongs to the ROI is then
Histogram backprojection

Histogram backprojection is one such technique where based on the color histogram, a pixel location is given a value equal to its histogram value in chromaticity space.

Using the image:
cropping an the image:
Thus, we will use the yellow ball as the ROI.

We will use to techniques.
Parametric:

Non-Parametric

Acknowledgements:

Mark Leo - for the help.

Grade:
10/10
- because I think I did what is needed to do. And I think the image is well segmented.

A15 – Color Image Processing

2008-08-28T10:50:00.012+08:00

A colored digital image is an array of pixels each having red, green and blue light overlaid in various proportions, Per pixel, the color captured by a digital color camera is an integral of the product of the spectral power distribution of the incident light source S(l), the surface reflectance r(l) and the spectral sensitivity of the camera h(l).

White Balancing
This setting allows the user to select the white balancing constants appropriate for the capturing conditions.

White Balance Settings
Daylight - not all cameras have this setting because it sets things as fairly ‘normal’ white balance settings.
Incandescent/ Tungsten - this mode is usually symbolized with a little bulb and is for shooting indoors, especially under tungsten (incandescent) lighting (such as bulb lighting). It generally cools down the colors in photos.
Flourescent - this compensates for the ‘cool’ light of fluorescent light and will warm up your shots.
Cloudy - this setting generally warms things up a touch more than ‘daylight’ mode.

There are two popular algorithms of achieving automatic white balance. The first is Reference White Algorithm and the second is the Gray World Algorithm.

In the Reference White Algorithm, you capture an image using an unbalanced camera and use the RGB values of a known white object as the divider.

In the Gray World Algorithm, it is assumed that the average color of the world is gray.

Using a cloudy white balance, the color of the original image is yellowish. Using reference white, the image became whiter. And when we use gray world, the image is also whiter than the original but it is darker than the image using reference white.

Using an incandescent white balance, the image is bluish in color. Using reference white, the image became whiter and brighter than the original. Using gray world, the image is darker but whiter than the original.

Using daylight settings, the image became whiter in the reference white than the gray world. It also becomes brighter using reference white.

Using flourescent white balance. The image become white using both reference white and gray world. But i think it is brighter using gray world.
Using incandescent white balance, the image is bluish. After implementing reference white, the color of the leaves became green and the paper became white. After implementing gray world, the leaves became green, and the paper is close to gray.

I think that the reference white algorith is better than the gray world because of the results in the images.

-- code --
//white balance

stacksize(20000000);
image = imread('rix.jpg');
im = imread('rix-white.jpg');

RW = mean(im(:,:,1));
GW = mean(im(:,:,2));
BW = mean(im(:,:,3));

new = zeros(image);
new(:,:,1) = image(:,:,1)./RW;
new(:,:,2) = image(:,:,2)./GW;
new(:,:,3) = image(:,:,3)./BW;

maxall = max(max(max(new)));
newim = new./maxall;

imwrite(newim,'rix-new-white.jpg');

//gray world

stacksize(20000000);
image = imread('rix1.jpg'C/3B
new = zeros(image);

new(:,:,1) = image(:,:,1)./mean(image(:,:,1));
new(:,:,2) = image(:,:,2)./mean(image(:,:,2));
new(:,:,3) = image(:,:,3)./mean(image(:,:,3));

maxall = max(max(max(new)));
newim = new./maxall;

imwrite(newim,'rix1-new-gray.jpg');

Acknowledgements
Activity 15 manual
http://digital-photography-school.com/blog/introduction-to-white-balance/

Benj - for the help with the codes

Grade:
10/10
- because I think I implemented the algorithms well. The color of the images were improved. :)

A14 – Stereometry

2008-08-26T08:46:00.004+08:00

Objective: To reconstruct a 3D object.

Stereo imaging is the technique we will use in this experiment and it is inspired by how our two eyes allow us to discriminate depth.

A13 – Photometric Stereo

2008-08-07T09:26:00.007+08:00

We can estimate the shape of the surface by capturing multiple images of the surface with the sources at different locations. The information about the surface will be coded in the shadings obtained from the images.

Let there be N sources in 3-d space. We can define a matrix
where each row is a source, each column is the x,y,z component of the source.

Procedure:
1. Load the matlab file photos.mat which contains 4 images I1, I2, I3,
and I4. The images are synthetic spherical surfaces illuminated by a far
away 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}
Use loadmatfile in Scilab.

Sperical surfaces
2. Compute the surface normals using Equation 10 and 11.

Equation 10

To get the normal vector we simplify normalize g by its length

Equation 11

3. From the surface normals compute the elevation z=f(u,v) and display a 3D plot of the object shape.
Once the surface normals (nx, ny, nz) are estimated using photometric stereo, they are related to the partial derivative of f as
The surface elevation z at point (u,v) is given by f(u,v) and is evaluated by a line integral

This is the resulting image.
--
codes
loadmatfile('Photos.mat',['I1','I2','I3', 'I4']);
scf(1)
subplot(141);imshow(I1,[]);
subplot(142);imshow(I2,[]);
subplot(143);imshow(I3,[]);
subplot(144);imshow(I4,[]);

V = [0.085832 0.17365 0.98106; 0.085832 -0.17365 0.98106; 0.17365 0 0.98481; 0.16318 -0.34202 0.92542];
I = [I1(:)';I2(:)';I3(:)';I4(:)'];

g = inv(V'*V)*V'*I;
[A,B] = size(g);
for i=1:A;
for j=1:B;
c(j)=sqrt((g(1,j)**2)+(g(2,j)**2)+(g(3,j)**2));
c = c+ 0.000000001;
end
end

n(1,:) = g(1,:)./c';
n(2,:) = g(2,:)./c';
n(3,:) = g(3,:)./c';

dfx= -n(1,:)./(n(3,:)+0.000000001);
dfy= -n(2,:)./(n(3,:)+0.000000001);

imx = matrix(dfx,128,128);
imy = matrix(dfy,128,128);

fx =cumsum(imx,2);
fy =cumsum(imy,1);

Image = fx+fy;

mesh(Image)

Acknowledgements:
April, Lei, Mark Leo and Aiyin
- for helping me

Grade
10/10
-since I was able to find the correct 3D plot.

A12 – Correcting Geometric Distortions

2008-07-31T09:26:00.002+08:00

There are two types of geometric distortion.
1. pincushion - the image seems pinched in the middle and expanded in the boundaries.
2. barrel - the image seems bloated in the middle and pinched at the sides.

For this activity, we will use bilinear interpolation. "the graylevel v at an arbitrary location (x , y)
in the distorted image can be found using v (x , y )=ax+by+c xy+d.

We used a distored capiz window shown below,
I cropped the image
and using bilinear interpolation, the result is

Acknowledgements:

Activity 12 manual

Grade:
9/10 - because I think that even though I find an undistorted image. It is far from what is expected.

A11 – Camera Calibration

2008-07-30T13:18:00.022+08:00

An image is a projection of brightness values from surfaces existing in 3D world space to 2D sensor space. The aim of this activity is to be able to model the physical processes involved in the geometric aspects of image formation.

Procedure:
1.Mount a 3D calibration checkerboard (to be provided) onto a surface and steady your camera with a tripod. Take an image of the checkerboard.
2. Pick an origin and a right-handed coordinate system in the grid and measure coordinates of around 20 to 25 corners of the squares of the checkerboard pattern.

I picked 23 corners.
3.From the image of the same points, find their [xi,yi] coordinates in image space. Use locate to get the coordinates in the image figure window using a mouse.

we have two coodinates since the image is flat. We will have two equations.
The o subscript corresponds to the object and i subscript corresponds to image.
finding the coordinates of selected points.

4. From Lecture 2, rederive Equation 13 this time with the z or Z axis as the camera axis, and x,y as the planar coordinates. Using all the points you've selected, set up the left and right-hand side matrices in Equation 13. Compute the elements of the matrix A using Equation 15.

Equation 13.
Thus,
5. To verify if you got the calibration correctly, predict the image coordinates of some cornerpoints of the checkerboard which were not used in the calibration. Overlay the predicted cornerpoints on the image. Comment on the accuracy of your prediction.
I found out that the average error for yi is 0.016708 and for zi is 0.0045 . And I think it this is accurate.

Using points that are not used in finding a
average error:
yi = 0.013684
zi = 0.010258

I think this is still acccurate.

--------------------------------------------------------------------
codes

stacksize(20000000);
img = imread('rix.jpg');
imshow(img);
x = locate(23);

yi = [326.66667 357.77778 424.66667 300.22222b 356.22222 393.55556 497.77778 508.66667 491.55556 150.88889 217.77778 113.55556 183.55556 118.22222 185.11111 88.666667 301.77778 241.11111 32.666667 28 147.77778 336 326.66667];
zi = [340.44444 184.88889 251.77778 161.55556 111.77778 500.66667 328 550.44444 158.44444 331.11111 178.66667 461.77778 373.11111 194.22222 505.33333 58.888889 419.77778 295.33333 366.88889 564.44444 552 534.88889 265.77778];
xo = [0 0 0 0 0 0 0 0 0 5 3 6 4 6 4 7 0 2 8 8 5 0 0];
yo = [1 2 4 1 2 3 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 1 1];
zo = [7 3 5 2 1 11 7 12 3 7 3 10 8 4 11 1 9 6 8 12 12 12 5];

//finding a
for i = 1:length(xo)
O((2*i)+1) = [xo(i) yo(i) zo(i) 1 0 0 0 0 -(yi(i)*xo(i)) -(yi(i)*yo(i)) -(yi(i)*zo(i))];
O((2*i)+2) = [0 0 0 0 xo(i) yo(i) zo(i) 1 -(zi(i)*xo(i)) -(zi(i)*yo(i)) -(zi(i)*zo(i))];
I((2*i)+1) = yi(i);
I((2*i)+2) = zi(i);
end

a = inv(O'*O)*O'*I;

//prediction
for j = 1:length(xo)
yinew(j) = ((a(1,1)*xo(j))+(a(1,2)*yo(j))+(a(1,3)*zo(j))+a(1,4))/((a(3,1)*xo(j))+(a(3,2)*yo(j))+(a(3,3)*zo(j))+1);
zinew(j) = ((a(2,1)*xo(j))+(a(2,2)*yo(j))+(a(2,3)*zo(j))+a(2,4))/((a(3,1)*xo(j))+(a(3,2)*yo(j))+(a(3,3)*zo(j))+1);
end

Acknowledgements:
Activity 11 manual.

Beth, Aiyin, Lei
- for answering my questions

Grade :
10/10 because I think that my data is accurate and I did what the activity asked. :)

A10 – Preprocessing Handwritten Text

2008-07-22T17:55:00.016+08:00

In this activity, we will try to extract handwritten text from an imaged document with lines. In handwriting recognition, individual examples of letters must be extracted.

Procedure.
1. Download one of the images DSC00469.JPG or Untitled_0001.jpg.
2. Crop a portion of the image with handwritten text within lines in the form.

image 1

I cropped image 1 to

image 2 - cropped image

3. Remove the lines using image processing techniques.
To remove the horizontal lines we will use the filter below.

image 3 - filter

This filter is based on the fft of the cropped image which is shown in figure 4.

image 4 - fft of cropped image

Then we will filter the image by convolution,

image 5 - filtered image

4.Binarize the handwriting, clean the image and process such that each handwritten letter is one pixel thick.

image 6 - binarized image

image 7 - image after using opening operator

5. Use bwlabel to label each letter. Comment on the quality of your preprocessing.

image 8 - labeled image

code used:

im=imread('image.jpg');
img=imread('filter.jpg');
im = im2gray(im);
imf = im2gray(img);
ff1=fft2(im);
ff2=fftshift(imf);
imft=ff1.*ff2;
imshow(ff1);

//filtering the image
a=real(fft2(imft));
scf(1)
imshow(a,[]);

//binarize the image
b=im2bw(a, 127/255);//threshold from GIMP
c=1-b;
scf(2);
imshow(c,[]);

// structuring element
SE = ones(2,2)

//opening operation
d=erode(c,SE);
e=dilate(d,SE)
scf(3);
imshow(e,[]);

//label the image
f=bwlabel(e);
scf(4);
imshow(f,[]);

From the labeled image, the processed image is not that clear. :(

Acknowledgements:
Ed
- for the help

Grade:
10/10
- because I did my best and I was able to use what I learned in the activities before.

A9 – Binary Operations

2008-07-17T21:10:00.022+08:00

In image-based measurements, it is often desired that the region of interest (ROI) is made well segmented from the background either by edge detection or by specifying the ROI as a blob.

Binarizing an image simplifies the separation of background from ROI. However, the optimum threshold must be found by examing the histogram.

Procedure:
1. Cut the image in 256 x 256 subimages.

In my case, I have 12 subimages.

2. Find the threshold of the image.

3. Binarize the image

bw = im2bw(im, 0.84);
subplot(142)
imshow(bw, [])
xtitle('binary')

4. Closing operator - dilate then erode
//closing operator
SE = ones (4,4);
imdilatec = dilate(bw, SE);
imerodec = erode(imdilatec, SE);
subplot(143)
imshow(imerodec, [])
xtitle('closing')
Opening operator - erode then dilate
//opening operator
SE = ones (4, 4);
imerodeo = erode(bw, SE);
imdilateo = dilate(imerodeo, SE);
subplot(144)
imshow(imdilateo, [])
xtitle('opening')

* we will not use both operators, we will just choose which one will show a good image where the blobs are defined.

5.Use bwlabel to label each contiguous blob on the binarized image.
// Label every connected component with a unique number.
[L, n] = bwlabel(imdilateo);
// Shows each component with a different color
scf(1)
subplot(121)
imshow(imdilateo, [])
subplot(122)
imshow(L+1,rand(n+1,3));
xtitle('label')

6. Find the area
for i=1:n
[r,c] = find(L==i);
a=size(r);
area(i) = a(2)
end

One of the subimages is shown below:

subimage1

After finding the area by pixel counting, it will show this histogram(using Excel)
From the graph, it shows that the area of the blob is near 525-500. I only use the areas of the circle from 400 to 700 because I think that below 400, the circle is truncated and more than 700 there is overlapping of circles.

Verifying our assumption:

1. I find the diameter of the blob, using GIMP, the diameter is around 26 pixels. Hence, the radius is 13 pixels. Using the formula for circle, which is pi*(r^2), the area should be 531 pixels which is in the range.

2. Another method is to pixel count a blob, it is found that the area is around 537 pixels, which is still in the range.

3. We will get the mean and the standard deviation.
Mean: 527 pixels
Standard Deviation: 22 pixels
which is still in the range of the peak from the histogram.

Acknowledgements:
Lei
Beth
Aiyin
Ed
- for the help. :)

Grade:
10/10
because I did what is needed to do.

A8 – Morphological Operations

2008-07-15T21:25:00.025+08:00

Morphology refers to shape or structure. In image processing, classical morphological operations are treatments done on binary images, particularly aggregates of 1's that form a particular shape, to improve the image for further processing or to extract information from it. All morphological operations affect the shape of the image in some way, for example, the shapes may be expanded, thinned, internal holes could be closed, disconnected blobs can be joined. In a binary image, all pixels which are “OFF” or have value equal to zero are considered background and all pixels which are “ON” or 1 are foreground.

We will deal with two types of morphological operation, dilation and erosion.

and

The erosion operator is defined as

For this activity we will use 5 binary images.
1. square ( 50 x 50)
2.triangle (base = 50 , height = 30)
3. circle (radius 25)
4. hollow square (60×60, edges are 4 pixels thick)
5. plus sign (8 pixels thick and 50 pixels long for each line)

and we will use structuring element for dilation and erosion
1. 4×4 ones
2. 2×4 ones
3. 4×2 ones
4. cross, 5 pixels long, one pixel thick.

The algorithm for dilation is:

img = imread('filename.bmp');
SE = [1 1 1 1; 1 1 1 1; 1 1 1 1; 1 1 1 1];
SE2 = [ 1 1 1 1; 1 1 1 1];
SE3 = [ 1 1; 1 1; 1 1; 1 1];
SE4=[0 0 1 0 0; 0 0 1 0 0; 1 1 1 1 1; 0 0 1 0 0; 0 0 1 0 0];
im = dilate(img,SE);
im2 = dilate(img, SE2);
im3 = dilate(img, SE3);
im4 = dilate(img, SE4);
imwrite(im, 'filename1.bmp');
imwrite(im2, 'filename2.bmp');
imwrite(im3, 'filename3.bmp');
imwrite(im4, 'filename4.bmp');

Dilation:

The algorithm for erosion is

img = imread('filename.bmp');
SE = [1 1 1 1; 1 1 1 1; 1 1 1 1; 1 1 1 1];
SE2 = [ 1 1 1 1; 1 1 1 1];
SE3 = [ 1 1; 1 1; 1 1; 1 1];
SE4=[0 0 1 0 0; 0 0 1 0 0; 1 1 1 1 1; 0 0 1 0 0; 0 0 1 0 0];
im = erode(img,SE);
im2 = erode(img, SE2);
im3 = erode(img, SE3);
im4 = erode(img, SE4);
imwrite(im, 'filename1.bmp');
imwrite(im2, 'filename2.bmp');
imwrite(im3, 'filename3.bmp');
imwrite(im4, 'filename4.bmp');

Erosion:

Other morphological operations

thin - thinning by border deletion
use thin in the original square image.

skel - skeletonization, thinning, Medial Axis Transform

Acknowledgements:
Activity 8 Manual

BETH
JULIE
AIYIN
ANGEL
APRIL
- for helping me.

Grade:
10/10 - because sone of my predictions are right with the simulated image.

A7 – Enhancement in the Frequency Domain

2008-07-10T08:54:00.018+08:00

The Fourier Transform (FT) of a signal gives the spatial frequency distribution of
that signal. Essentially, the Fourier Theorem states that any image or signal can be
expressed as a superposition of sinusoids. Unique to the 2D FT (as compared to
the 1D FT) is the fact that rotation of the sinusoids result to the rotation of their
FT's.

For this activity we have three tasks:
A. Anamorphic Property of Fourier Transform
B. Ridge Enhancement
C. Line Removal

7A. A Anamorphic property of the Fourier Transform

Create a 2D sinusoid using Scilab in the X direction.

nx = 100; ny = 100;
x = linspace(-1,1,nx);
y = linspace(-1,1,ny);
[X,Y] = ndgrid(x,y);
f = 4;
z = sin(2*%pi*f*X);
imshow(z,[]);

The image is like a corrugated roof. The image is a sine function.

Then we will get the fourier transform of the image.

I = imread('roof.bmp');
Igray = im2gray(I);
FIgray = fft2(Igray);
imshow(fftshift(abs(FIgray)),[]);
xset("colormap", hotcolormap(255));

The image shows two dots at the center of the image.The dots represent the frequency of the sine function. There are no pixels in the x-direction, because the image is the same everywhere in that direction.

When we increase the frequency, we will see that

f = 10

We can see that the number of lines increases and the dots are near the edges of the image.

As the frequency increases, the dots go farther from each other.

When we create a 2-D sinusoid in the X- direction,the dots are in Y-direction.

Then we will rotate the sinusoid,

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

In the FT image, the dots are in the X- direction and the second dot is tilted, at the same degree as the sinusoid is rotated.

Using different values of theta

We will then create a pattern. I used the pattern given in the manual
z = sin(2*%pi*4*X).*sin(2*%pi*4*Y); this is a product of two corrugated roofs, one running in the X-direction, the other in Y.

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

We can see that the resulting image is a checkered black and white image. The image 2D cosine with both horizontal and vertical components. They have 4 cycles horizontally and vertically. And the FT image has for dots forming a square near the center of the image.

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

The dots in the FT image correspond to the frequency of the stripes in the original image.

Activity 7.B Fingerprints : Ridge Enhancement

For this activity, we will use fingerprint.

img = imread('finger.jpg');
scf(1)
imshow(img)
img = im2gray(img);
image =img-mean(img);
scf(2);
imshow(image);

im=fft2(image);

ff=real((im).*conj(im));
scf(3); imshow(fftshift(log(ff+1)),[]);
xset('colormap',jetcolormap(64));

//Transfer function
filter=mkfftfilter(image,'exp',30);
scf(4);
imshow(filter);

//High-pass filter
IM=im.*fftshift(1-filter);
IMAGE=real(fft2(IM));
scf(5); imshow(IMAGE);

scf(6);
imshow(abs(fftshift(fft2(IMAGE))), []);
xset('colormap', jetcolormap(64));

Using the image in the Activity 7 manual

Using my own image(c/0 Julie D.)

Activity 7.C Lunar Landing Scanned Pictures : Line removal
Using the same commands we used in the previous activity for getting the fft and using filters.

// getting the FT of original image
im = imread('moon.jpg');
imgray = im2gray(im); // convert to grayscale
Fimgray = fft2(imgray);// Fourier Transform
scf(1);
imshow(fftshift(abs(Fimgray)),[]);
xset("colormap", hotcolormap(255));// using colormap

// getting the enhanced image by filtering
b = imread('filter.jpg');
a= imread('moon.jpg')
bgray = im2gray(b);
agray = im2gray(a);
Fb = fftshift(bgray);
Fa = fft2(agray);
FRA = Fb.*(Fa);
IRA = fft2(FRA); //inverse FFT
FImage = abs(IRA);
imshow(FImage, [ ]);

The lines in the filter corresponds to the line in the original image which we want to remove.

Acknowledgements:
http://www.cs.unm.edu/~brayer/vision/fourier.html
http://student.kuleuven.be/~m0216922/CG/fourier.html

Julie D. - for the scanned fingerprint
Aiyin and Beth - for answering my questions

Grade:
10/10
- because I did what the activity asks to do.

A6 - Fourier Transform Model of Image Formation

2008-07-08T08:50:00.025+08:00

Activity 6.A – Familiarization with discrete FFT
First we made a 128 x 128 image of a circle using paint
Using scilab, we will convert the image to grayscale and apply Fourier transform.

im = imread('circle.bmp');
imgray = im2gray(im); // convert to grayscale
Fimgray = fft2(imgray);// Fourier Transform
scf(1);
imshow(abs(Fimgray),[]);
xset("colormap", hotcolormap(255)); // using colormap

applying fftshift

scf(2);
imshow(fftshift(abs(Fimgray)),[]);
xset("colormap", hotcolormap(255));// using colormap

The result is an airy disc.

applying Fourier transform again
scf(3);
imshow(abs(fft2(Fimgray)),[]);

The resulting image is the original image but the circle is shifted from the center to the left.

The next task is to apply the coomands to a letter A.

im = imread('A.bmp');
imgray = im2gray(im); // convert to grayscale
Fimgray = fft2(imgray);// Fourier Transform
scf(1);
imshow(abs(Fimgray),[]);
xset("colormap", hotcolormap(255)); // using colormap

applying fftshift

scf(2);
imshow(fftshift(abs(Fimgray)),[]);
xset("colormap", hotcolormap(255));// using colormap

applying Fourier transform again

scf(3);
imshow(abs(fft2(Fimgray)),[]);

The resulting image is an inverted letter A.
Activity 6.B Simulation of an imaging device.

I created an image "VIP" using paint.
This will be the "object".

Using the commands

b = imread('circle.bmp');
a= imread('vip.bmp')
bgray = im2gray(b);
agray = im2gray(a);
Fb = fftshift(rgray);
Fa = fft2(agray);
FRA = Fb.*(Fa);
IRA = fft2(FRA); //inverse FFT
FImage = abs(IRA);
imshow(FImage, [ ]);
xset("colormap", hotcolormap(255));

We will use different radii of circles. The circles will be the "lens".

radius 1:
The resulting image will be
radius 2:
The resulting image will be:

radius3:
The resulting image will be:
A smaller lens aperture will results in a blurred image. Comparing this with the bigger aperture, the image is sharper and most closely resembles the original.

Activity 6.C Template Matching using correlation

Template Matching is a pattern recognition technique suitable for finding exactly identical patterns in a scene such as in the case of finding a certain word in a document.

We made two images.
First, with the words "THE RAIN IN SPAIN STAYS MAINLY IN THE PLAIN."
Second, the letter A.

Using the commands
im = imread('rain.bmp');
img = imread('A2.bmp');
imgray = im2gray(im);
imggray = im2gray (img);
Fim = fft2(imgray);
Fimg = fft2(imggray);
FRA = Fimg.*conj(Fim);
IRA = fft2(FRA);
FImage = abs(IRA);
imshow(fftshift(FImage), [ ]);
xset("colormap", hotcolormap(255));

will produce the image below:

In the image, there are 5 dots which corresponds to the 5 A's in the sentence.
The A's are from words "rain", "spain", "stays", "mainly", "plain".

Activity 6.D Edge detection using the convolution integral
Edge detection can be seen as template matching of an edge pattern with an image

Using the commands,

hor = [-1 -1 -1; 2 2 2; -1 -1 -1]; //horizontal pattern
ver = [-1 2 -1; -1 2 -1; -1 2 -1]; //vertical pattern
spot = [-1 -1 -1; -1 8 -1; -1 -1 -1]; //spot pattern
pattern = spot;
vip = gray_imread('vip.png');
im = imcorrcoef(vip, pattern);
imshow(im);

The image that will appear in horizontal pattern is

For vertical pattern:
And for spot pattern:
The edges are more prominent depending on what kind of pattern the image was convolved with.

Acknowledgements:
Mark Leo
Aiyin
Beth
- for answering my questions

Grade: 10/10
because I know I did well and I did what the activity needed.

A5 – Physical Measurements from Discrete Fourier Transforms

2008-07-03T09:11:00.012+08:00

The activity for today is to create correct frequency scales for FFT patterns.

I. Generate a 1-D sinusoid of the form sin (2*pif t) specifying Δt, and N and the frequency f.
Using the commands:

T = 2 //total time the signal was sampled
N = 256 // total number of samples
dt = T/256 // sampling interval
t = [0:dt:(N-1)*dt];
f = 5
y = sin(2*%pi*f*t);//function
f1 = scf(1); plot(t,y);

This will give the plot below
II. Get the Fourier transform and compute the frequency scale
Using the commands:

FY = fft(y); // fourier transform
F = 1/(2*dt); // maximum frequency
df = 2*F/256; // discrete frequency in the FT domain
f = [-(df*(N/2)):df:df*(N/2 -1)]; //frequency

plotting the frequency and the shifted fft

f2 = scf(2);
plot(f, fftshift(abs(FY)));

gives the image below:
frequency: -4.5, -5.5, 4.5, 5.5
Note: x axis - frequency and y axis - shifted fft

In an image:
The Discrete Fourier Transform is given by:
In 2-D
IN DFT, the number of frequencies correponds to the number of pixels in the domain image.

The Fourier Transform is used to help us find the geometric characteristics of an image.
To use it in an image, we will use a grayscale image. Find its histogram and PDF. And then we will use the 2-D DFT to find the Fourier image. We will mainly used sine or cosine functions. After using DFT, the image is now decomposed to its sinusoidal components. Then we can find the frequency which corresponds to the number of pixels.

Questions:
a) Light from a fluorescent lamp is known to flicker at 120Hz. What should be the threshold sampling interval for accurate FT analysis?
using the formula:
where
Fmax is the maximun frequency = 120 Hz
We are looking for deltaT which is the threshold sampling interval.
Calculating, the threshold sampling interval is

b) What is the effect of increasing the number of samples N in the FT?

--> increasing the number of samples,increases the peaks.

Using N= 1000, the plot of the FT and frequencies will look like the image below
frequency: - 4.5, -5.5, 4.5, 5.5

c) What is the effect of decreasing the sampling interval Δt in the FT?

--> we can decrease the sampling interval by either increasing the number of samples or decreasing the total time or both. We saw that when the total time is decreased, the frequencies increased. Decreasing the time interval, doesn't affect the peaks of the plot. When we increased the number of samples, we increased the peaks. When we increased the number of samples and decreased the total time, the frequency and peaks increases.

Using T =1
N = 500
frequency: -5,-6, 5, 6

d) What is the effect of fixing the total time interval T but increasing the
number of samples N?

--> when the total time interval is fixed but the number of samples is increased, the peaks are increased.

Acknowledgements:
http://homepages.inf.ed.ac.uk/rbf/HIPR2/fourier.htm

BETH
AIYIN
- for helping me.

Grade:
10/10. because I think I answered all the questions.

A4 – Enhancement by Histogram Manipulation

2008-06-26T08:55:00.042+08:00

The task for this activity is to enhanced an image using histogram manipulation.

For this activity, we are asked to find grayscale images. I looked for an image in the web. The image is from: http://upload.wikimedia.org/wikipedia/commons/thumb/9/90/Face_sapa14.jpg/800px-Face_sapa14.jpg

To find the histogram of the image:

Change the directory where the image is saved.

img = imread('face.jpg');

// plot histogram
gsval=[];
pixelnum=[];
counter=1;
for i=0:1:255
[x,y]=find(img==i);
gsval(counter)=i;
pixelnum(counter)=length(x);
counter = counter+1;
end;
scf(1);
plot(gsval,pixelnum);
// puts the titles
xtitle( 'Histogram') ;

This will show

Note: x-axis is the grayscale values and the y-axis is the number of pixels.
It ii show in the histogram that the grayscale values is well spread in the image.

After finding the histogram, we can find the probability distribution function (PDF). PDF can be find by normalizing the pixel values of the histogram. After finding the PDF, we will find the cumulative distribution function (CDF).
To find the PDF (normalized histogram) and CDF
//plot PDF
a = gsval;
b = pixelnum;
c = size(img,1);
d = size(img,2);
e = c.*d
f = b/e;
scf(2);
plot(a,f);
g = cumsum(f);
xtitle ('Normalized Histogram')
Note: x-axis is the grayscale image and the y-axis is the normalized number of pixels.

//plot CDF
scf(3);
plot(a,g);
xtitle('CDF');

Note: x-axis is the grayscale values while y-axis is the cumulative sum of the normalized number of pixels.

________________________________________________________

Then the next thing to do is the Back Projection of the Image

//Back Projection
gray = [];
for ii = 1:1:size(img,1)
for jj = 1:1:size(img,2)
gray(ii,jj) = g(img(ii,jj));
end
end
imwrite(gray, 'gray.jpg');

After back projection,

Then we will find the histogram and the CDF of the new image.

// New Histogram
im = imread('gray.jpg');
gval=[];
pnum=[];
count=1;
for i=0:1:255
[x1,y1]=find(im==i);
gval(count)=i;
pnum(count)=length(x1);
count = count+1;
end;
scf(4);
plot(gval,pnum);
xtitle('Histogram');
Note: x-axis is the grayscale values and the y-axis is the number of pixels.

// New PDF and CDF
//plot PDF
h = gval;
i = pnum;
j = size(im,1);
k = size(im,2);
l = j.*k;
m = i/l;
plot(h,m);
xtitle('Normalized Histogram')

Note: x-axis is the grayscale image and the y-axis is the normalized number of pixels.

//plot new CDF
n= cumsum(m);
scf(5);
plot(h,n);
xtitle(' CDF');
Note: x-axis is the grayscale values while y-axis is the cumulative sum of the normalized number of pixels.

After finding the PDF and CDF of the new image. These plots show that the new image has a good contrast.

_________________________________________________________

The next task is to remap the CDF of the grayscale image to find the desired CDF.
I used the function
G = 0.5*[tanh(6*((Z-128)/255))+1] where Z = [0:255]
The graph of this function is our desired CDF
Applying the function by interpolation.

Z = [0:255];
G = tanh(6.*(Z-128)./255);
G = (G+1)/2;
A = interp1(a,g,img);
graynew = interp1(G,Z,A);

imshow(graynew, [0 255]);
The final image is
We then find the histogram, PDF and CDF using same commands we used in finding the histogram, PDF and CDF of the original image.
Histogram:
Note: x-axis is the grayscale values and the y-axis is the number of pixels.

PDF:
Note: x-axis is the grayscale image and the y-axis is the normalized number of pixels.

CDF:
Note: x-axis is the grayscale values while y-axis is the cumulative sum of the normalized number of pixels.

Comparing the three images:

The last image is darker than the other two but I think that the middle image has the best contrast. This is also based on the PDF and CDF of the images.

Acknowledgements:
Julie D.
Ed
Beth
Angel
Aiyin
for helping me and answering my questions.

Grade :
10/10, because I did my best and I enhanced the original image.

A3 - Image Types and Basic Image Enhancement

2008-06-24T11:05:00.009+08:00

PART 1
There are 4 types of images
1. True Color Image

photo from: www.cssnz.org/flower.jpg

Using the command in Scilab
--> imfinfo ('flower1.jpg')
shows the following results

File Name	flower1.jpg
File Size	3348
File Format	jpeg
Width	115
Height	118
Depth	8
Storage Type	truecolor
Number of Colors	0
Resolution Unit	centimeter
X Resolution	0
Y Resolution	0

Using the properties in Windows

Width	115
Height	118
Horizontal Resolution	96 dpi
Vertical Resolution	96 dpi
Bit Depth	24

2. Gray Scale imagephoto from: digital-photography-school.com

Using the command in Scilab
--> imfinfo ('flower2.jpg')
shows the following results

File Name	flower2.jpg
File Size	4225
File Format	JPEG
Width	120
Height	120
Depth	8
Storage Type	indexed
Number of Colors	256
Resolution Unit	inch
X Resolution	76
Y Resolution	76

Using the properties in Windows

Width	120
Height	120
Horizontal Resolution	72 dpi
Vertical Resolution	72 dpi
Bit Depth	8

3.Indexed Imagephoto from:www.digitalphotoartistry.com/rose1.jpg

Using the command in Scilab
--> imfinfo ('flower3.bmp')
shows the following results

File Name	flower3.bmp
File Size	16306
File Format	bmp
Width	106
Height	141
Depth	8
Storage Type	indexed
Number of Colors	256
Resolution Unit	centimeter
X Resolution	28.350000
Y Resolution	28.350000

Using the properties in Windows

Width	106
Height	141
Bit Depth	8

4. Binary Imagephoto from:www.botany.com

Using the command in Scilab
--> imfinfo ('flower4.bmp')
shows the following results

File Name	flower4.bmp
File Size	1550
File Format	bmp
Width	124
Height	93
Depth	8
Storage Type	indexed
Number of Colors	2
Resolution Unit	centimeter
X Resolution	28.350000
Y Resolution	28.350000

Using the properties in Windows

Width	124
Height	93
Bit Depth	1

PART 2:
This part of the activity is concerned with our scanned image.
Cambodian money( c/o Anthony Amarra)
I cropped the image so that the rulers will not be included in reading the area of the scanned image.

Using
-->image = imread('gray2.jpg');
-->imfinfo('gray2.jpg')
shows the following properties
FileName: gray2.jpg

FileSize: 20680
Format: JPEG
Width: 422
Height: 201
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: inch
XResolution: 96.000000
YResolution: 96.000000

Using the command
-->histplot ([0:1:255], image)
We find the histogram of the image
From the histogram we can say that the image is low in contrast.
We can also check the histogram and threshold by using imageJ.
We can also find the histogram using the following commands:
-->gsval=[]
-->pixelnum=[]
-->counter=1;
-->for i=0:1:255
-->[x,y]=find(image==i);
-->gsval(counter)=i;
-->pixelnum(counter)=length(x);
-->counter = counter+1; -->end;
-->plot(gsval,pixelnum);
This will show the image below:

Using the histogram, i find the best threshold is at 189 or 74.117647% of 255. I used this threshold to convert the image to binary
-->bw = im2bw(image,0.74117647);
--> imshow(bw,2)
It shows the image below
Inverting the image using the commands,
--> binary = abs(bw-1); --> imshow (binary)
shows the image below:

Using the commands, in the previous activity, to find the area
-->[x,y] = follow(binary);
-->size(x)
ans =
924. 1.
-->size(y)
ans =
924. 1.
-->x_2(1) = x(924) ;
-->x_2(2:924) = x(1:923);
-->y_2(1) = y(924) ;
-->y_2(2:924) = y(1:923);
-->area=0.5*sum(x.*y_2-y.*x_2);
--> Area = abs(area)
Area =
84200.

The experimental value for area is 84200 square pixels.
The theoretical value for area is ( 419 x 199) 83381 square pixels. This can be solve by pixel counting
The percent error is 0.9822%.

Acknowledgments:
JULIE D.
ED
BETH
AIYIN
- for answering some of my questions

JORGE
- for the histplot
JERIC
- for the histogram code

GRADE:
10/10 because I did my best in this activity and the error is acceptable.

A2 = Area estimation of images

2008-06-19T10:58:00.005+08:00

Using the sip toolbox in the scilab program, we have can view images.

We open the scilab program then we open the sip toolbox but we encounter error in the imagemagick path so we type command so that we can use sip toolbox.
The commands used are:
chdir(ImageMAgickPath); link(CORE_RL_Magick_.dll);
after entering this command, we can use the sip toolbox.

I first studied how to insert images in the sip toolbox. I first changed the directory using the command
chdir ('C:\Documents and Settings\AP186user13\My Documents\My Pictures').
After changing the directory, I can now read the image using sip tool box.
To read the image, I used the commands
-->image = imread('square.bmp');
-->xbasc(); imshow(image);
Then, the image is shown in the sip graphic window. This image(which is binary) will appear
Now, i am ready to use "follow" and find the area of the image using scilab.
I enter the following commands to find the area of the square.
--> [x,y] = follow(image);
--> size(x);(the size of x is 584)
--> size(y); (the size of y is 584)
--> x2(1) = x(584) ;
--> x2(2:584) = x(1:583);
-->y2(1) = y(584) ;
-->y2(2:584) = y(1:583);
--> area=0.5*sum(x.*y2-y.*x2);
area = 21316.
The dimensions of the square is 148x148. Therefore the theoretical value of the square is 21904.
The error from the value at the scilab to the value of the theoretical is 2.69%.

For the second, rectangleUsing the same commands as the square,
-->image = imread('rectangle.bmp');
-->xbasc(); imshow(image);
--> [x,y] = follow(image);
--> size(x);(the size of x is 510)
--> size(y); (the size of y is 510)
--> x2(1) = x(510) ;
--> x2(2:510) = x(1:509);
-->y2(1) = y(510) ;
-->y2(2:510) = y(1:509);
--> area=0.5*sum(x.*y2-y.*x2);
area = 14534.
we find the scilab value of area to be 14534 and the theoretical to be 14960. Therefore the error is 2.84%.

For the third image,
Using the same commands.
-->image = imread('circle.bmp');
-->xbasc(); imshow(image);
--> [x,y] = follow(image);
--> size(x);(the size of x is 548)
--> size(y); (the size of y is 548)
--> x2(1) = x(548) ;
--> x2(2:548) = x(1:547);
-->y2(1) = y(548) ;
-->y2(2:548) = y(1:547);
--> area=0.5*sum(x.*y2-y.*x2);
area = 29477
The scilab value of area is 29477. While the theoretical(having a radius of 97) is 29599. The error is 0.02%.

Acknowledgements...
Beth, for answering all my questions...
Lei, for helping me with the commands...

I will give myself a grade of 10/10.

Good day.

A1-Digital Scanning

2008-06-12T09:04:00.003+08:00

Using the scanned handwritten graph found in the College of Science Library.
from

Title: Electrolytic Determinations & Separations with the Use of a Rotating Anode.

Reference: J. Langness, The Journal of the American Chemical Soc. 29, 459-472 (1907). For x-axis, the major grid is 2 and for the y-axis the major grid is 0.05.

I have found out that the pixel values for x and y are 60.75 and 58.16667 respectively. Finding the pixel locations of each point including the origin we have found the following data.

The second and third columns are the pixel locations of the data points. The fourth and fifth columns are the points when the pixel location of a data is subtracted to the pixel location of the origin. However, in the x-axis I use the absolute value.
The last two columns are the ratio of the x and y. We multiply the value of the major grid to the value of the pixel location and divide it by the pixel value. For example, data point 1(x-axis)

(2*30)/60.75 = 0.987654

Finding the ratio for all points in x and y and plotting it in excel.
Comparing the two graphs,

I have found out that the graphs are almost the same. But because of human error of looking at the exact value of the data points, the graph will look like this.

I made some errors but I still did my best so I will give myself 10/10...

Credits to:

Elizabeth Ann Prieto for scanning the images and for answering some of my questions... :D
Good day.. :)