Bresenham Circle No Multiplication

var canvas:BitmapData = new BitmapData(400, 400, false, 0xCCCCCC);
addChild(new Bitmap(canvas));

drawCircle(200,100, 50);

// y, y radius, color
function drawCircle(xp:Number,yp:Number, radius:Number, col:uint =0x000000):void {
	var balance:int;
	var xoff:int;
	var yoff:int;
	xoff=0;
	yoff=radius;
	balance=- radius;

	while (xoff <= yoff) {
		canvas.setPixel(xp+xoff, yp+yoff, col);
		canvas.setPixel(xp-xoff, yp+yoff, col);
		canvas.setPixel(xp-xoff, yp-yoff, col);
		canvas.setPixel(xp+xoff, yp-yoff, col);
		canvas.setPixel(xp+yoff, yp+xoff, col);
		canvas.setPixel(xp-yoff, yp+xoff, col);
		canvas.setPixel(xp-yoff, yp-xoff, col);
		canvas.setPixel(xp+yoff, yp-xoff, col);

		if ((balance += xoff++ + xoff) >= 0) {
			balance-=--yoff+yoff;
		}
	}
}

The above demos a circle drawing algorithm. This will draw an outlined circle with no fill. This implementation doesn’t use multiplication.

Using setPixel to draw primitive shapes can be a good learning experience. I found this basic implementation of the Bresenham Circle algorithm a few years back and lost the original link…. I dug around for a good hour trying to find the original but to no avail. So if someone recognizes this interesting implementation …. let me know 🙂

The original code was written in java I think.

If your curious. The standard implementation I keep finding online looks something like this:

// ported from http://www.codeuu.com/Bresenham_Circle
function drawCircle(cx:Number, cy:Number, r:Number, col:uint):void{
	var xp:int  = 0, yp:int= r ;
	var d:int = 3 - (2 * r);
	
	while(xp <= yp){
		
		canvas.setPixel(cx+xp,cy+yp,col);
		canvas.setPixel(cx+yp,cy+xp,col);
		canvas.setPixel(cx-xp,cy+yp,col);
		canvas.setPixel(cx+yp,cy-xp,col);
		canvas.setPixel(cx-xp,cy-yp,col);
		canvas.setPixel(cx-yp,cy-xp,col);
		canvas.setPixel(cx+xp,cy-yp,col);
		canvas.setPixel(cx-yp,cy+xp,col);
		
		if (d<0){
			d += (4*xp)+6;
		}else{
			d += (4*(xp-yp))+10;
			yp -= 1;
		}
		xp++;
	}
	
}

I did a few speed tests against the first one that doesn’t make use of multiplication and it is only ever so slightly faster….