Image Processing

A20 - Neural Networks

2008-10-05T18:21:00.000-07:00

Neural network is a mathematical model that mimics brain function. It is made up of interconnecting artificial neurons (programming constructs that mimic the properties of biological neurons) in a similar manner shown below.

http://upload.wikimedia.org/wikipedia/en/thumb/1/1d/Neural_network_example.png/180px-Neural_network_example.png

In this activity, we use neural networks as a method to classify objects into classes depending on the extracted features. We again use pillows and kwek-kwet data set from activity19. The features used are ROI pixel area, length-to-width ratio, average red component (NCC) and average green component (NCC).

A code was already prepared by Jeric Tugaff and was only modified for this activity's purpose. The values used are as 4 input feature vectors (normalized between 0-1) both from 4 training objects for each class and 4 test objects for each class.

The neural network is trained using the training set. The code is expected to output values close to

[0 0 0 0 1 1 1 1]

meaning the first four test object will be classified as belonging to the pillows class and the second set of test objects will be classified under the kwek-kwek class. The output is as follows. From this table, 100% classification of the test objects is obviously obtained.

//code
chdir('C:\Documents and Settings\VIP\Desktop\ap186\A20');

training = fscanfMat('training.txt');
test = fscanfMat('test.txt');

//training
mntr = min(training, 'c');
tr2 = training - mtlb_repmat(mntr, 1, 8);
mxtr = max(tr2, 'c');
tr2 = tr2./mtlb_repmat(mxtr, 1, 8);

//test
mnts = min(test, 'c');
ts2 = test - mtlb_repmat(mnts, 1, 8);
mxts = max(ts2, 'c');
ts2 = ts2./mtlb_repmat(mxts, 1, 8);

tr_out = [0 0 0 0 1 1 1 1];
N = [4, 10, 1];
lp = [0.1, 0];
W = ann_FF_init(N);

T = 400;
W = ann_FF_Std_online(tr2,tr_out,N,W,lp,T);
//x is the training t is the output W is the initialized weights,
//N is the NN architecture, lp is the learning rate and T is the number of iterations

// full run
ann_FF_run(ts2,N,W) // classification output

//end code

---
Thanks Jeric Tugaff for helping me understand how neural network works and for helping me with the program.

---
Rating 7/10 since I implemented the program correctly but was very dependent on Jeric's tutorial and discussion. :)

A19 - Probabilistic Classification

2008-09-20T18:15:00.000-07:00

Linear discriminant analysis is a classification technique by which one creates a discriminant function from predictor variables.

In discriminant analysis, there is a dependent variable (Y) which is the group and the independent variables (X) which are the object features that might describe the group. If the groups are linearly separable, then we can use linear discriminant analysis. This method suggests that the groups can be separated by a linear combination of features that describe the objects.

In this activity, i used LDA to classify pillows (chocolate-coated snack) and kwek-kwek (orange, flour-coated quail egg) based on the features such as pixel area, length-to-width ratio, average red component (NCC), and average green component (NCC).

Images of the two samples were taken using Olympus Stylus 770SW. The images are then white balanced using reference white algorithm with the white tissue as the reference. This is to maintain uniform tissue color in each of the images. The images are then cut such that a single image contains a single sample. Features are then extracted from each of the cut images in the same manner as the previous activity.

The data set is again divided into training and test sets, with the first four images of each sample comprising the training set while the last four images for the test set.

Following the discussion and equations from Pattern_Recognition_2.pdf by Dr. S. Marcos, I computed the following values.

An object is assigned to a class with the highest f value. As can be seen from the table below, most of group 1 (pillows) have higher f1 values while those in group 2 (kwek-kwek) have higher f2 values. 100% classification is obtained.

---
//code

TRpillow=fscanfMat('TrainingSet-Pillows.txt');
TSpillow=fscanfMat('TestSet-Pillows.txt');

TRkwek=fscanfMat('TrainingSet-Kwekkwek.txt');
TSkwek=fscanfMat('TestSet-Kwekkwek.txt');

TRpillow=TRpillow';
TSpillow=TSpillow';
TRkwek=TRkwek';
TSkwek=TSkwek';

TRpilmean=mean(TRpillow,1);
TRkwekmean=mean(TRkwek,1);

globalmean=(TRpilmean+TRkwekmean)/2;
globalmean=mtlb_repmat(globalmean,4,1);

TRpillow=TRpillow-globalmean;
TRkwek=TRkwek-globalmean;

