Single-shot wallSmoothing

===========================
Recently, I wrote a distance-finding method for a problem I came across.
The problem:

As a robot in the arena, if you traveled directly forward until you hit a wall (So, given a point and a heading), how far would you travel before you hit that wall?

There's the simple solution that walks the robot 1 pixel at a time down that heading until collision is detected, but it doesn't scale well if needed often.

But I propose a non-iterative solution; hidden in cosine similarity.

     1) Check if facing right or left
     2) Measure your known X, solving for lateral distance to wall.
     2.1) Apply cosine similarity to heading and absolute angle of wall in that direction.
     3) Check if facing up or down
     4) Measure vertical distance from wall
     4.1) Apply cosine similarity to that.

//At this point there's a pretty good chance you're gonna run across a huge number or infinity.
//Luckily, only one of them will be super huge, the other is our solution.
5)It's the closest wall that matters, so take the minimum between the horizontal and vertical solutions.

<pre>
        static double calcWallSpace(final Point eCenter, double eGoing) {
		eGoing = Utils.normalAbsoluteAngle(eGoing);
		final double wallDistLat = eGoing < Helpers.PI ? (Identity.PLAY_WIDTH+18d-eCenter.getX()) / (Helpers.cos((Helpers.PI/2d - eGoing)))
			: eCenter.getX() / (Helpers.cos((3d*Helpers.PI/2d - eGoing)));
		eGoing = Utils.normalRelativeAngle(eGoing);
		final double wallDistVirt = Math.abs(Utils.normalRelativeAngle(eGoing)) < Helpers.PI / 2d  ?
				(Identity.PLAY_HEIGHT+18d-eCenter.getY()) / (Helpers.cos(eGoing)) : eCenter.getY() / (Helpers.cos(Helpers.PI - eGoing));
		 return(float)(Math.min(wallDistLat, wallDistVirt) / Identity.MAX_DIST);
	}
</pre>