Tracing images to create Box2D objects - part 1

	/*
	* Helper function to determine the alpha value of a pixel on the image where the variable img is a BufferedImage
	*/
	public boolean hasAlpha (int x, int y) {
		if((img.getRGB(x, y) >>> 24)>0)
			return true;
		return false;
	}
	/*
	 * Test a point to see if the alpha is greater than 0. If the point falls outside the image return false for no alpha.
	 */
	public boolean pointHasAlpha (int x, int y) {
		if(x<0||x>(img.getWidth()-1)||y<0||y>(img.getHeight()-1)) {
			return false;
		} else {
			if(hasAlpha(x,y))
				return true;
			else
				return false;
		}
	}
 
	/*
	* Test to see if a pixel on the image is a boundary pixel. 
	*/	
	public boolean isBoundary (int x, int y) {
 
		// If this point doesn't have alpha we're not interested
		if(!pointHasAlpha(x,y))
			return false;
 
		// Look at the 8 adjoining points, if at least one has alpha then 
		// it's a boundary
		for(int i=-1; i<2; i++)  {
			for(int j=-1; j<2; j++) {
				if(!pointHasAlpha(x+i, y+j)) 
					return true;
			}	
		}
 
		// If this point has alpha and all of the adjoining points
		// have alpha then it's not a boundary
		return false;
	}

        // function which loops over the image file until it identifies the first boundary pixel
	public int loopOverImage () {
		if(img!=null) {
			// Loop until we find a boundary pixel
			for (int cx=0;cx<img.getWidth();cx++) {  
		        for (int cy=0;cy<img.getHeight();cy++) {
		        	if(isBoundary(cx, cy)) {
		        		traverseBoundary(cx, cy);
		        		return 0;
		        	}
		        }
			}
		} else {
			LogMessage.log(TAG, "loopOverImage", "image null");
		}
		return 0;
	}
 
	public void traverseBoundary (int x, int y) {
 
		Pixel start = new Pixel(x,y,Pixel.WEST,Pixel.CENTRE);
		Pixel next = start;
		Pixel old = new Pixel(-1,-1);
 
		points.add(start.toVertex());
 
		// Set arbitary limit to length of circumference
		for(int i=0; i<10000000; i++) {
			// Save off the last position
			old = next;
 
			// Find the next clockwise boundary pixel
			next = findNextBounearyPoint(next);
 
			// Set the search start point as the previous pixel
			// to avoid loops and continue traversing the shape
			// in the same direction i.e.
 
			// edge:  x  first point     second point  34x
			//       x            23x                  2x
			//      x             1x                   1
 
			// In this diagram the numbers represent the order
			// in which the neighboring points are tested. We
			// Always start with the previous point found.
			next.setNSP(old.sub(next));
 
			// When we get back to the start break the loop 
			if(next.equals(start))
				break;
 
			points.add(next.toVertex());
 
		}
	}
 
	public Pixel findNextBounearyPoint(Pixel p) {
		// Move clockwise around from previous point until we
		// hit another boundary cell
		for(int i=0; i<9; i++) {
			// Find the next pixel clockwise - the pixel remembers the last
			// position tested and will increment to the next position
			Pixel next = p.clockwise();
			if(isBoundary(next)) {
				return next;
			}
		}
		LogMessage.log(TAG, "findNextBoundaryPoint", "Error next point not found");
		return null;
	}

public class Pixel {
 
	public static final int NORTH = 1;
	public static final int SOUTH = -1;
	public static final int EAST = 1;
	public static final int WEST = -1;
	public static final int CENTRE = 0;
 
	public int x;
	public int y;
 
	private int nspX = -1;
	private int nspY = 0;
 
	public Pixel(int x, int y) {
		this.x = x;
		this.y = y;
	}
 
	public Pixel(int x, int y, int nspX, int nspY) {
		this.x = x;
		this.y = y;
 
		this.nspX = nspX;
		this.nspY = nspY;
	}
 
	public void set(int x, int y) {
		this.x = x;
		this.y = y;
	}
 
	public Pixel add(Pixel p) {
		return new Pixel(x+p.x, y+p.y);
	}
 
	public Pixel sub(Pixel p) {
		return new Pixel(x-p.x, y-p.y);
	}
 
	public Vec2 toVec2 () {
		return new Vec2(x,y);
	}
 
	public Vertex toVertex () {
		return new Vertex(x,y);
	}
 
	public Pixel mult (int i) {
		return new Pixel(x*i, y*i);
	}
 
	public String toString () {
		return "x:"+x+" y:"+y;
	}
 
	public void setNSP (Pixel p) {
		nspX = p.x;
		nspY = p.y;
	}
 
	public Pixel clockwise () {
		Pixel nsp = clockwise(nspX, nspY);
		nspX = nsp.x;
		nspY = nsp.y;
		return add(nsp);
	}
 
	public Pixel clockwise(int x, int y) {
		return clockwise(new Pixel(x,y));
	}
	public Pixel clockwise (Pixel sp) {
		if(sp.x==WEST) {
			if(sp.y==SOUTH)
				return new Pixel(WEST,CENTRE);
			else if(sp.y==CENTRE)
				return new Pixel(WEST,NORTH);
			else if(sp.y==NORTH)
				return new Pixel(CENTRE,NORTH);
		}
 
		if(sp.x==CENTRE) {
			if(sp.y==SOUTH)
				return new Pixel(WEST,SOUTH);
			else if(sp.y==NORTH)
				return new Pixel(EAST,NORTH);
		}
 
		if(sp.x==EAST) {
			if(sp.y==SOUTH)
				return new Pixel(CENTRE,SOUTH);
			else if(sp.y==CENTRE)
				return new Pixel(EAST,SOUTH);
			else if(sp.y==NORTH)
				return new Pixel(EAST,CENTRE);
		}
		return null;	
	}
 
		public boolean equals (Pixel p) {
			if(x==p.x && y==p.y)
				return true;
			return false;
		}
	}