c_pil=((TRpillow')*TRpillow)/4;
c_kwek=((TRkwek')*TRkwek)/4;

C=((4*c_pil)+(4*c_kwek))/8;
P = [0.5;0.5];
for i=1:4
f1(i) = (TRpilmean*inv(C)*(TSkwek(i,:)'))-((0.5)*(TRpilmean)*inv(C)*(TRpilmean')+log(P(1)));
f2(i) = (TRkwekmean*inv(C)*(TSkwek(i,:)'))-((0.5)*(TRkwekmean)*inv(C)*(TRkwekmean')+log(P(2)));
end

//end code

---
Thanks Jeric Tugaff for the tips and discussions and Cole Fabros for the images of the sample.

---
Rating 8.5/10 since I implemented and understood the technique correctly but was late in posting this blog entry.

A18 - Pattern Recognition

2008-09-15T19:27:00.000-07:00

Pattern recognition, as a subtopic of machine learning, aims to classify data according to a statistical information extracted from its patterns.

A pattern is usually a group of measurements or observations extracted from the data set. In essence, a pattern is a set of quantifiable features. These features are then arranged into an ordered set to define a feature vector. Feature vectors, then, define the grouping of the data into classes.

In pattern recognition, the specific goal is to decide if a given feature vector belongs to one of the several classes.

In this activity, we aim to classify a set of images into one of the four classes - kwek-kwek (orange, flour-coated quail egg), squid balls, piatos potato chips, pillows (chocolate coated snack).

Images of the four samples were taken using Olympus Stylus 770SW. The images are then white balanced using reference white algorithm with the white tissue as the reference. This is to maintain uniform tissue color in each of the images. The images are then cut such that a single image contains a single sample.

FEATURE VECTOR
For each of the individual sample, the features extracted are as follows:
1. pixel area
2. length-to-width ratio
3. average red component (NCC)
4. average green component (NCC)

To get the pixel area, the sample images were first binarized to separate ROI from the background. Closing operation is then performed on the binarized images to reduce effect of poor thresholding. The pixel area is then equal to the sum of the (binarized then closed) image.

Length-to-width ratio is computed as the maximum filled pixel coordinate along the x-axis minus the minimum filled pixel coordinate along x-axis divided by its y-axis counterpart.

The average red component and green component is obtained from the ROI only using Normalized Chromaticity Coordinates.

The following table summarizes the features extracted for all the sample images.

MINIMUM DISTANCE CLASSIFICATION
The data set is divided into two - training and test sets. The training set is composed of the first four images from each classes while the test set are the last four images for each sample.
(Note: Pixel Area was first normalized before subjecting to minimum distance classification.)

To facilitate classification of the test images into one of the four classes, we use minimum distance classification.

This is done by getting the mean feature vector from the training set for each class. Therefore, we get the mean of the training set by getting the mean pixel area, mean L/W, mean r, mean g for each of the four classes.

Classification is done by getting the Euclidean distance of an unknown feature vector from the mean feature vector of each class. The unknown feature vector then belongs to the class with which it has the smallest distance.

In this activity, we use the test set to check for the validity of minimum distance classification as a pattern recognition algorithm. The following results were obtained.

From the matrix above, it is shown that among the 16 samples of the test set, only 1 was misclassified as belonging to another class.

---
Thanks Benj for the discussions with regards to this activity and Cole for the sample images.

---
Rating: 8.5/10 since I implemented the task correctly but was late in posting this blog entry.

A16 - Color Image Segmentation

2008-09-01T23:42:00.000-07: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.

In this activity, we use color as a feature for segmenting images. To do so, we first transform the color image's RGB into rgI. rgI is part of the normalized chromaticity coordinates or NCC color space. This color space separates chromaticity (r g) and brightness (I) information.

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

r = R/I
g = G/I
b = B/I

---

*http://images.replacements.com/images/images5/china/H/homer_laughlin_fiesta_shamrock_green_mug_P0000201549S0044T2.jpg

---
Parametric Probability Distribution

Segmentation based on color can be performed by determining the probability that a pixel belongs to a color distribution of interest. This implies that the color histogram of the region of interest must first be extracted. To do so, one crops a subregion of the ROI and compute the histogram from it. The histogram when normalized by the number of pixels is already the probability distribution function (PDF) of the color. To tag a pixel as belonging to a region of interest or not is to find its probability of belonging to the color of the ROI. Since our space is r and g we can have a joint probability p(r) p(g) function to test the likelihood of pixel membership to the ROI. We can assume a Gaussian distribution independently along r and g, that is, from the r-g values of the cropped pixel we compute the mean μr , μg and standard deviation σr , σg from the pixel samples. The probability that a pixel with chromaticity r or g belongs to the ROI is then

The joint probability is just the product of p(r) and p(g).

Shown below is the cropped region of the colored image, wherein we get the mean and standard deviation for both r and g so as to get the probability that a certain pixel belongs to the ROI.

We perform this over all pixels and plot the probability that a pixel belongs to our ROI.
Here's the distribution

And here's the segmented image, wherein the white parts corresponds to the pixels belonging to the ROI according to our Gaussian PDF.

---

Nonparametric Segmentation (Histogram Backprojection)

In non-parametric estimation, the histogram itself is used to tag the membership of pixels. 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.

Here's the histogram used

and the corresponding segmented image

Nonparametric image segmentation produced better results as compared to the parametric segmentation. Also, in nonparametric segmentation, we never assumed normality of distribution of the r and g, thus, this method is more accurate as compared to parametric segmentation.

---
Reference:
Activity 16 Lecture Handouts by Dr. Maricor Soriano.

---
Thanks to Ed for the valuable discussions and arguments with regards to the technique.

---
I give myself a 10 for I implemented image segmentation quite well. :)

A15 - Color Image Processing

2008-08-28T04:35:00.000-07: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(λ), the surface reflectance r(λ) and the spectral sensitivity of the camera η(λ).

Each pixel in a color image has R, G, B values, each of which has a balancing constant equal to the inverse of the camera output when the camera is shown a white object. This balancing constant is implemented through white balancing algorithm of a digital camera.
At its simplest - the reason we adjust white balance is to get the colors in your images as accurate as possible.*

More on white balancing at this link. *

---

The following images shows the effect of changing white balance on camera settings

WB: auto

sunny and cloudy settings

fluorescent and tungsten settings

From these images, we can obviously account that white doesn't appear white especially in tungsten settings. We therefore correct this image using the two algorithms we describe below.

---

AUTOMATIC WHITE BALANCING ALGORITHMS

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. Gray is part of the family of white, as is black. Therefore, if you know the RGB of a gray object, it is essentially the RGB of white up to a constant factor. Thus, to get the balancing constants, you take the average red, green and blue value of the captured image and utilize them as the balancing constants.

original image (tungsten WB)

reference white algorithm

gray world algorithm

As can be seen from the images, the reference white is superior in terms of image quality. This is because in gray world algorithm, averaging channels puts bias to colors that are not abundant.
---

We also test this algorithm for an image with objects of the same hue.

original image (green objects under tungsten WB settings)

reference white algorithm

gray world algorithm

In these images, we see that the gray world algorithm is superior in terms of producing accurate colors. The green objects looks more green than in the reference algorithm.

---
Note: All images may look dark. This is because I used 0.7 exposure value to avoid saturation of images after processing them.

I give myself a 10 for I implemented the algorithms correctly. :)

---
Thanks to VIP's digital SLR camera. *nakisingit po ako sa experiment ni Ate Loren.*

A14 - Stereometry

2008-08-25T18:06:00.000-07:00

Stereometry is another 3D reconstruction algorithm based on the human eye perception of depth. We perceive depth by viewing the same object at two different angles (two eyes separated by some distance).

In this activity, we explore how stereometry works. We try to reconstruct a 3D object using 2 images of taken by the same camera at the same distance z from the object but with a different x position (assuming x is the parallel axis between the camera and the object).

From this diagram, by simple ratio and proportion, depth z is perceived using the relation

(1)

If done on several points, we can reconstruct the 3D surface of the object.

The sample I used is a rubik's cube shown below with the tsai grid. (b=50mm, refer to diagram)

The camera used was first calibrated to get its internal parameter f (focal length). From the a's calculated using Activity 11 – Camera Calibration, matrix A is formed by recasting the a's. We then get the values of matrix A(1:3,1:3) and factorize this using RQ factorization, to get upper diagonal matrix K. (Note: Ensure that the factorized A(3,3) element is 1 by dividing the matrix by K(3,3)). The K-matrix obtained is shown below.

Knowing that K is just

and
we now have a value for focal length f (let kx=1);

We then get z values (using the equation 1) for different points on the object (purple dots).

Reconstruction was done using Matlab's griddata instead of SciLab's splin2d because of the latter's initial requirement of increasing values for both x and y image coordinates. Matlab's griddata function, however, works well for random values of x and y image coordinates.

Reconstruction of the rubik's cube is shown below.

It may not seem obvious but the reconstruction obtained the general height difference of the points selected. The edges are not defined but it somehow approximates the shape of the rubik's cube.

---
Thanks Cole for helping me with the images and JC for the discussions with regards to reconstruction.

---
Rating 6/10 since
1. reconstruction is not that good
2. I used Matlab in reconstruction rather than SciLab
3. I posted this blog very late.

A13 - Photometric Stereo

2008-08-06T21:35:00.001-07:00

Photometric stereo is an algorithm for obtaining local surface orientation by using several images of a surface taken under different illumination conditions with the camera viewpoint held fixed.

The technique assumes that intensity I captured by camera at point (x,y) is directly proportional to brightness of surface at that point. This also assumes that light rays arriving on the surface are parallel. Shape of the surface is estimated from the multiple images and the information about the surface is coded in the shadings obtained from the images.

In this activity, we use Photometric Stereo technique to obtain a 3D reconstruction from 2D images. The input images are shown below.

The intensity at each point is denoted in matrix form as

Knowing the light source directions (V) for each of the input images (I), we use the equation below to solve for g.

From the computed values of g (a 3 row matrix corresponding to the xyz locations), we get a normal vector by dividing each element in a column with the magnitude of that column. After this, a linear integral was used to obtain the z values. Plotting z with a 128x128 plane yields the following 3D reconstruction.

---
Rating: 10/10 for the accurate reconstruction of the shape of the input images using the algorithm

A11 - Camera Calibration

2008-07-30T16:42:00.000-07:00

In this activity we model the geometric aspects of image formation to recover information that was lost in the process of projecting brightness values from surfaces existing in 3D world space to 2D sensor space.

To do this, we first take a picture of a checkerboard pattern known as Tsai Grid.

Using SciLab's locate function, we selected 25 points on this image to get the pixel value of these points. We also take note of the real world coordinates of these points by letting the left side of the board to be the x-axis, the right side as the y-axis and the vertical as the z-axis. Each square has a side length of one inch. The origin is shown in pink below.

The green dots are the 25 points we've selected for our calibration. Next, we set up the matrix Q shown by equation below for values of i from 1 to 25. (i stands for image coordinate, o for real world object coordinate)

We then solve for a using equation below.

The resulting values of matrix a can then be used in the following equations to get the resulting 2D image coordinate by knowing the real world coordinates of the point. (a_34 is set to 1)

Implementing this method:

Real world coordinates of the green dots:
1. (8,0,12)
2. (6,0,10)
3. (2,0,10)
4. (4,0,9)
5. (6,0,8)
6. (6,0,3)
7. (4,0,2)
8. (2,0,3)
9. (6,0,5)
10. (4,0,3)
11. (0,8,12)
12. (0,5,10)
13. (0,2,10)
14. (0,5,8)
15. (0,3,7)
16. (0,5,4)
17. (0,7,2)
18. (0,2,1)
19. (0,3,3)
20. (0,5,1)
21. (0,0,1)
22. (0,0,3)
23. (0,0,5)
24. (0,0,6)
25. (0,0,11)

Corresponding Image Coordinates (Pixel Value)

point	y_image	z_image
1	23.214286	235.11905
2	53.571429	200
3	108.33333	205.35714
4	82.738095	185.11905
5	54.761905	163.09524
6	57.738095	73.214286
7	85.714286	63.095238
8	110.11905	86.904762
9	55.952381	108.92857
10	85.119048	80.357143
11	246.42857	236.90476
12	201.19048	202.38095
13	159.52381	205.95238
14	201.19048	166.66667
15	172.61905	152.97619
16	199.40476	80.357143
17	227.97619	55.952381
18	159.52381	55.357143
19	172.02381	85.119048
20	198.80952	45.238095
21	133.92857	60.714286
22	134.52381	92.261905
23	133.92857	125
24	133.33333	141.07143
25	132.7381	224.40476

Resulting matrix a

-13.2561
9.736856
-0.88994
134.7117
-4.07642
-4.2728
15.07773
45.71427
-0.01371
-0.01504
-0.00559

New image coordinates after using the matrix a

point	y_new	z_new
1	21.842763	235.67576
2	53.69017	199.59722
3	108.32033	205.44708
4	82.330771	184.49906
5	55.041758	162.50365
6	58.274085	73.794279
7	85.553674	63.772888
8	110.40641	86.620738
9	57.005504	108.60976
10	85.109881	80.396867
11	248.48566	236.84126
12	200.81792	201.5441
13	158.94669	205.61779
14	200.29104	164.72204
15	172.19655	151.17308
16	199.27642	93.813046
17	227.597	52.018523
18	158.96577	54.178965
19	171.88968	83.28296
20	198.54783	42.893636
21	134.57351	61.133497
22	134.29241	92.497568
23	134.00484	124.58259
24	133.85857	140.90327
25	133.10108	225.42079

Getting the difference between these computed values with the actual values gives the following mean values for each coordinate:
y: 0.474705
z: 1.365954

-o0o-
Collaborator: Cole Fabros

-o0o-
Grade: 10/10 since I implemented the camera calibration well, and that the mean difference for each axis is within one pixel. :)

A10 – Preprocessing Handwritten Text

2008-07-22T19:03:00.000-07:00

In this activity we tried to extract handwritten text from an imaged document with lines. The image I used is shown below.

To remove the lines, I first obtained the FFT of this image.

The lines in the image are frequent, therefore, we can conclude that to remove the lines we need to suppress the frequencies that correspond to these lines.

The enhanced image after working on the Fourier space is shown below.

We then binarized this image for further cleaning process.

The image below is a result of performing opening operation on the binary image.

I repeated the same opening operation on the image, ad this results to the following image.

In both opening operations, the resulting image shows no success. The text are not readable. Part of the lines were even enhanced.

-o0o-
Thanks Ed for pointers and help in GIMP.

-o0o-
Rating: 5/10 since I was only able to remove the lines from the original image and that I wasn't successful in extracting the text from the image. The resulting image was also very dirty.

A9 - Binary Operations

2008-07-21T07:21:00.000-07:00

The goal for this activity is to integrate everything we have learned so far to determine the best estimate of area (in pixel count) of simulated “cells”. We will also learn to use more morphological operators for enhancing and analyzing binarized images.

CLOSING and OPENING Morphological Operations
Opening is defined as an erosion followed by a dilation using the same structuring element for both operations. The basic effect of opening is somewhat like erosion in that it tends to remove some of the foreground (bright) pixels from the edges of regions of foreground pixels, but is less destructive. ***

Closing is defined as a dilation followed by an erosion using the same structuring element for both operations. Closing is similar in some ways to dilation in that it tends to enlarge the boundaries of foreground (bright) regions in an image (and shrink background color holes in such regions), but it is less destructive of the original boundary shape. ***

Getting Cell Area

The above image was first sampled by cropping 256x256 images. This was done because of two reasons. One is to save memory space since working with large images correspond to larger memory and two is to obtain an accurate value for the cell area by sampling on different regions of the image.

Below is a 256x256 cropped image. We first binarized this image to simplify the separation of background from region of interest (ROI). The optimum threshold can be found by examining the histogram of this image.

The binarized image is shown below.

Performing OPENING on the image results to the following image. The white pixels which are part of the background were removed.

Performing CLOSING operation results to the image below. Separation of touching blobs were observed.

We then use bwlabel function in SciLab to returns an image matrix which is of the same size as the original image but now containing labels for the connected objects in it. From this matrix, we can get the area of the cells since the each blob is a set of connected pixels.

We repeated the above procedures for different sample images and obtained a histogram of the cell area.

From this histogram, we can deduce that the pixel area of a cell in the image has a value between 500-550 pixels. Reducing the x-axis to 450-550 pixels shows the following histogram. This was done to limit the calculated area to those that best represents the cell area, since bins with smaller values can be accounted to small connected components, which is unlikely area of the cell.

We then get the mean and the standard deviation of the cell area obtained. The values were
area = 521.84444 pixels
std dev = 20.685915

We then checked if this values are correct. This was done by getting the cell area from an image with separated cells.

The values obtained are as follows
544.
527.
518.
535.
530.

Clearly, these values lie within the acceptable limit for the calculated area of the cell. The mean value obtained is thus correct. :)

