    int i;
    struct point pt;
 
-   enum gridColorspace 
-   {
-      RGB = 1,
-      HSL
-   };
-
-   enum axisColorspace
-   {
-      RED = 1,
-      GREEN,
-      BLUE,
-      HUE,
-      SAT,                      // Saturation
-      LIGHT                     // Lightness
-   };
-   
-   typedef struct
-   {
-      gridColorspace colorspace;  
-      axisColorspace xAxisSpace, yAxisSpace; 
-
-      // Axis values may be non-linear (e.g., intensity)
-      union
-      {
-         int axisIntValues[GRID_SIZE_X];
-         float axisFloatValues[GRID_SIZE_X];
-      } x;
-      
-      union
-      {
-         int axisIntValues[GRID_SIZE_Y];
-         float axisFloatValues[GRID_SIZE_Y];
-      } y;
-   } runParamTuple;
-   
-   // TODO: put the following setup in setup() ----------------------------------------------------------------
-   
-   // Gonna cheat, since we know we have a square grid:  same values on each axis.
-
-   int ledBrightness[GRID_SIZE_X]; // RGB intensity
-   float dLedBrightness = 1.0 / (GRID_SIZE_X - 1);
-   float dLightness = 1.0 / (GRID_SIZE_X + 1); // Will drop lightness = 0 (black) and 1 (white), since that results in
-                                               // an entire row/column being all the same (fully off or fully on).
-   float lightness[GRID_SIZE_X]; // HSL
-   float saturation[GRID_SIZE_X]; // HSL
-   
-   ledBrightness[0]               = 0;
-   ledBrightness[GRID_SIZE_X - 1] = 255;
-
-   saturation[0]                  = 0;
-   saturation[GRID_SIZE_X - 1]    = 1;
-
-   float v;
-
-   clearStrip();
-   
-   for (i = 1; i < GRID_SIZE_X - 1; i++)
-   {
-      v = i * dLedBrightness;   // Linear
-      saturation[i] = v;
-      v = pow( v, exponent);    // Non-linear
-      ledBrightness[i] = v * 256; // Don't need to constrain; won't get close to 255.
-   }
-
-   for (i = 0; i < GRID_SIZE_X; i++)
-   {
-      v = (i + 1) * dLightness; // See dLightness.
-      v = pow( v, 3.45);
-      lightness[i] = v;
-   }
-   
-
-   // // Debug:
-   // for (i = 0; i < GRID_SIZE_X; i++)
-   // {
-   //    pt = {i, 4 } ;
-   //    rgb = hsl2rgb( 0, saturation[i], 0.5); // red/pink
-   //    c = Color( rgb.r, rgb.g, rgb.b);
-   //    strip.setPixelColor( point2seq( pt, org, gridSize), c);
-
-   //    pt = {i, 3 } ; 
-   //    rgb = hsl2rgb( 120, 0.5, lightness[i]); // greenish
-   //    c = Color( rgb.r, rgb.g, rgb.b);
-   //    strip.setPixelColor( point2seq( pt, org, gridSize), c);
-
-   //    pt = {i, 2 } ;
-   //    c = Color( 0, 0, ledBrightness[i]); // blue
-   //    strip.setPixelColor( point2seq( pt, org, gridSize), c);
-   // }
-   // strip.show();
-   // delay( 15000);
-
-   runParamTuple runParams[6] = { { RGB , RED   , GREEN } ,  // 0
-                                  { RGB , BLUE  , RED }   ,  // 1
-                                  { RGB , GREEN , BLUE }  ,  // 2
-                                  { HSL , HUE   , SAT }   ,  // 3
-                                  { HSL , HUE   , LIGHT } ,  // 4
-                                  { HSL , SAT   , LIGHT } }; // 5
-   
-   // RGB
-   for (i = 0; i < 3; i++)
-   {
-      copyIntArray( runParams[i].x.axisIntValues, ledBrightness, GRID_SIZE_X);
-      copyIntArray( runParams[i].y.axisIntValues, ledBrightness, GRID_SIZE_X);
-   }
-   
-   // HSL
-   float dHue = 60.0; // 360.0 / GRID_SIZE_X;
-   for (i = 0; i < GRID_SIZE_X; i++)
-   {
-      runParams[3].x.axisIntValues[i] = (int) (i * dHue + 0.5);
-      runParams[4].x.axisIntValues[i] = (int) (i * dHue + 0.5);
-   }
-   copyFloatArray( runParams[3].y.axisFloatValues, saturation, GRID_SIZE_X);
-   copyFloatArray( runParams[4].y.axisFloatValues, lightness, GRID_SIZE_X);
-   copyFloatArray( runParams[5].y.axisFloatValues, lightness, GRID_SIZE_X);
-
-   copyFloatArray( runParams[5].x.axisFloatValues, saturation, GRID_SIZE_X);
-
-   // (setup ends) ----------------------------------------------------------------
-   
-   int run;
-
-   // Label the runs for x and y axes: rg, br, gb
-   // 0, 1, 2
+   int run;                     // We're going to do a series of "runs", in which we pick the axes, set the third
+                                // component to a constant and then generate values for each grid point.
 
    for (run = 0; run < 6; run++)
    {
-      runParamTuple rp = runParams[run];
+      struct runParamTuple rp = runParams[run];
       for (y = 0; y < GRID_SIZE_Y; y++)
          for (x = 0; x < GRID_SIZE_X; x++)
          {

   int r,g,b;
};

// ---------------------------------------------------------------------------------------------------------------------
//  globals
// ---------------------------------------------------------------------------------------------------------------------

//  rotatingColorAxes
// ---------------------------------------------------------------------------------------------------------------------

// Setup for rotationColorAxes()
void setupRotatingColorAxes()
{
   int i;
   
   ledBrightness[0]               = 0;
   ledBrightness[GRID_SIZE_X - 1] = 255;

   saturation[0]                  = 0;
   saturation[GRID_SIZE_X - 1]    = 1;

   clearStrip();
   
   for (i = 1; i < GRID_SIZE_X - 1; i++)
   {
      v = i * dLedBrightness;   // Linear
      saturation[i] = v;
      v = pow( v, exponent);    // Non-linear
      ledBrightness[i] = v * 256; // Don't need to constrain; won't get close to 255.
   }

   for (i = 0; i < GRID_SIZE_X; i++)
   {
      v = (i + 1) * dLightness; // See dLightness.
      v = pow( v, 3.45);
      lightness[i] = v;
   }
   

   // // Debug:
   // for (i = 0; i < GRID_SIZE_X; i++)
   // {
   //    pt = {i, 4 } ;
   //    rgb = hsl2rgb( 0, saturation[i], 0.5); // red/pink
   //    c = Color( rgb.r, rgb.g, rgb.b);
   //    strip.setPixelColor( point2seq( pt, org, gridSize), c);

   //    pt = {i, 3 } ; 
   //    rgb = hsl2rgb( 120, 0.5, lightness[i]); // greenish
   //    c = Color( rgb.r, rgb.g, rgb.b);
   //    strip.setPixelColor( point2seq( pt, org, gridSize), c);

   //    pt = {i, 2 } ;
   //    c = Color( 0, 0, ledBrightness[i]); // blue
   //    strip.setPixelColor( point2seq( pt, org, gridSize), c);
   // }
   // strip.show();
   // delay( 15000);

   // RGB
   for (i = 0; i < 3; i++)
   {
      copyIntArray( runParams[i].x.axisIntValues, ledBrightness, GRID_SIZE_X);
      copyIntArray( runParams[i].y.axisIntValues, ledBrightness, GRID_SIZE_X);
   }
   
   // HSL
   for (i = 0; i < GRID_SIZE_X; i++)
   {
      runParams[3].x.axisIntValues[i] = (int) (i * dHue + 0.5);
      runParams[4].x.axisIntValues[i] = (int) (i * dHue + 0.5);
   }
   copyFloatArray( runParams[3].y.axisFloatValues, saturation, GRID_SIZE_X);
   copyFloatArray( runParams[4].y.axisFloatValues, lightness, GRID_SIZE_X);
   copyFloatArray( runParams[5].y.axisFloatValues, lightness, GRID_SIZE_X);

   copyFloatArray( runParams[5].x.axisFloatValues, saturation, GRID_SIZE_X);
}

// Show two of three axes of RGB and HSL colorspaces, with the third axis held to some reasonable constant, blending
// those values into a single unique colorspace point.  Rotate among the choice of which two axes to use (e.g.,
// red/green, hue/saturation, etc.).
void rotatingColorAxes()
{
   int x,y;
   int dColor = 64;
   float d1 = 1.0 / (5-1);      // 0..4 ==> 0..1.0 in 5 steps
   struct rgbTriple rgb;
   int r,g,b;
   float rf, gf, bf;
