Carnegie Mellon University

Data Privacy Course

JPEG Lab: Working with Hand Images

Objective

The objective of this lab is for you to learn how to work with JPEG image files within Java sufficient to work with hand geometry and fingerprint data.

Overview of activities

The in-class activities concern your working with a few hand images from the silhouette database. You will convert the images to pure black-and-white, remove the shaded borders from the sides, and compute an image that shows only the outline of the hand.

Part I. JPEG Notes

JPEG images consists of pixels displayed in a rectangular format having a given width and height. On left below is a JPEG image (blown up by a factor of 100 with borders addded) representing an image having 4 pixels across and 2 pixels down. To the right of the image is a listing of the pixel values, numbered left to right, top down. [This image was made using this Java code.]

0 1 2 3

4 5 6 7
For manipulation in the Java code presented on the links in this Lab, JPEG images are read from disk and then stored in a one-dimensional integer arrays for processing. In one version of the one-dimensional array, each pixel is a cell in the array. Pixels appearing in the rectangular view, left to right and top to bottom, are stored in the on-dimensional array. The table above shows how the pixels would be referenced in the rectangular view and the table below shows the cell positions those same pixels would be stored in the one-dimensional array.

0

1

2

3

4

5

6

7

Each pixel value is a 24-bit field which decomposes into the concatenation of 3 8-bit values (0 to 255). These three 8-bit values represent the amount of red, green and blue appearing in the pixel color. The first 8 bits are the amount of blue, the second 8-bits represent the amount of green, and the last 8 bits are the amount of red.

In the sample JPEG image above, the following colors are being displayed in the cells.

0 (blue=255, green=0, red=0)	1 (blue=0, green=255, red=0)	2 (blue=0, green=0, red=255)	3 (blue=255, green=255, red=255)
4 (blue=100, green=100, red=100)	5 (blue=200, green=100, red=200)	6 (blue=100, green=200, red=200)	7 (blue=0, green=0, red=0)

As shown above, 0,0,0 is black and 255,255,255 is white. In the other version of the one-dimensional array used in the Java code, each pixel uses 3 consecutive cells in the array, rather than one. In this version, the first cell assigned to th pixel stores the integer value for blue, the second for green, and the third for red.

Part II. Binarization of an Image

Visit the hands database and select three images for processing. You will use these images throughout these activities. Here is a link to the silhouette. Hands database 2.
Place each of your images in a directory called step0, which should be one level down from the place where you will compile and work with your Java code.
Convert the images to pure black-and-white. If you look at the images carefully, you will see they contain many shades of colors. To convert them to black-and-white, you will use Java code.
In order to use this code, you will need a subdirectory to the location of your Java code, which for convenience you should name step1. Below is a copy of the header comment from the file.
```
 ** This application reads the JPEG files in the indir and writes a 
 ** corresponding JPEG file in the outdir with all pixel values
 ** above a threshold stored as black and all below stored as white. 
 ** Threshold should be a value between 0 and 255.
 ** The original files remain unchanged.  Files not ending
 ** in .jpg are ignored. 
 **  
 ** Usage: java JPGBinarizeAll threshold indir outdir
 **
 ** Usage for large files: -mx180m JPGBinarizeAll threshold indir outdir
 **
 ** Author: L. Sweeney, For: Privacy Technology, Date: 2/2006.
```
Run the program using the image files in the step0 directory and have the results stored in the step1 directory. View the resulting files. Also, take a look at the code and see how it works. As time permits, we will discuss in class.

Part III. Remove side borders

If you examine the images, you will see that there is a dark border on the left and right sides of each image. Use the following Java code to remove these borders.

In order to use this code, you will need a subdirectory to the location of your Java code, which for convenience you should name step2. Below is a copy of the header comment from the file.


 ** This application reads the JPEG files in the indir and writes a 
 ** corresponding JPEG file in the outdir with the side borders removed.
 ** The left and right sides of an image are assumed o have dark bands
 ** which are re-colored white in the new JPEG files. 
 ** The original files remain unchanged.  Files not ending
 ** in .jpg are ignored. Assumes that only borders are dark from the top
 ** of the image to the bottom of the image for any pixel column.
 **  
 ** Usage: java JPGRemoveBorderAll indir outdir
 **
 ** Usage for large files: -mx180m JPGRemoveBorderAll indir outdir
 **
 ** Author: L. Sweeney, For: Privacy Technology, Date: 2/2006.

Run the program using the image files in the step1 directory and have the results stored in the step2 directory. View the resulting files. Also, take a look at the code and see how it works. As time permits, we will discuss in class.

Part IV. Produce an outline of the image.

Instead of a black-and-white colored image, we want to show only the edge or outline of the hand. Use the following Java code to remove these borders.

In order to use this code, you will need a subdirectory to the location of your Java code, which for convenience you should name step3. Below is a copy of the header comment from the file.


 ** This application reads the JPEG files in the indir and writes a 
 ** corresponding JPEG file in the outdir that shows the outline
 ** of the image using edge detection.
 ** The original files remain unchanged.  Files not ending
 ** in .jpg are ignored. 
 **  
 ** Usage: java JPGEdgeDetect indir outdir
 **
 ** Usage for large files: -mx180m JPGEdgeDetect indir outdir
 **
 ** Author: L. Sweeney, For: Privacy Technology, Date: 2/2006.

Run the program using the image files in the step2 directory and have the results stored in the step3 directory. View the resulting files. Also, take a look at the code and see how it works. As time permits, we will discuss in class.

You will want to run the program with different Kernels to see how they transform the image differently. We will examine and discuss these in class. Various Kernels are provied within the code and commented out.

Part IV. Finding anchor points in the hands image

One of the possible tasks you may elect to do in Assignment 4 concerns writing a Java program that automatically locates anchor points within hand silhouette images. Achieving this task can be done by extending the work performed in this Lab. You will want to compute the sloppe of the outline provided in Part III above as you move around the outline of the hand. Anchor points tend to appear at particular changes in slope. To compute the length of fingers, you will want to draw a line that is not an anchor point, but that cuts across the tops of the fingers, where the left top and right top of each finger is identified as an anchor point.

To produce this code, do NOT want just run each of these steps sequentially. It will be too slow! Speed matters. Part of your task is to write code that runs reasonably fast (e.g., using few passes through the data). So, you will likely want to mix and bundle the code together. You may alternatively use an entirely different code. Afterall, Java provides support for JPEG images directly and you are free to use these classes as well.

Spring 2006 Privacy Technology
Professor: Latanya Sweeney, Ph.D. [latanya@dataprivacylab.org]