-o0o-
Thanks Jeric for the tips on getting the histogram of the areas obtained.

-o0o-
I give myself a 10 for I implemented the necessary techniques well.

A8 - Morphological Operations

2008-07-15T23:12:00.000-07: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 this activity, we learned two basic morphological operations done on images --- DILATION and EROSION.

From Dr. Soriano's lecture notes, dilation is defined as follows.

On the other hand, erosion operator is defined as

From these definitions, we predicted the outcome of an image after dilating and eroding it with certain structuring elements.

We used the following binary images as test objects:

square (50×50)
triangle (base = 50 , height = 30)
hollow square (60×60, edges are 4 pixels thick)
plus sign (8 pixels thick and 50 pixels long for each line)
circle (radius 25)

The structuring elements used are shown below.
1. 4×4 ones
2. 4×2 ones
3. 2×4 ones
4. cross, 5 pixels long, one pixel thick.

We then check our predictions using SciLab's dilate and erode functions.

DILATION
The dilation results for each structuring element is shown below

EROSION
The erosion results for each structuring element is shown below

THIN
According to SciLab:
thin - thinning by border deletion
Function thin performs thinning of binary objects. It uses the Zhang-Suen, a de facto standard and simple technique. The resulting image, the skeleton, is not always connected and is very sensible to noise. For thin shapes, it should work faster and provide better quality. You will need some pruning criterium to eliminate spurs.

