Equation for a sphere Math checking

So based on a single location this code will make a sphere with the pBlock as the center.

PHP:

 
public void act(pBlock pB) {
double bsd = this.bp.brushSize;
int bsi = (int) Math.round(bsd);
 
//Y
for (int by = bsi; by > -bsi; by--) {
double xzRadius = HalfCircleFunction(bsd,by);
int xzRadiusi = (int) Math.round(xzRadius);
for(int bx = xzRadiusi; bx > -xzRadiusi; bx--) {
double zLength = HalfCircleFunction(xzRadius, bx);
int zLengthi = (int) Math.round(zLength);
for(int bz = zLengthi; bz > -zLengthi; bz--) {
addBlockRelative(pB,bx,by,bz);
}
}
}
 
perform();
}
 
private Double HalfCircleFunction(Double radius, int x){
return Math.sqrt((radius*radius)-(x*x));
}


often times the circles are not symmetrical is my problem.

 

I use this function to make planets at my multiworld plugin:

Code:java

/**
	 * Numbers used to make X^2 faster 
	 */
	public static final int[] SQUARES =
	{
		0, 1, 4, 9, 16,
		25, 36, 49, 64, 81, 100, 121, 144, 169, 196,
		225, 256, 289, 324, 361,
		400, 441, 484, 529, 576,
		625, 676, 729, 784, 841,
		900// Why do I not use the Matyh class, because this code is old!
	};
 
	/**
	 * Makes the input positive
	 * @param i the input
	 * @return The positive input
	 */
	private int makePositive(int i)
	{
		if (i < 0)
		{
			return 0 - i;
		}
		return i;
	}
protected void makePlanet(final World workingWorld,
				  final int planetX,
				  final int planetY,
				  final int planetZ,
				  final int size,
				  final byte blockTop,
				  final byte blockDown,
				  final byte blockSpecial)
	{
		int mainDistance;
		boolean isTop = true;
		Block workingBlock;
 
 
		int posAX = planetX - size;
		int posAY = planetY - size;
		int posAZ = planetZ - size;
		int posBX = planetX + size;
		int posBY = planetY + size;
		int posBZ = planetZ + size;
		int comparatorSize = SQUARES[size];
		for (int x = posAX; x <= posBX; x++)
		{
			for (int z = posAZ; z <= posBZ; z++)
			{
				mainDistance = SQUARES[this.makePositive(x - planetX)] + SQUARES[this.makePositive(z - planetZ)];
				if (mainDistance <= comparatorSize)
				{
					isTop = true;
					for (int y = posBY; y >= posAY; y--)
					{
						if (comparatorSize < mainDistance + SQUARES[this.makePositive(y - planetY)])
						{
							continue;
						}
						workingBlock = workingWorld.getBlockAt(x, y, z);
						if (isTop)
						{
							workingBlock.setTypeIdAndData(blockTop,(byte)0,false);
							isTop = false;
						}
						else
						{
							workingBlock.setTypeIdAndData(blockDown,(byte)0,false);
						}
 
					}
				}
 
			}
		}
		workingWorld.getBlockAt(planetX, planetY, planetZ).setTypeIdAndData(blockSpecial,(byte)0,false);
 
	}

mayby you can edit it, so it does exactly what you want whit circles

 

do:

Code:

double volume = Math.PI * radius * radius * radius / 3 / 4;

(this gives you an integer of the volume of a sphere)
At least, thats what Wolvereness told me on irc yesterday

 

double volume = Math.PI * radius * radius * radius * 4 / 3;

 

oh, just flip the 3 and the 4....

 

ferrybig I think I might try your SQUARES idea to test if it becomes more efficient. Otherwise I think I was wrong to ask for people's methods of achieving this task because I don't want to figure out how to use these methods Thanks Jnorr44 but I don't know what that is for