There was this stupid hackish thing I was doing when grapping the image
buffer storing the last render.  Instead of getting it by allocating
the buffer again, store the pointer in a different state variable.  Now
you only call allocate when you need a new buffer.

With this change, you only call the state buffer allocate functions when
you want a fresh buffer.  In debug mode, fill the values with 0xDC to
make it more obvious when I create an error when reusing buffers.

Does not do anything yet.

The gcc compiler wants to optimize a conditional that is always true,
but only if we assume that there is no signed overflow.  (That is,
there are no negitive numbers.)  It happens to be true wtih the numbers
I give, so do a bunch of casts to tell the compiler that.

This was the (hopefully) one place where the radix-k code was still
using the whole group for determing splits rather than the largest
power of 2 size.

In most places malloc is called, check to make sure that the returned
pointer is not null, and emit an out of memory error if it is.

Found several places where free was not always called for all allocated
memory.

When possible, remove direct calls to malloc in the code and replace
with the state variable memory management.

Previously, the strategy always returned an image for the display
tile, and the calling icetDrawFrame checked the size of that returned
image against the expected size of the display.  With the uncollected
option, any process can return an image for any tile.  Thus, we need
to check against the valid tile rather than the display tile.  If
collection is on, also check to make sure the valid tile is the same
as the display tile.

There was too much regularity in the colors of the partitions.  These
changes space out the colors differently so that it looks more scattered
and random (although it is not really).

The uncollected composite option is mostly for testing purposes to
compare collected and uncollected times.  I don't expect this
option to be used much, if at all, in practice.  I have to admit
that I have not fully exercised this code.  In fact, much of it
I have not yet run and may never run.

Makes little sense in other strategies.

Not implemented yet.  All strategies still collect images.

Incoporates fixes for improper sizes of partitions when splitting images.

Incoporates fixes with the sizes of split partitions.

In the actual pow-2 composite, was only keeping track of the initial
group size, not the largest group size of any.

There was an issue with the tree composites in radix-k where when
the local process did not have a partner on level 0, it never got
promoted to level 1.

Previously radix-k composited images as they came in if it could.  This
change forces the images to be composited in a tree order to minimize
copying of non-overlapping pixels.

I was using 16 bit run lengths to ensure that I never inflated images,
even when pixels only took up 32 bits.  However, 16 bits limits the
maximum size of the run lengths.  Thus, it inflated images (albiet by
a small amount) in the average case when all pixels were averaged, and
there is lots of code to break up the run lengths and copy pixels
individually.

This change means that some images can expand up to 50%, but only in
cases that probably never happen.  The worst side effect of this
change is that IceT must allocate this extra 50% in buffers just in
case.  I could probably get around this by refusing to use run
lengths of size 1.  However, that would again complicate code,
especially in cases where you are copying active pixels (and hence
have a special case of inserting background pixels).

I just copied from the decompress template, so the DT abbrivation
makes no sense.