SKEL
According to SciLab:
skel - skeletonization, thinning, Medial Axis Transform
Function skel performs skeletonization (thinning) of a binary object. The resulting medial axis is multi-scale, meaning that it can be progressively pruned to eliminate detail. This pruning is done by thresholding the output skeleton image.
The algorithm computes skeletons that are guaranteed to be connected over all scales of simplification. The skeletons are computed using the euclidean metric. This has the advantage to produce high-quality, isotropic and well-centered skeletons in the shape. However the exact algorithm is computationally intensive.

-o0o-
Notes:
The predictions were visualized and written in a piece of paper. I'll try to scan them for posting and for comparison as well. For now, I could only say that some of my predictions, as to what the outcome of the image looked like after dilation and erosion using the given structuring elements, did not match the simulation done in SciLab. I would say 70% of my predictions were correct. I had difficulty especially with predicting images after erosion. Also, I wasn't so sure about my prediction in using the cross structuring element.
With all these reasons and knowing that I'd only predict roughly 70% of the outcome of the images, I give myself a 7/10 for this activity.

-o0o-
Collaborators:
Thank you JC Nadora, Jeric Tugaff, Toni Lei Uy, Benj Palmares, Cole Fabros, Ed David, Angel Lim, Mark Bejemino for the invaluable discussions regarding erosion and dilation, especially with prediction. More thanks to Ed for pointers in drawing the test objects in GIMP. (I was doing it in Paint with so much difficulty so he showed me how to do it easily.)

A7 - Enhancement in the Frequency Domain

2008-07-09T18:37:00.000-07:00

Anamorphic Property of the Fourier Transform

Varying the frequency of the sinusoid changes the location of the FFT peaks from (0,0). As observed, higher frequencies would result to peaks farther from the origin.

Rotation of the image, on the other hand, corresponds to the rotation of its FFT but on the other direction.

Multiplying two sinusoids result to peaks which form the corner of a square. Adding them, however, result to a cross-like pattern, wherein the vertical dots correspond to fft peaks of the horizontal sinusoid and horizontal dots to vertical sinusoid. The effect in the Fourier space is much like adding each FFT.

Filtering in Fourier Space

a) Fingerprint Enhancement

Shown below is a fingerprint image. We want to enhance the ridges present on it by filtering in Fourier space.

