(NOT) An Introduction to SHIFT-JIS Programming

終わりだ　(Activity # 19)

2009-10-11T17:11:00.013+09:00

Activity # 19 - Restoration of Blurred Images.. this is the last of the AP 186 activities which means this sem is finally over.. well, not quite but at least it's almost done. xD

In this activity, our objective would be to restore an image corrupted by a blurring function and some noise. This entire activity can be summarized in the form of a flowchart:

In simple terms, just as the objective states, we start by taking an image, then we give it a blur by introducing a blurring function and adding a noise in the Fourier domain, and then finally restoring it using a Minimum Square Error Filter.

Since the equation for a blurred image with T as the length of exposure is defined by the equation:

for adding a blur, the degradation function would then be expressed as (also in terms of T):

As for the noise, we make use of the Gaussian Noise that was already discussed in the previous activity. The operations are performed in the Fourier domain and is described by the following equation:

The filter used for the activity is the Weiner Filter or the minimum mean square error filter given by either this

or this

where K is a constant (alternative when Sn and Sf are unknown).

So that's practically all the physics you'll ever need for the activity--what we need to do now is apply those equations to a test image. For this activity, the I grabbed a photo of Eric Clapton with 'The Fool' guitar from Gibson's site:

The blurred image generated by the degradation function looks like this:

Now, since there are two equations for the filter, we therefore have two reconstructions for the image: one using Sn and Sf (Left) and another one using K=0.01 (Right).

We can see that we have a better image using the Sn and Sf reconstruction. However, we can observe the following trend for various K's (K=1, K=0.1, K=0.01 and K=0.001 respectively:

From the set, we can infer that K approaching integer values is biased towards the blur, while small values of K are biased towards the noise. On a side note, the optimal value is hence in between K=0.1 and K=0.001.

This activity was rather easy compared to the other activities, so I'll give myself a 10. I'd like to acknowledge Neil for his help in this activity.

AP186のアクチヴィチ１３が、完了した!! (Activity # 13)

2009-10-11T11:56:00.014+09:00

This is probably the most difficult (if not tedious) activity in AP 186. This activity (Activity # 13) is entitled Correcting Geometric Distortions.

Since a camera uses a lens to focus an image to its sensor, lens distortions can be observed. For spherical lenses, there are two common types: Barrel Distortion and Pin Cushion Distortion. Here are the examples for each kind (c/o imagetrendsinc.com):

In order to correct the distortion, we need a reference image with a regularly occuring pattern and visuallize the distortion across the image frame. If we let f(x,y) be the correct ideal image, and g(x,y) be the distorted image, we can assume that there exists a transformation function that mapped f(x,y) to g(x',y'):

The aim would be to invert the transformation in order to obtain our ideal image. Two image properties will be corrected in the process: the pixel locations, and their respective graylevel values.

We start by expressing x'=r(x,y) and y'=s(x,y), where r and s are the transformation functions used to map the ideal image to the distorted image frame. It is good to assume that these functions take the form of bilinear functions, r(x,y) = c1*x+c2*y+c3*xy+c4 and s(x,y) = c5*x+c6*y+c7*xy+c8.

That's basically the physics of this activity as the rest of the steps would make use of matrix manipulations. First, I obtained a barrel-distorted image from imatest.com and cropped it to get this image:

It's cropped for two reasons: one, this activity aims to demonstrate the concepts used in geometric distortion correction and thus a large grid is not advisable; two, since Scilab works faster with small matrices or images. Notice that the centered square on the grid features the least amount of distortion and our ideal grid was generated from the dimensions of that square. Here are the pixel locations of the points of intersection of the distorted and ideal grids respectively:

After obtaining the pixel coordinates for the ideal image, we then solve for the coefficients c1 to c8 by setting up the following matrices for each square (thus making the procedure similar to a moving averages run):

and solving for the coefficients using the following equations:

Once the coefficients are obtained, we get the corresponding pixel locations from our distorted image using the set of transformation equations listed above (x' = r(x,y) = c1*x+c2*y+c3*xy+c4 and y' = s(x,y) = c5*x+c6*y+c7*xy+c8) and map out these pixel coordinates to the ideal image map. For the points in the ideal image plane with no corresponding point from the distorted image, we use interpolation methods (bilinear or nearest neighbor) to obtain their grayscale values. Since I practically patterned out my interpolation routine from Gilbert's source (by the way, Gilbert helped me to get this thing working after we consulted Mandy several times), please refer to his source for the interpolation part.

Here are the results I obtained from this activity:

The images above are for the original image, the bilinearly-interpolated image and the image for nearest neighbor interpolation. Although the image was not fully restored, the bilinearly-interpolated image has better quality than the nearest neighbor-interpolated image.

Once again, I'd like to acknowledge Gilbert and Mandy for helping me in getting my version of the source to work. I'm getting a 9 for this activity.. minus one for the delay but 9 for finishing it anyway.

日本人彼女募集中。（Activity # 18)

2009-09-21T21:25:00.019+09:00

This activity is entitled 'Noise Models and Basic Image Restoration.' It introduced me to the different noise models, and the filters to use whenever they're encountered in real life (not likely). As usual, although this activity will orient the reader on the different image restoration techniques, the best advice is still to start off with a good image--one that doesn't need restoration in the first place. The second best advice would be to use Photoshop--that's why, this post and Scilab with SIPtoolbox should come as a last resort (after Matlab).

The original test image and its pdf looks like this:

Different Types of Noise

In the activity, we were given six image models, as well as the equations needed for the models to act on the probability distribution function (refer to Activity 3) of the image. These noise models are: Exponential Noise, Gamma Noise, Gaussian Noise, Salt-and-Pepper Noise, Uniform Noise and Rayleigh Noise. Note that I listed them in the order the sample images above are arranged, except for Rayleigh Noise. (Rayleigh noise is currently in the works.)

While there are six noise models, only four filters were given for us to examine. These filters are: Arithmetic Mean, Geometric Mean, Harmonic Mean and Contra-harmonic Mean.

Exponential Noise

Gamma Noise

Gaussian Noise

Rayleigh Noise

Salt and Pepper Noise

Uniform Noise

Arithmetic Mean as the name implies, takes the average of the sum of color values for each subimage (hence, a moving average; sub-image means 3x3 patch); Geometric Mean takes the average via an n-th root; Harmonic Mean divides the patch dimensions by the inverse sum; and finally, the Contra-harmonic filter takes the sum raised to an order value Q, and divides it by the sum raised to the order of Q-1.

Since this activity is pretty much about learning what kind of filter to use for a specific kind of noise, the images below can serve as a guide for the reader. Though most of the time, the arithmetic mean and geometric mean filters obtain a similar looking image, the images are different for the Gaussian and Salt-and-Pepper noise. It is also important to note that for the contra-harmonic filter, we obtain different images for different values of Q.

The images above show the contra-harmonic filter acting on Salt-and-Pepper Noise for Q=-2, Q=0 and Q=+2 respectively. From this, we can infer that the value of Q to use would depend on the image being restored--negative values for grayscale images biased towards black, while positive values for grayscale images biased towards the white. In the case of my Yuuko sketch, since it's biased towards white, it is greatly restored at Q~+2.

I thank Neil and Gilbert for their help with the noise addition parts, and myself for helping others with the filtering part. xD Anyway, since all the objectives for this activity was accomplished, and I had my own batch processing script as a bonus, I'll give myself a 10.

「ai sp@ce」のバイトは、どうしますか? (Activity # 17)

2009-09-10T09:43:00.007+09:00

This activity focuses on photometric stereo, a method of extracting shape and surface detail from shadows. Using this method, we are able to reconstruct an image with surface detail from a series of several images taken at different point sources.

Suppose we have the matrix V given by

where the first index of V represents the image while the second index refers to x, y, and z coordinate of the light source respectively. Assuming these sources illuminate a common object of interest, we can obtain a series of images with intensities defined by

for each point (x,y). We would then have to find g for each point using the usual matrix operation (i.e. inv(V'*V)*V'*I) and normalize the g's to obtain the value for the normal vectors. We get the surface normals using

and finally, we obtain the surface elevation at a point (u,v) using

Following the steps I listed above, here's the Scilab output for the images contained in Photos.mat

I'd like to give myself a 10 for this activity, since this is one of the RARE activities that anyone can finish in one meeting. xD

一番大切なものは? (Activity # 16)

2009-09-08T22:30:00.006+09:00

Neural networks is the third classification method for pattern recognition explored in this course, and is the title of activity 16. Unlike the LDA, neural networks don't need heuristics and recognition rules for classification and instead makes use of learning, a function it tries to imitate from the neurons in our brain.

In any case, the activity makes use of the ANN toolbox (ANN_toolbox_0.4.2 found on Scilab's Toolboxes Center) which makes the activity more of a plug-and-play kind of activity.

So how do neural networks work? Each input connection to the artificial neuron has its own weight (synaptic strength) and is multiplied to the inputs, xi. A neuron receives weighted inputs from other neurons and lets the sum act on an activation function g. The result z is then fired as an output to other neurons.

A neural network is formed through the connection of neurons. A typical network consists of an input layer, a hidden layer and an output layer. Just like the previous activities, two modes were considered -- a training mode and a test mode. The parameters one can play around with for the functions in ANN would be the Neural Network architecture (how many neurons for each layer), the Learning Rate and the Number of Iterations.

Using the same data I used in Activity # 15

I had to do a few modifications. First, the inputs must be in a [2xN] matrix (done by transposing the bin after an fscanfMat() call), afterwhich the values must be normalized (ranging from 0 to 1). For the training set, I also had to change the classification values (1 and 2) to 1 and 0 (this is crucial to avoid having erroneous outputs). Finally, here's the output of my neural net classification after round():

For the win, I give myself a pat at the back and a well-deserved 10. xD I'd like to thank Gilbert for his help in helping me understand the ANN toolbox.

好き?　(Activity # 15)

2009-09-07T01:16:00.005+09:00

Activity # 15 is pretty much like the previous activity except for a little improvement--this time, it uses probabilisitic classification to minimize the risk or loss in classification.

Since my classes can be linearly separated (i.e. one can separate one from the other by drawing a line in the plot in the previous activity), the method I used was Linear Discriminant Analysis, the details of which can be found here.

This time, we were asked to sort out an image with patterns that are close to being similar, i.e. they should have little to no difference. I generated another image of blobs using Photoshop--the blobs are one brush size apart in terms of size and a difference of 50 ticks when it comes to G-channel color value.

Of course, the script is pretty much plug and play.. all that was needed was to obtain data using the script from the previous activity, dump them into an outfile, get the LDA script (found in the tutorial but implemented in scilab) to organize and process the files, and poof! we have an LDA plot as shown above.

Note that unlike the previous activity, it organized all the data points in a line, and that the discriminant functions were successful in classifying close patterns by increasing the difference between them (note the order of magnitude - xE+06). As expected from the image, the LDA results to a perfect classification (100% correct). I'm not sure about real life images though. I'll probably give it a shot when I find some time.

That's why, it's probably just a 9 for now.

もう。。わかんない。 (Activity # 14)

2009-09-03T11:52:00.008+09:00

Pattern recognition is the subject of Activity 14 and will probably be the subject for the next few activities.

In the context of image processing, it can be used to decide whether a feature vector (ordered set of attributes) of a pattern (a set of features) belongs to one of several classes (set of patterns sharing common properties).

Activity 14 makes use of the Minimum Distance Classification routine, where a pattern is assigned to the class whose mean or representative to it is nearest to. This can simply be done by either taking the minimum distances of the means for each sample, or by simply plotting out the means.

My original design for this activity was actually to implement the Scilab routine on an image of coins (30 coins, three classes - 25 centavo, 1 peso and 5 peso coins, and up to four features - size, R, G and B-channel color values). However, it seems absurd to do it straightforwardly, so I decided to test my algorithm on a Photoshop-generated image (based from the original coin image) of circles with three different brush sizes and three different color values in the Red. The fifteen patterns (five for each class) used for the training set were also obtained from the image of 30. All it took was a little playing around with the bwlabel() and find() functions.

As expected, the algorithm managed to sort the patterns out. Judging from the plot, there was a clear distinction between each pattern in the image, and that the deviation of the individual patterns from the training set was small.

When applied to coins however, although there is a clear distinction when it comes to size, the color values (not only in the red) were scattered all over the place. This is probably due to the uneven lighting in the image--there were shiny coins and there were dull coins. A better result can be obtained by capturing a better photo, especially with the use of reflectors and diffusers.

For my choice of a difficult image, and succeeding in sorting them out even if it's against it's will. xD I'm getting a 10.

あのぉさ。。　大丈夫か? (Activity # 12)

2009-08-06T12:23:00.007+09:00

Again, we were fortunate enough to have an activity which has something to do with taking pictures using a camera (and not generating our own images using scilab and/or paint.) The activity was entitled Color Image Segmentation, yet another concept in image processing.

In an image segmentation process, a Region of Interest (ROI) is picked out from the rest of the image in order to do further processing. It can be done by grayscaling, however that is not always the case. Sometimes, we don't want to lose some of the color information, nor do we want to lose the shading variations in 3D images.

The best way to do it is to convert the RGB values for each pixel into its normalized chromaticity coordinates. Once can easily do this by letting the sum

R + G + B = I

and dividing each channel by I. After this procedure, we can then use either the Parametric Probability Distribution Estimation by assuming a Gaussian Distribution independently along r and g (i.e. the probability that a pixel r belongs to the ROI is seen in the equation below, repeat for g),

or the Non-Parametric Probability Distribution by using the histogram itself to tag the membership of the pixels.

I used three different patches from my original picture (above).

I will leave it to the reader to guess where these patches were taken from my image.

I don't really like putting code snippets in my blog site, but I guess I'll have to put this one in since it's not mine:

I = double(I); //I is the image of the region of interest
R = I(:,:,1); G = I(:,:,2); B = I(:,:,3);
Int= R + G + B;
Int(find(Int==0))=100000;
r = R./ Int; g = G./Int;

BINS = 32;
rint = round( r*(BINS-1) + 1);
gint = round (g*(BINS-1) + 1);
colors = gint(:) + (rint(:)-1)*BINS;
hist = zeros(BINS,BINS);

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

scf(2);
imshow(hist,[]);

The snippet was provided in our activity manual by our professor. The following images are my results for this activity (I didn't bother to post all of them). I also included an image of the chromaticity space for verification.

For the wood-patch [non-parametric (L), parametric (R)]:

For the blue-patch [non-parametric (L), parametric (R)]:

Since this is one of those activities I get to complete in a single meeting.. and I believe I completely understood what I'm doing this time.. I get a 10.

I thank Gilbert for verifying some of the answers for Me and Neil.

この学校は、好きですか?　(Activity # 11)

2009-07-30T12:40:00.003+09:00

Yey.. we finally had an activity which makes me feel that this is an image processing class.. why of course.. the best images are taken with a camera..

This activity is entitled Color Image Processing. We learned that the color captured by a digital color camera is an integral of the product of the spectral power distribution of the incident light source, the surface reflectance and the spectral sensitivity of the camera. We note that from these quantities, a White Balancing constant for the camera can be obtained and this constant explains why sometimes the colors taken by the camera just don't seem right.

There were two White Balancing Algorithms discussed in this activity: the White Patch algorithm which requires a patch or ROI in the image that looks white in the real world to calibrate the colors of the image, and the Gray World algorithm which basically takes the mean value of the pixels in the image for its definition for white.

The images displayed above shows a white-balanced photo (L) using AWB or Auto White Balancing and a poorly white-balanced photo (R) using the Tungsten Bulb setting in my phone's camera. We note that for tungsten, the camera tries to compensate for the orange tone produced by the tungsten bulb by adding more blue. However, Tungsten will make a daylight photo blue, resulting to a loss of color information in the red.

Using the White Patch algorithm, I was able to restore some of the red colors seen in the AWB image. For the Gray World algorithm however, since most of the pixels are cyan in nature--guess what their mean value is? My intuition however tells me that there just doesn't seem to be any point trying to make a bad image look good, so today's valuable lesson would be--Make sure to get your camera settings right!!

Now here's another set of images. To make it challenging, we added items of the same color but different shades in the images:

Guide to the pictures above: Auto-White Balanced (TL), Daylight setting (TR), White Patch (BL) and Gray World (BR). In terms of quality, the ones at the bottom lose unless we consider the fact that Scilab isn't actually equipped with good rendering backends.

The daylight setting is wrong in this case since the light source is mainly flourescent. The white patch algorithm did its best in restoring the original lighting, but I got a lot of noise from its attempt. Same goes for gray world but as expected, the lighting is still to the poorly-white balanced image. The white patch algorithm is definitely better than the gray world algorithm--but a good image taken by a good camera is tens of thousands of times better. ^_^

There goes another 10 for finishing the activity on time.. it's too bad the blog posts never make it in time. xD

がんばってね。(Activity # 10)

2009-07-29T20:20:00.002+09:00

The title for this activity is Preprocessing Text. The lessons we learn in the activity is very useful in handwriting recognition where individual letters must be extracted.

We were given the task of extracting a group of text from a scanned image. We rotated the image by using mogrify(), a function in Scilab that can do almost anything that the Free Transform tool in Photoshop can do (although I favor the latter). We removed the lines using the techniques used in the moon photo and the canvas weave in the previous filtering activity, binarized and threshold the image, and then labeled using bwlabel().

This activity pretty much summarizes everything we learned so far, thus it's vital to show the resulting image for each step. Apparently, mogrify() returns a stack problem in my pc, causing SIP to go FUBAR.. I had no other choice but to make use of the Free Transform tool in photoshop.

By looking at the Fourier Domain of our image, we can get an idea on the type of filter we'll need. For this case, it's pretty much like the moon photo except this time, the lines are horizontal. From the Fourier Domain of the image as shown below, the best filter is a vertical line masking the white vertical line, but taking care not to touch the point at the center. Touching that point will result in a great loss of information.

The following sets of images are the images taken before (L) and after (R) the closing operator was used. We can note that the noisy signals inside the letters were significantly reduced.

Finally, here's the image with indexed values for each blob. Imaged in hotcolormap. xD

I'd like to acknowledge Neil for helping me out with this activity, especially since I needed to do it again.. all thanks to the recent USB disk loss. I'd also like to thank Hime for her support, and for keeping me awake last night through all the blog posts I needed to write. The post date might lie, but this is actually the last blog post I made in time for the deadline.

I get a 9 for this activity. Probably for the effort in trying to recover the lost files.

違う。違うよ。(Activity # 9)

2009-07-27T11:23:00.003+09:00

Activity # 9 is entitled Binary Operations. It is very important in image-based measurements where a Region of Interest (ROI) is segmented from the background by means of edge detection or blob labelling. Some common problems in image processing where these operations are used include cell counting, tracking of fingerprint ridges and pattern recognition.

In this activity, we've been given the task of estimating the area (in pixels) of a typical puncher hole, using a reference image that looks like this:

In order to make life easier for both scilab and me, I divided the image into nine parts..

For the first subimage, the next step is thresholding. Using Photoshop (I'm working at home since I had to do this activity again.. why? Coz i lost my flash disk!!), I obtained the suitable threshold value of 230/255.

Once the threshold was found, I made use of the erosion and dilation operations from the previous activity, to perform the closing and opening operations. I used the closing operation (dilate then erode) to clean up my image, after which I used bwlabel() to label the blobs.

Finally, I used my routine for counting the pixels of the same label, tallied them into an array, and repeated the procedure for the rest of the subimages.

I tallied the areas for all the holes in the large image by appending the tallies for each of the sub-images, and I got this histogram:

I realize that as it is, there's still a lot of noise in the image. However, we are only after the area for each punch hole, thus we can also just trim our histogram by setting a tolerance level. I decided to set my tolerance between 300 and 700, the location at which the second peak is centered.

We can see that the peak is located between 512.5 and 525--but the mean value however tells us that it's 507.5. The histogram tells us that the size of the hole should be about 517 pixels, giving the mean an error estimate of around 3%.

I managed to finish the activity in a few minutes (when I had to do it again), so I definitely get a 10. hahaha.

ほら朝よ。おきておきて。 (Activity # 8)

2009-07-20T11:13:00.005+09:00

Morphology refers to shape or structure. Just as the title implies, morphological operations for image processing shall be the focus of this activity. So what is it used for? Shapes can be expanded or thinned, holes can be closed, and disconnected blobs can be joined.

It makes use of the Set Theory. It makes use of the shape, as well as a structuring element for the direction of its growth or reduction. However, for our purposes, we only need to focus on the concepts of Dilation and Erosion.

Dilation results in an expansion of the shape following the morphology of the structuring element.

Erosion results in a reduction of the shape following the morphology of the structuring element.

In this activity, there was predicting involved. However, for the most part, you won't really see explanations. It's pictures galore once again. xD

Original Images:

Structuring Element (4x4 ones):
Dilation

Erosion

Structuring Element (2x4 ones):
Dilation

Erosion

Structuring Element (4x2 ones):
Dilation

Erosion

Structuring Element (cross):
Dilation

Erosion

This is probably the most tedious activity ever. So without further ado, I get a 10.

面白い?もちろんです（ない)。 (Activity # 7 )

2009-07-14T11:55:00.003+09:00

Activity 7 is all about filtering in the Fourier Domain. Of course, this type of filtering can only be done on unwanted repetitive patterns on images. These patterns can be removed by masking out their frequencies in the fourier space. However, filtering can also be used to enhance images in the Fourier domain.

We started the activity with a little practice on Fourier space. We explored the Fourier transform plots for dots, squares and gaussians. We played around with the spacing to find out that it does affect the transform.. same goes for the orientation. However, the images are too plain to post here, so I think it's better to jump to the good part.

Truth be told.. I tried my best with the fingerprint enhancement.. demo.. it's really hard to filter out the low frequencies!! I end up losing more information and my image did not get enhanced--at all. That's why I ended up with the conclusion that the image I picked is better off not being tampered with.

Next up is an image from the moon landing. The images are: original image (TL), the image in Fourier domain(TR), the fft filter used (BL), and the enhanced image (BR). There was a signifcant reduction in the vertical lines, however, some residual lines still appear to be present. Probably need to filter out more of the low-frequency signals but I believe this image has already passed my standard.

Last but not the least would be the filtering for a painting. The weave texture on the canvas can be pretty tricky.. and depending on the situation we might want it, or not. The images displayed above are: original image (TL), the image in Fourier space (TR), the pattern we've been trying to filter out or the weave (BL), and the reconstructed image in grayscale (BR).

The brush strokes were enhanced after the weave pattern was removed, so it's probably a sign that the code and the filter works. Another way to verify the routine would be to check the noise profile--and it does look like the weave pattern.

For this activity, I'll probably give myself an 8 since I did get through the tedious drills in Fourier Transform, I succeeded in doing the two image enhancements and I wasted an entire period working ONLY on the fingerprint enhancement. It's probably a science in itself, and it being a sub-activity just doesn't fit.

もうあたし,　止まらんあい!! (Activity # 6)

2009-07-09T11:27:00.008+09:00

Moar pix!! Moar!! Naow na!!

Continuing from Activity # 5 , this time we made use of different shapes for the apertures -- square, annulus, square annulus, a double-slit, and two dots. The corresponding images can be found right next to its aperture.

The next part of the activity investigated the anamorphic property of Fourier Transform. It was a step-by-step routine, and the end product would be the last two images. Different variations were tested which included the superposition and rotation of sinusoidal waves.

As of the moment, my interest goes to the attempt to generate my checkered images (will post them as soon as they're done.)

Raffy taught me a valuable trick today--just change imshow() to mesh() to get a rather interesting 3-D image. xD

七夕祭りへようこそ!! (Activity # 5)

2009-07-07T11:43:00.012+09:00

Applied Physics 186 class isn't an image processing class for nothing. Of course, its students are EXPECTED to have lots of images in their activity blogs.. xD

5 - A:

Part A of Activity 5 focuses on the familiarization with the discrete FFT. We have two sample images, a circle and a letter 'A'. All we needed to do is apply a discrete FFT2() on the image, give it an FFTSHIFT(), and apply an FFT2() again to get an inverted image of the original. The images above are chronologically-ordered to give the viewer an idea of the process.

5-B:

Part B is all about the simulation of an imaging device. This part makes use of a concept known as Convolution, which is a linear operation for linear transformations as long as they follow the Convolution theorem. The basic gist is that we are imaging an image (VIP), through various apertures (circle, circle2, circle3). The image above displays the original 'VIP', along with the images projected from 100%, 50% and 10% of the circular aperture respectively.

5-C:

Part C worked with Correlation through Template Matching. For the image, we used 'THE RAIN IN SPAIN STAYS MAINLY IN THE PLAIN' which is quite known (although unknown to me. xD). We used another image for the letter A, the trick being it had to be of the same size and font as the one in the previous image, and ta daa.. We obtained an image wherein all the 'A's are highlighted. Pretty nifty for looking for patterns in a large image.

5-D:

Finally, Part D was about detecting edges with the use of the convolution integral. All that was needed was a 3x3 matrix pattern such that the total sum is zero. I used a horizontal, vertical, diagonal and a spot pattern to obtain the images above.

I think I deserve a 10 for the activity for finishing it earlier than expected along with Neil. It's easy because it's a demonstration activity, aside from the fact that the stuff needed is readily available.

あのぉさあ。。晩御飯は、おいしいですか?　(Activity # 4)

2009-07-06T21:35:00.010+09:00

I actually missed this activity that day. I spent the day in a hospital bed with a liter of 0.9% sodium chloride solution connected to my hand through plastic transparent tubing. Not to mention, I got a shot of gamma-immuno to strengthen my immune system and get my platelets up. It was the flu. However, the symptoms were more dengue-like than H1N1.. better luck next time.

Anyway, the activity was on Histogram Manipulation. Just like the others, I had to make use of the useful piece of code that can be found on a little learning. Getting it to work on my pc in CSRC was a bit tricky, good thing I had Neil and Rommel with me. For manipulating the histogram, Gilbert shared this little bit of info with me:

good = [];
for i = 1:size(poor,1)
for j = 1:size(poor,2)
good(i,j) = cdf(poor(i,j));
end
end

good: new image
poor: old image

With everything all set, all I needed was a picture to work on. The one i got from this site seems pretty nifty:

Right next to the image is its histogram. Using the chunk of code Gilbert suggested to apply the transformation, I gave it a shot for a linear function:

The linear function did not turn out as good as expected. In any case, the eye has non-linear response and therefore a non-linear transformation (square function) should be better:

And that concludes the histogram activity. I think I'll get a nine this time for missing the meeting, still high enough considering I finished the activity in a meeting instead of two meetings. xD

それでいいですか? (Activity # 3)

2009-06-23T11:08:00.019+09:00

We were oriented with the different kinds of images today:
1. Binary - simply black and white images
2. Grayscale - shades of gray; where a pixel is given a value between 0 (black) and 255 (white)
3. True-color - has three color channels (usually in RGB)
4. Indexed - similar to true-color except it contains both the image and indexed RGB info.. it is safe to assume that most grayscale images are indexed.

We were asked to collect different types of images.. I selected four pictures, one for each basic type.

Binary

(My own generated image--same as Activity # 2)

FileName: activity_3.bmp
FileSize: 12864
Format: BMP
Width: 320
Height: 320
Depth: 8
StorageType: indexed
NumberOfColors: 2
ResolutionUnit: centimeter
XResolution: 28.340000
YResolution: 28.340000

Grayscale

(This is a picture from the Azusa Nakano Fanclub.)

FileName: 100720.jpg
FileSize: 70426
Format: JPEG
Width: 204
Height: 600
Depth: 8
StorageType: indexed
NumberOfColors: 256
ResolutionUnit: inch
XResolution: 72.000000
YResolution: 72.000000

True-color (the one here is in JPEG.. BMP is not web-friendly)

(Adding the Mahou Shoujo Lyrical Nanoha emblem makes me the final author of this image. If it interests anyone, I got the original background from moe.imouto.org)

FileName: nanoha_wallpaper.bmp
FileSize: 768056
Format: BMP
Width: 640
Height: 400
Depth: 8
StorageType: truecolor
NumberOfColors: 0
ResolutionUnit: centimeter
XResolution: 78.720000
YResolution: 78.72000

Indexed

(Just so you wouldn't think that I prefer 2-D girls over 3-D.. xD I got this fine picture of my favorite seiyuu and J-Pop artist, Mizuki Nana, from Sankaku Complex's Seiyuu Idol Gallery)

FileName: isisuke_uljp01368.png
FileSize: 46755
Format: PNG
Width: 300
Height: 240
Depth: 8
StorageType: truecolor
NumberOfColors: 256
ResolutionUnit: centimeter
XResolution: 117.720000
YResolution: 117.720000

[Edit: Included part b of the activity.]

Unfortunately, Activity # 3 does not end here. What's left to do is to use the area calculation routine in Activity # 2 for a scanned image in Activity # 3. A scanned image is used so that we can have a sense of its physical area, and compare this area with the one obtained using the Green's Theorem.

I got the image of Japan from my old volumes of Grolier's Encyclopedia of Knowledge (1999, Vol. 10, p. 316, JAPAN article.) What I did next was to lasso the Hokkaido part of the map, and paint black on a another layer. I removed the layer with the original map, and it left me with a black object on a white background. Then, I inverted the colors to get the second image, and had my contour follower perform the routine to get the last image to the right.

Now here comes the part where I give the details, enough to give the reader an information overload. Wiki tells me that Hokkaido has a land area of 77,981.87 km². The map was drawn to a scale of 1:10,615,000--proper conversion tells me that 1mm in the map is 10,615,000km in physical units (this was confirmed with the use of a ruler xD). The image was scanned to a resolution of 200 dots per inch. Now all that's left to do is the math:

Hehe.. getting that formula to fit the length of this blog site was rather tricky. In any case, the area calculation routine gave me 18691.5 pixels. Now, if were to compare this to our theoretical value, we realize that we have an error of 56%. Why that large of an error? Simply because the routine's weakness is concave curvatures, something that can be quite prominent to an outline of an island.

Oh well, at least the contour follower gave me one hell of an outline. It almost looks like the original pattern. If there's one thing we can learn from this, it's the fact that this area estimation routine has its limits and that more can be done to actually fine-tune its estimation.

P.S. I think I'll have to settle for a ROMANIZED title for my blog post. Will change it the moment I get home. CSRC computers don't have IME. T_T [Edit: Done!] [Edit: Added the imfinfo descriptions.. xD]

The only trick here is to make sure that the filename points to the file and to make sure the file extensions are there. Yey! I get another 10. xD

答えは、どこですか？ (Activity # 2)

2009-06-23T10:58:00.008+09:00

[Edit: Prepared this for tomorrow.. that way the title for the post is in Japanese. xD]

We've been having difficulties with siptoolbox here at the CSRC--meaning this activity is post-poned until prior notice.

For now, we've been instructed to generate an image for Activity 2. I came up with this one:

The geometric shape in the binary image needs to be of known area, thus I generated a 320px x 320px image. I cut it diagonally in half, and flipped the inner triangle to obtain the image. Since the image can be reduced to a triangle of half the area of a 320px x 320px square, the area is simply:

320*320 = 102400*0.5 = 51200 square pixels

Apparently, we needed two more images, and here they are:

I set my convention to obtaining the area of the black-shaded regions. The are of the image at the left is simply the area of a triangle of length and base equal to 160px:

0.5*160 px*160 px = 12800 square pixels

Thus, the area of the image at the right is simply equal to half the area of the image subtracted by the area of the inner triangle:

51200 square pixels - 12800 square pixels
= 38400 square pixels

In order to compute for the experimental values, I used the function follow() found on the SIP toolbox. The important chunk of code to use would be:

image = gray_imread('activity_2c.bmp');
for i=1:320, j=1:320; image(i,j)=(image(i,j)*-1)+1; end;
[x,y]=follow(image);

and in order to compute the area, we use Green's Theorem:

n=length(x);
A=0;
for i=1:n-1;
Ai=0.5*(x(i)*y(i+1)-x(i+1)*y(i));
A=A+Ai;
end;

I have Neil to thank for checking my codes. In any case, here are the results:

I used this routine for plotting the follow contours:

xset('window',1)
xbasc()
plot2d(x,y,rect=[0,0,320,320]);

It is important to note that contour assumes the object to be white and its background black. Also, the routine cannot detect any shapes inside a contour, thus making it effective only for contours with defined edges. The area calculated via Green's Theorem yielded the following results:

Image A (unaltered) = 63521 [theoretical: 51200, error: 24.1%]
Image A (sum of B and C) = 50602 [theoretical: 51200, error: 1.17%]
Image A (difference of B and C) = 50840.5 [theoretical: 51200, error: 0.702%]
Image B = 12680.5 [theoretical: 12800, error: 0.934%]
Image C = 37921.5 [theoretical: 38400, error: 1.25%]

I get a 10 for making sure that follow() follows the contour I wanted. xD

AP１８６,　始まります。 (Activity # 1)

2009-06-18T11:37:00.015+09:00

The first activity for Physics 186 is Digital Scanning. Nope, the title might seem too simple but it doesn't end there--it's all about reconstructing images.

We started the activity by looking for some old, rugged hand-drawn plots in some old journals in the library last Tuesday. I picked Figure 11 from H. FESHBACH and E.L. LOMON's Boundary Condition Model of Strong Interactions (MIT, Cambridge), ANNALS of PHYSICS: 29, 19-17 (1964).

We had our plot scanned, and received it through e-mail about a night ago. Today, I started with some cropping and rotating tasks, letting loose my obsessive-compulsive. I figured that I'd have a harder time with it, if I don't crop it in the best way I can now.

After cropping, I loaded the image in paint and took note of the XY locations for the ticks (in pixels) on each of the axes. After which, I noted the XY locations for the points (also in pixels). I used OpenOffice.org Calc for storing my data.

I solved for the difference in the actual physical values and divided it by the difference in the X locations of two ticks. I repeated the procedure for the y-ticks and got the scaling factor needed for the points. I obtained a scaling factor of 0.38 for X and -0.04 for Y.

My actual physical position for the points was computed using : 400+[0.38*(x-value for points)] for X and for Y, 40+[-0.04*(y-value for points)]. Note that an initial value of 400 for X and 40 for Y were applied in order to meet the intercepts of the original plot.

What comes next would be the standard way of plotting XY scatter plots c/o Calc. Nothing special really. I believe that getting the area filled by the original plot would take my reader's attention. In itself, it's not special as well. After all, it's in the Help File (to quote, xD) :

Bitmap
Fills the selected object with the bitmap pattern that you click in the list. To add a bitmap to the list, open this dialog in OpenOffice.org Draw, click the Bitmaps tab, and then click Import.

I autoscaled my plot to make sure that the original image remains unaltered while I tinkered with my plot dimensions. I looked for the best values for my XY dimensions for the plot, added the Axes Titles, and poof! I got a plot that looks just like the image at the right.

Not bad for a first activity. It's actually really challenging to get those points to meet once the AUTOFIT feature is used. Not only can't you use the offset options (the ones you get when TILED is enabled), you also get stubborn sizing options for the Chart Area. But yeah, considering you already know how to do it, it'll probably be done in a matter of minutes. ^_^

I'm definitely getting a 10 for this one. xD

新しいサイト?!　無図化して。。　0_0

2009-06-16T21:59:00.009+09:00

Is this my new blog site? Nah.

This blog site was specifically made in partial fulfillment to the requirements for my Applied Physics 186 class.

It says here in the syllabus that 'Your blog report will contain all the outputs you produce from this course which include, but are not limited to, graphs, images and results, write-ups from short activities, etc.'

To those who knew of my real blog site, keep it to yourselves. xD

こんにちわ世界?!

2009-06-16T12:21:00.007+09:00

Who'd have thought this in itself would get a Wikipedia Article? Hmm.. As far as I can remember, I know of a few ways to do this..

Easiest would be in Python or BASIC:
print "Hello World."

In C it would be something like:
main() {
printf("Hello World.");
}

In FORTRAN, it can either be:
write (*,*) 'Hello World.'
or
print ('a') 'Hello World.'

Oh well.. so much for a sanity test to make sure everything's working.. But when it comes right down to it, it's not such a bad chunk of code to learn. xD

(NOT) An Introduction to SHIFT-JIS Programming

終わりだ (Activity # 19)

AP186のアクチヴィチ１３が、完了した!! (Activity # 13)

日本人彼女募集中。（Activity # 18)

「ai sp@ce」 のバイトは、どうしますか? (Activity # 17)

一番大切なものは? (Activity # 16)

好き? (Activity # 15)

もう。。わかんない。 (Activity # 14)

あのぉさ。。 大丈夫か? (Activity # 12)

この学校は、好きですか? (Activity # 11)

がんばってね。(Activity # 10)

違う。違うよ。(Activity # 9)

ほら朝よ。おきておきて。 (Activity # 8)

面白い?もちろんです（ない)。 (Activity # 7 )

もうあたし, 止まらんあい!! (Activity # 6)

七夕祭りへようこそ!! (Activity # 5)

あのぉさあ。。晩御飯は、おいしいですか? (Activity # 4)

それでいいですか? (Activity # 3)

答えは、どこですか？ (Activity # 2)

AP１８６, 始まります。 (Activity # 1)

新しいサイト?! 無図化して。。 0_0

こんにちわ世界?!

終わりだ　(Activity # 19)

「ai sp@ce」のバイトは、どうしますか? (Activity # 17)

好き?　(Activity # 15)

あのぉさ。。　大丈夫か? (Activity # 12)

この学校は、好きですか?　(Activity # 11)

もうあたし,　止まらんあい!! (Activity # 6)

あのぉさあ。。晩御飯は、おいしいですか?　(Activity # 4)

AP１８６,　始まります。 (Activity # 1)

新しいサイト?!　無図化して。。　0_0