MEASUREMENTS and COORDINATE SYSTEM
===================================
128x128x128 = dimension of workspace for planner
each cell represents a 3cm cube

armsim: coordinate system 
	x = [-530 ..  530]
	y = [-530 ..  530]
	z = [   0 .. 1060]

4in = 10.16cm / 3 = 3.387cells * 1060 / 128 = 28.05

planner/linkmeasures.h:
	Units are cm/3  i.e. 4in = 3.387cells

Note:  I have converted each cube in the 128x128x128 grid to be 3cm
       instead of 2cm.


JOINT ANGLE LIMITATIONS
=======================

Joint	   Range	"Home"
-----   ------------    ------
  1	-180 to +180	    0
  2	  +3 to +135	 +122
  3	-180 to +180	    0
  4	-175 to  -25	 -165
  5	-360 to +360	    0
  6	-170 to  +35	  -44
  7	-360 to +360	    0


HOME POSITION (Minimizes Torque on Joints)
==========================================

Joint	"Home"
-----   ------
  1         0
  2	 +122
  3	    0
  4	 -165
  5	    0
  6	  -44
  7	    0

End effector position in the 128x128x128 space is (104, 64, 51)
assuming robot is mounted at (64,64,48) with the initial link potruding
in the X direction.


TO TAKE A SNAPSHOT OF A WINDOW ON AN SGI
========================================

% snapshot


PLANNER
=======
Changed LINKSIZE to 0.3 in globalconst.h


DISTRIBUTED PLANNING
====================

Issue: If one copy of the planner is launched on each of 40+ machines
simultaneously, we will hit the file server and network very hard.
This means 40+ processes all pulling 6Mb worth of data off the server
over the network ... simultaneously.

Out of courtesy to my fellow coworkers I haven't actually tried to do
this.  Instead, I have introduced an arbitrary delay of 7 seconds
between the start of each process.  This should give each process
enough time to load it's data before the next process starts up.

This is friendly to the network, but causes overall performance to be
degraded.  With this setup, we simply can't find good paths in
fractions of a second.

On an arbitrary machine it takes roughly 6 seconds to load 6Mb worth
of data.  If we dispense with the pre-computations, it takes roughly
15 seconds to calculate and generate this same data on this same
machine.  If we did this, there would be a latency of at least 15
seconds for a Pentium-90 class workstation before any paths would be
generated.

The point of precomputing the heuristic functions and workspace
bitmaps beforehand was to improve overall performance.  However, when
running the planner in a distributed environment the network/server
contention problems with loading this data has the opposite effect.