We know that the ridges would correspond to high frequencies since they are repetitive patterns present in the image. Also, we can think of them as sinusoids in different directions. Therefore, we get the FFT of the fingerprint image.

We then designed a filter mask using mkfftfilter function in SciLab. Since we want to enhance the higher frequencies corresponding to the ridges, we design a high pass filter. Shown below is a high-pass exponential filter.

We multiplied this filter with the original FFT of the fingerprint image. After this, we again get its FFT to get the following enhanced image.

The FFT of the enhanced image is shown below. The lower frequencies were removed thereby resulting to enhancement of the higher frequencies.

We then tried using a high-pass binary filter shown below.

The resulting image is shown below.

b) Lunar Landing Scanned Picture: Line Removal

The two groups of irregularly shaped craters north and west of the landing site are secondaries from Sabine Crater. This view was obtained by the unmanned Lunar Orbiter V spacecraft in 1967 prior to the Apollo missions to the Moon. The black and white film was automatically developed onboard the spacecraft and subsequently digitized for transmission to Earth. The regularly spaced vertical lines are the result of combining individually digitized 'framelets' to make a composite photograph and the irregularly-shaped bright and dark spots are due to nonuniform film development. [NASA Lunar Orbiter photograph]

By filtering in the Fourier domain, we can remove the vertical lines present in this image. We first get its FFT.

Using the hints from http://www.roborealm.com/help/FFT.php, we designed a filter mask such that the peaks which lie horizontally along the center of the FFT image will be suppressed. These peaks corresponds to the strong vertical lines in the original image. The filter mask we designed is shown below.

This mask is then multiplied to the FFT of the original image to get the following enhanced FFT.

From this enhanced FFT, we obtain the following enhanced image which obviously has no vertical lines present. Clearly, the image was enhanced.

-o0o-
Collaborators:
Jeric Tugaff for the FFT discussions and hints on filtering in the Fourier space.
Cole Fabros, Benj Palmares and Ed David for the FFT discussions.

-o0o-
Rating:
I give myself an 8/10 because
1. I'm not satisfied with my fingerprint enhancement algorithm. SciLab's mkfftfilter seems not suitable for this job.
2. I'm happy with the results of the Lunar Image tho, we had a hard time figuring how to do it properly. I'm thankful for Jeric's resourcefulness for he found hints in the internet.

A6 - Fourier Transform Model of Image Formation

2008-07-07T18:53:00.000-07:00

Familiarization with Discrete FFT
Test Image 1: 128x128 image of a white circle, centered and with the background black

Applying FFT on the image and computing the intensity values resulted to the following image:

However, the FFT algorithm inverts the quadrants of the FT plane resulting to the image above. Applying fftshift() command on it yields the correct FT of a circle whose analytical solution is the Airy circle, as shown in the figure below

One characteristic of FFT is that it can retrieve the original image by performing FFT on the FFT of the image, as seen on the resulting image below.

Test Image 2: 128x128 image of a letter “A”

applying fft()

then fftshift()

FFT on FFT of an image

Convolution

The convolution is a linear operation which means that if f and g are recast by
linear transformations, such as the Laplace or Fourier transform, they obey the
convolution theorem:

H=FG

where H , F and G are the transforms of h, f and g, respectively. The convolution
is a “smearing” of one function against another such that the resulting function
h looks a little like both f and g. Convolution is used to model the linear regime of
instruments or detection devices such as those used in imaging. For example, in
imaging, f can be the object, g can be the transfer function of the imaging system.
Their convolution, h, is then the image produced by the detection system which in
general is not 100% identical to the original object. *
*AP186 Notes, Maricor Soriano, 2008

For this part of the activity, we simulate an imaging device such as lens by using images of circles with different radii. These images represent the aperture of a circular lens. We then convolve another image with these lenses and observe the resulting image.

Original Image:

a) circular lens of small aperture with resulting image after convolution

b) circular lens of medium aperture with resulting image after convolution

c) circular lens of large aperture with resulting image after convolution

d) circular lens of very large aperture with resulting image after convolution

As observed, the resulting images for lenses with larger aperture are better as compared to those with smaller aperture. This is because the resulting image is dependent on the finite size of the lens.

Correlation via Template Matching

Correlation is a measure of the degree of similarity between two functions f and g. The more identical they are at a certain position, the higher their correlation value. Therefore, the correlation function is used mostly in template matching or pattern recognition.

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.

The image on the left is correlated with the template on the right. This is done to find the location of the letters A on the original image.

The resulting image highlights the points where A is located. These are the points where bright white spots occur.

Edge detection using the convolution integral

Edge detection can be seen as template matching of an edge pattern with an image. In this activity, we created a 3x3 matrix pattern of an edge such that the total sum is zero.

We used three different patterns corresponding to three different directions.

horizontal/vertical/spot

Using imcorrcoef() function in SciLab, we then correlate these patterns to an original image to be able to detect edges. Observe from the results below that horizontal patterns are highlighted on the first image, vertical ones on the second image while edges were better defined using the spot pattern since it can include both horizontal and vertical edges even smooth edges.

This technique can refine edges but it is limited to monochrome images as your original image because in using a 256 color bitmap as input image, the edge detection technique results to a noisy image, therefore one cannot see clearly defined edges.

-o0o-
Collaborators: Jeric and Benj

-o0o-
Rating: 10/10
Expected results were observed for each part of the activity.

A5 - Physical Measurements for Discrete Fourier Transforms

2008-07-02T18:02:00.000-07:00

Discrete Fourier Transform (DFT) is one of the specific forms of Fourier analysis. It transforms a time-domain function into its frequency domain representation.

*AP186 Lecture Notes, Maricor Soriano, 2008

We used the following code by Dr. Soriano in getting the FFT of a temporal signal. Fast Fourier Transform (FFT) is a DFT algorithm.
---

T = 2;
N = 256;
dt = T/N;
t = [0:dt:(N-1)*dt];
f = 5;
y = sin(2*%pi*f*t);
f1 = scf(1); subplot(2,1,1); plot(t,y); xtitle('sin 10*pi*t');

FY = fft(y);
F = 1/(2*dt);
df = 2*F/256;
f = [-(df*(N/2)):df:df*(N/2 -1)];

subplot(2,1,2); plot(f, fftshift(abs(FY))); xtitle('FFT');
---

The following plots show the FFT of a 1-D sinusoid. Observe that peaks on the FFT corresponds to the frequency of the sinusoidal function.

