Crop

To run crop from command line: ./image -input ./sampleimgs/stromanthe.jpg -crop 100 150 250 350 -output ./out/stromanthe/stromanthe_crop_-1_-1_100_200.jpg

My implementation handles out of range parameters by truncating to the size of the image, as shown in below sample results.

Edge Detect

Rotate + Sampling

Scale + Sampling

Scale: 5 x 5 (Images are fitted to the web page here)

In the case of up sampling (scaling up), bi-linear has the best performance as shown in the moon images above and the edges shown below.

Updated 3/2: 10x scale with corrected Gaussian Sampling method

Lossy Compression

• I implemented binary ppm file write/read with 1 bit to 8 bit image data packing. Combined with Floyed Steinberg Dither. I can achieve compressed images that are visually indistinguishable from the original image at 4 bits. And the size of the .ppm file is 14% of the original file.

• However, my compression implementation is only a first stab. In the future I would like to implement what the professor had shown in class: the LCC or YUV color scheme with efficient information sampling (L/Y at 8 bit with information for each sample, while CC/YY at 1~2 bits and information for each 8x8 block). Then pack the information into my binary file.

Art Contest

Write Up

This was a fun project for me. The visual aspect of the project makes it especially appealing. The data structure of the component/pixel/image class makes it easy to implement features. I love how clean the data is structured. I also love how the project makes me implement what the professor had talked about in the class and not everything is spoon fed to us. It had just the right amount of challenge for me.

The simple features such as crop, quantize, and extract channel did not take effort to implement. Most other features took me some time, either because of a simple miscalculation/bug in my initial attempt or the corner/border cases require some thinking. The part that took me the most effort is the binary file implementation for lossy compression. I ended up spending a half day figuring out how to pack a varying number of bits into a byte. Given time, I would like to further my lossy compression implementation by implementing the LCC color scheme and fix L at 8 bits, and the other two channels at 1 or 2 bits, before packing bits into the binary file. Another idea I would like to explore in lossy compression is to process the images in the frequency domain to take advantage of most images' limited bandwidth representation. I also spent a fair amount of time on trying to come up with an authentic way to create an artistic representation of the image, and most of my attempts fell short.

For the algorithms implemented, it is amazing how well dithering preserved information during quantization. Among the 3 sampling methods, Gaussian is the best filter for down sampling and bi-linear is the best filter for up sampling. To create artistic representation of an image, I found no method is one size fits all. What makes one image look good, may look too grainy or too dark or too ... on another image. I picked some of the better ones for the contest.

Overall, this was a very fun and useful project for me and really helped me grasp the concepts Dr. Guy had taught us.

3/2 update: During Dr. Guy's office hour, I realized that my Gaussian sampling method was not correctly implemented. In my original implementation, my Gaussian sampling filter will always center at the center of a pixel. This method works fine for down sampling, but for up sampling, it ended up sampling the same pixels with the same weights for a block of pixels. This is the main reason for the poor performance of the Gaussian sampling method on large up sampling. I re-implemented the Gaussian sampling method, The down sampling results does not change much, but the up sampling performance of the new gaussian filter is as good as the bilinear method.