For images, which are two dimensional in nature, we use pixels as our discrete time. Therefore, FT of images is much like doing FT for temporal signals, only that now, we perform spatial FT rather than temporal FT. In SciLab and Matlab, a built-in function called fft2 is used for performing 2-D DFT.

In Mathworks the fft2 algorithm is defined as follows:

fft2(X) can be simply computed as

 fft(fft(X).').'

This computes the one-dimensional DFT of each column X, then of each row of the result.

From the DFT equation above, one could infer that increasing the number of samples N in the signal would result in widening the domain of the FT.

This is supported by the FT analyses of a sinusoidal function with dominant frequency equal to 5. I increased the number of samples from N=128, 256,512 and 1024.

Next, decreasing the sampling interval Δt would increase the Δf in the FT. This suggests that in doing so, you actually decrease the resolution of your frequency analysis.

A4 - Enhancement by Histogram Manipulation

2008-06-25T18:32:00.000-07:00

HISTOGRAM MANIPULATION: LINEAR CDF

This activity is designed to improve the quality of an image by manipulating its histogram. Histogram manipulation enhances certain image features such as brightness and contrast. The image below is a good example for histogram manipulation since as shown, the image seems to be too dark.

*http://www.dphclub.com/tutorials/images/war-time-1.jpg

The observation that the image is dark is supported by plotting its histogram. The histogram of a grayscale image is equal to the graylevel probability distribution function (PDF) if normalized by the total number of pixels. (AP186 Notes, Maricor Soriano, 2008) Observe that pixel values of the image cluster on the darker region of the PDF, that is near the lower values of the gray level. The lowest pixel value of the image is equal to 15 while the highest is 114.

We then get the Cumulative Distribution Function (CDF) of the image from its PDF, simply by getting the cumulative sum of the values in the PDF.

The CDF is nonlinear and the values cluster on the darker region of the CDF. We then use this CDF to map each pixel of the original image to a new array with the CDF as the mapping function. The resulting image is shown below.

As observed, the image is much brighter than the original. This is because, after mapping the original image using its CDF, the pixel values of the image is 'stretched' within the 0-255 gray levels, therefore values where evenly distrbuted within the gray level The histogram plot below signifies that a slightly even distribution actually happened.

Since the values were evenly distributed (relatively) among the gray levels, the expected CDF must be linear. The 'ringings' on the lower part is caused by contributions from the darker gray levels which are relatively more than those present in the lighter side. (see histogram) This is again due to the fact that the original image has more darker values than lighter ones.

Here is the code I used:
---

getf('imhist.sci');

im=imread('image_tc.jpg'); //opens a 24 bit image
im=im(:,:,1);
imwrite(im(:,:), 'image_gs.jpg'); //converts to 8 bit grayscale image
im=imread('image_gs.jpg'); //saves the grayscale image
[val,num]=imhist(im);
imsize=size(im,1)*size(im,2);
normCDF=cumsum(num/imsize);
h=scf(1); plot(val, num/imsize);
h=scf(2); plot(val,normCDF);

//pixel mapping using CDF of image
imnew=[];
for i=1:size(im,1)
for j=1:size(im,2)
imnew(i,j)=normCDF(find(im(i,j)==val));
end
end

imwrite(imnew,'image_enhanced.jpg'); // saves enhanced image after mapping
imenhanced=imread('image_enhanced.jpg');
[val,num]=imhist(imenhanced);
imsize=size(imenhanced,1)*size(imenhanced,2);
normCDF=cumsum(num/imsize);
h=scf(3); plot(val, num/imsize);
h=scf(4); plot(val,normCDF);
---
***imhist.sci is the histogram plotting code written by Jeric Tugaff

HISTOGRAM MANIPULATION: NON-LINEAR CDF

Below is a flowchart of pixel backprojection using a non-linear CDF, as summarized by Dr. Maricor Soriano in her lecture notes.

The following is an enhanced image after mapping the original pixel values using a nonlinear CDF given by the equation G=1/2+ 1/2(tanh(16*((z-128)/255))) where z is from 0-255.

The histogram of this enhanced image is shown below with its CDF as well. The blue plot is the CDF used for mapping while the red plot is the CDF of the enhanced image. The difference in the CDF is probably due to the interpolation method I used in pixel backprojection. (click CDF plot for a clearer view)

I observed that the sigmoid CDF I used didn't enhance the image well as seen with the naked eye. I experimented with using a parabolic function as my desired CDF.

G=(z.^2);
G=G/max(G);

where z is again between 0-255. I divided it with its maximum value to obtain a function with 1 as the highest value. The enhanced image is shown below.

Below is the histogram and CDF of this image. The blue plot is the desired CDF, red plot is the CDF of the enhanced image. (click CDF plot for a clearer view) The difference in the CDF is probably due to the interpolation method I used in pixel backprojection.

Here is the code I used:
---

getf('imhist.sci');

im=imread('image_tc.jpg'); //opens a 24 bit image
im=im(:,:,1);
imwrite(im(:,:), 'image_gs.jpg'); //converts to 8 bit grayscale image
im=imread('image_gs.jpg');
[val,num]=imhist(im);
imsize=size(im,1)*size(im,2);
normCDF=cumsum(num/imsize);
h=scf(1); plot(val, num/imsize);
h=scf(2); plot(val,normCDF);

z=[0:255];
G=(1+(tanh(16*((z-128)/255))))/2;
//G=(z.^2);
//G=G/max(G);
h=scf(5); plot(z,G,'b');

imnew=[];
imnew2=[];
for i=1:size(im,1)
for j=1:size(im,2)
imnew(i,j)=normCDF(find(im(i,j)==val));
end
end

imnew2=interp1(G,z,imnew);
imnew2=round(imnew2);
h=scf(3); imshow(imnew2,[0 255]);

[val,num]=imhist(imnew2);
imsize=size(imnew2,1)*size(imnew2,2);
normCDF=cumsum(num/imsize);
h=scf(4); plot(val, num/imsize);
h=scf(5); plot(val,normCDF,'r');
---
***imhist.sci is the histogram plotting code written by Jeric Tugaff

--o0o--

Collaborator: Jeric Tugaff
...thank you for the histogram plotting code and for the interp1 syntax

--o0o--
Grade: 10/10 since image was enhanced thru histogram manipulation and that CDF of enhanced image is almost the same as that of the desired CDF, especially for the nonlinear part.

A3 - Image Types and Basic Image Enhancements

2008-06-24T10:49:00.000-07:00

Image Types

1. Truecolor Image

*photographed by Kate Dado

FileName: truecolor.jpg
FileSize: 35662
Format: JPEG
Width: 300
Height: 400
Depth: 8
StorageType: truecolor
NumberOfColors: 0
ResolutionUnit: inch
XResolution: 72.000000
YResolution: 72.000000

2. Grayscale Image

*http://www.jnevins.com/Angelwebgrayscale.jpg

FileName: grayscale.jpg
FileSize: 47925
Format: JPEG
Width: 378
Height: 504
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: inch
XResolution: 72.000000
YResolution: 72.000000

3. Indexed Image

*http://imgtops.sourceforge.net/bakeoff/o-png8.png

FileName: indexed.png
FileSize: 139332
Format: PNG
Width: 400
Height: 400
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: centimeter
XResolution: 72.000000
YResolution: 72.000000

4. Binary Image

Shown below is a truecolor image of a flower.

*photographed by Kate Dado

To obtain a binary image from this truecolor image, I first converted it to grayscale using the following code.

im=imread('flower.jpg');
im=im(:,:,1);
imwrite(im,'flower_gs.jpg');

I then examined the histogram of flower_gs.jpg using...

(a) GIMP

and

(b) SciLab Histogram Plotting Code (© Jeric Tugaff)

im=imread('flower_gs.jpg');
val=[];
num=[];
counter=1;
for i=0:1:255
[x,y]=find(im==i);
val(counter)=i;
num(counter)=length(x);
counter=counter+1;
end
plot(val, num);

From the histogram, we see that there are two significant clusters of pixel values, one on the black side (0) and one on the white side (255). Therefore, we can choose a value for thresholding the image to separate the background from the region of interest (ROI), by simply examining the image histogram. Then we incorporate this threshold value to convert flower_gs.jpg to binary.

thresh=150;
im=im2bw(im,thresh/255);

FileName: binary.gif
FileSize: 19608
Format: GIF
Width: 400
Height: 300
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: centimeter
XResolution: 72.000000
YResolution: 72.000000

Thresholding and Area Calculation Part 2

Thresholding is done by examining the histogram of an image, as detailed above. Shown is a scanned image of a leaf.

im=imread('leaf.jpg');

For purposes, which I'll explain later, I cropped the image.**

im=imread('cropleaf.jpg');

This is a truecolor image, and so, I first converted it to grayscale to obtain its histogram.

im=imread('cropleaf_gs.jpg');

Two peaks are evident on the histogram, a hint that the image is of good quality, and that we can separate the leaf from the background. We then again find a threshold to be used for converting the image into binary.

thresh=175;
im=im2bw(im,thresh/255);

To calculate the area of the leaf, using Green's theorem (see this), we first incorporate the following code.

im=1-im;

Effectively, this inverts the pixel values such that the area bounded by the contour of the leaf would be 1's (white) and those outside are 0's (black). This is important since what we are going to calculate the area of the leaf, not the area outside the leaf (or the background).

Using Green's theorem, the area calculated is 21466.5 pixels.

Comparing this with the area calculated using pixel counting* which is 21967 pixels, we see a 2.28% difference between them.

*ImageArea=sum(im);
//summing can be done since we know that the value inside the contour of the leaf are all 1's and that outside are 0's, and therefore summing the whole image will just result to the area (in pixels) of the leaf.

**The image of the leaf was cropped so that the ruler won't be included in the area calculation.

---
Thanks to...
Jeric Tugaff for the histogram plotting code. :)

---
Rating: 10/10
since a 2.28% difference between the two methods for area calculation is within the 5% acceptable limit.

A2 - Area Estimation for Images with Defined Edges

2008-06-18T20:14:00.000-07:00

Activity 2 - Area Estimation for Images with Defined Edges

The goal of this activity is to get the area of a regular geometric image (i.e. circle, rectangle, triangle). To do this, we use the 'follow' command in SIP toolbox of SciLab to obtain the edge pixel values of an image and then use these values (these values form the contour of the shape) to obtain the area bounded by this contour using Green's theorem.

*AP 186 A2-Area Estimation for Images with Defined Edges, M. Soriano, 2008

The following illustrates the code which I used in implementing Green's theorem for computing areas bounded by a contour.

---
//Area Estimation for Images with Defined Edges
//Julie Mae B. Dado
//AP186

TestImg=imread('C:\Documents and Settings\AP186user03\Desktop\rect.jpg');
TestImg=im2bw(TestImg,0.5);
//imshow(TestImg);

[x,y]=follow(TestImg);
size_x=length(x);
size_y=length(y);

x1(1)=x(size_x);
x1(2:size_x)=x(1:size_x-1);

y1(1)=y(size_y);
y1(2:size_y)=y(1:size_y-1);

area=0.5*sum((x1.*y)-(y1.*x));

//theoretical area
tarea=(max(x)-min(x))*(max(y)-min(y)); //rectangle or square
//tarea=%pi*(((max(x)-min(x))/2)^2); // circle
//tarea=0.5*(max(x)-min(x))*(max(y)-min(y)); //triangle

---

RESULTS:
*Image size: 63x71
Test Image 1: Rectangle

Area Computed Using Green's Theorem: 1763
Theoretical Area (pixel count): 1763
% Error: 0%

Test Image 2: Triangle
Area Computed Using Green's Theorem: 876.5
Theoretical Area (pixel count): 860
% Error: 1.9%

Test Image 3: Circle (large)
Area Computed Using Green's Theorem: 1658
Theoretical Area (pixel count): 1661.9
% Error: 0.23%

Test Image 4: Circle (medium)
Area Computed Using Green's Theorem: 341
Theoretical Area (pixel count): 346.4
% Error: 1.6%

Test Image 5: Circle (small)
Area Computed Using Green's Theorem: 64
Theoretical Area (pixel count): 78.5
% Error: 18.5%

Observations:
1. Maximum differences between area estimation using Green's theorem (that is, obtaining pixel values for the contour) and analytical estimation of area using pixel counting were observed for circular shapes while minimum errors were observed for rectangular shapes. This error can be accounted for the pixel shape which are actually small squares. Circular shapes relatively do not have smooth contours. (this may be observed if you zoom in on a circular image)

2. For circle with smaller radii, the errors are larger. This is because the smaller the radius, the less number of pixels used to estimate the smooth shape of the circle.

3. Area estimation by obtaining pixel values of a contour used for Green's theorem are somehow limited shapes with straight sides. This technique somehow isn't suited for smooth contours unless pixel values are compensated such that it can approximate the shape with less error.

---
Thanks to...
Jeric for helping me debug my program whenever it doesn't work and for showing me how to obtain theoretical area using pixel counting.

---
Grade: 7/10
because I had a hard time debugging simple errors and that I pretty much didn't analyze how to obtain area using pixel counting.

A1 - Digital Scanning

2008-06-11T19:27:00.000-07:00

I obtained this plot from Canadian Journal of Physics dated 1953.

The following table shows the pixel locations of the tick marks for both X and Y axes of the digitally scanned plot.

along x
points	px	py
0	140	1129
0.2	271	1129
0.4	401	1129
0.6	531	1129
0.8	661	1129
1	791	1129

along y
points	px	py
0	140	1129
4	140	994
8	140	859
12	140	724
16	140	589
20	140	457
24	140	324
28	140	190
32	140	60

To obtain a conversion factor (pixel/unit) for each axis, simply count the number of pixels that lie within each tick mark. For cases wherein the number of pixels within tick marks of one axis ( Y-axis in my case) varies, average the values to obtain a general conversion factor. The values I obtained are the following:

x-axis: 130.2 pixels/unit (unit in this case, means, within one tick mark)
y-axis: 133.625 pixels/unit

These values are then used to obtain physical values of the points on the graph. The next step is to get the pixel values of the points the graph. I obtained the following for the scanned plot shown above.

px	py
203	998
267	936
331	879
398	824
461	773
528	722
591	665
658	602
721	459
780	58

Using the conversion factor (pixel/unit) for both axes, I obtained the following physicals values by dividing the pixel values with the conversion factor. (i.e. px/130.2 for x location values)

x	y
1.559139785	7.468662301
2.050691244	7.004677268
2.542242704	6.578110384
3.056835637	6.166510758
3.540706605	5.78484565
4.055299539	5.403180543
4.539170507	4.976613658
5.053763441	4.505144995
5.537634409	3.434985968
5.99078341	0.434050514

I then used Excel to plot these values and see if the same trend as the scanned plot will be observed. (Note: Image origin is different from Excel. Image origin is on the upper left corner of the image while Excel is on the lower left. For comparison, in plotting the physical values in Excel, plot values in reverse order.) This is how the plot in Excel looks The trend is much obvious with the original image superimposed on the plot. ...
Rating 10 - The trend I obtained in re-plotting the scanned copy was similar to the original plot.
...
Thanks to...
...Benj Palmares for helping with the Excel, especially with superimposing the original image. ...Jeric Tugaff for pointers in paint. _________________________________________________________________________________

A1 - Digital Scanning EDITED VERSION: posted June 19, 2008

I obtained this plot from Canadian Journal of Physics dated 1953.

The following table shows the pixel locations of the tick marks for both X and Y axes of the digitally scanned plot.


along x
points	px	py		pixel values included within each tick mark
0	136	1126		135
0.2	271	1126		130
0.4	401	1126		131
0.6	532	1126		131
0.8	663	1126		131
1	794	1126	average	131.6


along y
points	px	py		pixel values included within each tick mark
0	136	1126		134
4	136	992		133
8	136	859		135
12	136	724		135
16	136	589		132
20	136	457		134
24	136	323		133
28	136	190		131
32	136	59	average	133.375

To obtain a conversion factor (pixel/unit) for each axis, simply count the number of pixels that lie within each tick mark. Then, average the values to obtain a general conversion factor. The values I obtained are the following:

x-axis: 131.6 pixels/one tick mark
y-axis: 133.375 pixels/one tick mark

These are then used to obtain physical values of the points on the graph. The next step is to get the pixel values of the points the graph. I obtained the following for the scanned plot shown above.

px	py
203	998
267	936
331	879
398	824
461	772
528	721
590	665
658	602
721	458
780	58

Using the conversion factor for both axes, I obtained the following physicals values by dividing the pixel values with the conversion factor. (i.e. px/131.6 for x location values). These physical values, however, should be biased in order to properly correlate the points with those present in the image. Therefore, for both x and y, I subtracted the physical value of the origin from x physical values and y physical values (i.e. x biased = x-(136/131.6) and y biased = y-(1126/133.375)).

x	y
1.542553191	7.482661668
2.02887538	7.017806935
2.515197568	6.590440487
3.024316109	6.178069353
3.503039514	5.78819119
4.012158055	5.405810684
4.483282675	4.985941893
5	4.513589503
5.478723404	3.433926898
5.927051672	0.434864105

x biased	y biased
0.509118541	-0.959700094
0.995440729	-1.424554827
1.481762918	-1.851921275
1.990881459	-2.264292409
2.469604863	-2.654170572
2.978723404	-3.036551078
3.449848024	-3.456419869
3.96656535	-3.928772259
4.445288754	-5.008434864
4.893617021	-8.007497657

I then used Excel to plot these values and see if the same trend as the scanned plot will be observed. This can be done because the points which are now biased according to the origin can be plotted in a manner that will coincide with your scanned image given that you overlay a properly cropped image, that is cropped at the pixel value of the origin. One should also be careful in overlaying the image to your Excel plot, therefore check the limits of both your x and y axes to see if proper correlation with your cropped image is observed. The following shows the Excel plot.

The following shows the Excel plot with an overlay of the cropped image.

---
Thanks to...
... Dr. Maricor Soriano for pointing out my mistake, giving tips on how to correct that mistake and for giving me a second chance at a 10. :)

px	py
203	998
267	936
331	879
398	824
461	773
528	722
591	665
658	602
721	459
780	58

px	py
203	998
267	936
331	879
398	824
461	772
528	721
590	665
658	602
721	458
780	58

px	py
203	998
267	936
331	879
398	824
461	773
528	722
591	665
658	602
721	459
780	58

px	py
203	998
267	936
331	879
398	824
461	772
528	721
590	665
658	602
721	458
780	58

px	py
203	998
267	936
331	879
398	824
461	773
528	722
591	665
658	602
721	459
780	58

px	py
203	998
267	936
331	879
398	824
461	772
528	721
590	665
658	602
721	458
780	58