// plot8d.java plot  8d data
//             reads from stdin, first line  8 nx ny nz nt nu nv nw np
//                               many lines  x y z t u v w p U
//                               sorted x first, y next, ...
//                               one space separator
//  java -cp . plot8d <  file.dat > file.out
//                               converted from plot6d.java

import java.io.*;
import java.awt.*;
import java.awt.event.*;

public class plot8d extends Frame
{
  // mouse and display variables
  int xm, ym, bm; // mouse position 
  int height = 800; // was 800
  int width = 1000;  // was 1000
  double gfct = 0.575; // percent size of plot volume
  double xmin = 0.0; // scaled for plotting
  double xmax = 1.0;
  double ymin = 0.0;
  double ymax = 1.0;
  double zmin = 0.0;
  double zmax = 1.0;
  double tmin = 0.0;
  double tmax = 1.0;
  double umin = 0.0;
  double umax = 1.0;
  double vmin = 0.0;
  double vmax = 1.0;
  double wmin = 0.0;
  double wmax = 1.0;
  double pmin = 0.0;
  double pmax = 1.0;
  double Umin = 0.0;
  double Umax = 1.0;
  double dxmin, dxmax, dymin, dymax, dzmin, dzmax, dtmin, dtmax;
  double dumin, dumax, dvmin, dvmax, dwmin, dwmax, dpmin, dpmax, dUmin, dUmax;
  double v1min = 0.0; // variable samples, computed based on mouse click
  double v1max = 1.0;
  double v2min = 0.0;
  double v2max = 1.0;
  double v3min = 0.0;
  double v3max = 1.0;
  double v4min = 0.0;
  double v4max = 1.0;
  double v5min = 0.0;
  double v5max = 1.0;
  double v6min = 0.0;
  double v6max = 1.0;
  double v7min = 0.0;
  double v7max = 1.0;
  double v8min = 0.0;
  double v8max = 1.0;
  double xw, yh, xoff, yoff;
  int dim = 8; // should be read in
  int nn[] = new int[dim]; // nx, ny, nz, nt, nu, nv, nw, np
                           // in var order
  int var1 = 0; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 front axis
                // under mouse change
  int var2 = 1; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 side axis
  int var3 = 2; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 scan-run 
  int var4 = 3; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 other-run 
  int var5 = 4; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 other-run 
  int var6 = 5; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 other-run 
  int var7 = 6; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 other-run 
  int var8 = 7; // x=0, y=1, z=2, t=3, u=4, v=5, w=6, p=7 other-run 
  double v1, v2, v3, v4, v5, v6, v7, v8;
  int v3step = 1;
  int v4step = 1;
  int v5step = 1;
  int v6step = 1;
  int v7step = 1;
  int v8step = 1;
  int nx; // computed based on data
  int ny;
  int nz;
  int nt;
  int nu;
  int nv;
  int nw;
  int np;
  int nv1; //  nx,   ny,   nz,   nt,   nu,   nv,   nw,   np  based on
           // var1, var2, var3, var4, var5, var6, var7, var8
  int nv2;
  int nv3;
  int nv4;
  int nv5;
  int nv6;
  int nv7;
  int nv8;
  int nxyztuvwp;
  double pt[][]; // = new double[nxyztuvwp][dim+1];
  double ya = 0.5; //  orthographic typ 0.2 to 0.7, must fix text 
  double xs = (gfct*(width-150));
  double ys = (gfct*(height-100));
  int xp, yp; // for passing back ortho point
  boolean debug = true;
  int n_input;
  boolean run345678 = false;
  boolean stop = false;
  int speed = 100; // millisecond delay
  // set up double buffering for smooth "run"
  Image dbImage;
  Graphics dbg; // double buffered graphics

  public plot8d()
  {
    System.out.println("plot8d.java running.");
    setTitle("plot8d x,y,z,t,u,v,w,p  value U");
    setSize(width,height);
    setBackground(Color.white);
    setForeground(Color.black);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
        System.exit(0);
      }
    });
    setVisible(true);
    this.addMouseListener (new mousePressHandler());

    try
    {
      read_data();
      nn[0] = nx;  
      nn[1] = ny;  
      nn[2] = nz;  
      nn[3] = nt;  
      nn[4] = nu;  
      nn[5] = nv;  
      nn[6] = nw;  
      nn[7] = np;  
      nv1 = nn[0];
      nv2 = nn[1];
      nv3 = nn[2];
      nv4 = nn[3];
      nv5 = nn[4];
      nv6 = nn[5];
      nv7 = nn[6];
      nv8 = nn[7];
      v3step = nn[var3]-1;
      v4step = nn[var4]-1;
      v5step = nn[var5]-1;
      v6step = nn[var6]-1;
      v7step = nn[var7]-1;
      v8step = nn[var8]-1;
    } // end try
    catch(IOException exception)
    {
      System.out.println(exception);
    }
    // repaint();
  } // plot8d constructor

    // this is the key to double buffering, repaint() calls update, not paint
  public void update(Graphics g)
  {
    // initialize Double Buffers
    if(dbImage==null)
    {
      dbImage = createImage(this.getSize().width, this.getSize().height);
      dbg = dbImage.getGraphics();
    } // only first time

    // clear Image in RAM, dbg is off screen buffer
    dbg.setColor(Color.white);
    dbg.fillRect(0, 0, this.getSize().width, this.getSize().height);

    paint(dbg); // now call paint to render in dbg
    g.drawImage(dbImage, 0, 0, this); // display rendered image, very fast
  } // end update

  public class do_scan extends Thread 
  // var1, var2, var3, var4, var5, var6, var7, var8
  // v3step, v4step, v5step, v6step, v7step, v8step  can be changed
  {
    do_scan()
    {
      if(debug) System.out.println("do_scan on var3="+var3+" with nv3="+nv3);
      if(debug) System.out.println("do_scan on var4="+var4+" with nv4="+nv4);
      if(debug) System.out.println("do_scan on var5="+var5+" with nv5="+nv5);
      if(debug) System.out.println("do_scan on var6="+var6+" with nv6="+nv6);
      if(debug) System.out.println("do_scan on var7="+var7+" with nv7="+nv7);
      if(debug) System.out.println("do_scan on var8="+var8+" with nv8="+nv8);
    }

    public void run()
    {
      for(int iii=0; iii<nv3; iii++)
      {
	v3step = iii;
	for(int iiii=0; iiii<nv4; iiii++)
	{
	  v4step = iiii;
	  for(int iiiii=0; iiiii<nv5; iiiii++)
	  {
	    v5step = iiiii;
  	    for(int iiiiii=0; iiiiii<nv6; iiiiii++)
	    {
	      v6step = iiiiii;
    	      for(int iiiiiii=0; iiiiiii<nv7; iiiiiii++)
	      {
	        v7step = iiiiiii;
    	        for(int iiiiiiii=0; iiiiiiii<nv8; iiiiiiii++)
	        {
	          v8step = iiiiiiii;
                  repaint();
                  try
	          {
	            sleep(speed); // milliseconds delay
	          }
                  catch(InterruptedException excp)
	          {
	            System.out.println("caught Exception");
	          } // end try catch
                } // end iiiiiiii
              } // end iiiiiii
            } // end iiiiii
          } // end iiiii
        } // end iiii
      } // end iii
    } // end run
  } // end class do_scan

  class mousePressHandler extends MouseAdapter
  {
    public void mousePressed (MouseEvent e)
    {
      xm = e.getX();
      ym = e.getY();
      bm = e.getButton();
      // System.out.println("down xm="+xm+", ym="+ym+", bm="+bm); // debug
      // var1 front axis, var2 side axis,
      // var3, var4, var5, var6, var7, var 8  scan direction, all unique

      if(in_rect(width-70, height-25, 30, 20))
      {
	// dynamic display, run345678
	requestFocus();
        new do_scan().start();
      }
      else if(in_rect(width-70, height-50, 30, 20))
      {
	// stop scan
	requestFocus();
        stop = true;
      }
      else if(in_rect(width-120, height-50, 30, 20))
      {
	// faster
	requestFocus();
        speed -= 25;
        if(speed<0) speed = 0;
      }
      else if(in_rect(width-180, height-50, 30, 20))
      {
	// slower
	requestFocus();
        speed += 25;
        if(speed>250) speed = 250;
      }
      else if(in_rect(width-55, height-75, 50, 20))
      {
	// step6D   number to step = dim-2
	requestFocus();
        v8step++;
	if(v8step>=nv8) v8step=0;  
        if(debug) System.out.println("step6D v8step="+v8step);
        repaint();
      }
      else if(in_rect(width-110, height-75, 50, 20))
      {
	// step5D
	requestFocus();
        v7step++;
	if(v7step>=nv7) v7step=0;  
        if(debug) System.out.println("step5D v7step="+v7step);
        repaint();
      }
      else if(in_rect(width-165, height-75, 50, 20))
      {
	// step4D
	requestFocus();
        v6step++;
	if(v6step>=nv6) v6step=0;  
        if(debug) System.out.println("step4D v6step="+v6step);
        repaint();
      }
      else if(in_rect(width-220, height-75, 50, 20))
      {
	// step3D
	requestFocus();
        v5step++;
	if(v5step>=nv5) v5step=0;  
        if(debug) System.out.println("step3D v5step="+v5step);
        repaint();
      }
      else if(in_rect(width-275, height-75, 50, 20))
      {
	// step2D
	requestFocus();
        v4step++;
	if(v4step>=nv4) v4step=0;  
        repaint();
      }
      else if(in_rect(width-330, height-75, 50, 20))
      {
	// step1D
	requestFocus();
        v3step++;
	if(v3step>=nv3) v3step=0;  
        repaint();
      }
      else if(in_rect(width-140, height-25, 60, 20))
      {
	// next scan
	requestFocus();
	var3++;
        if(var3>=dim) var3 = 0;
        while(var3==var1 || var3==var2)
	{
	  var3++;
          if(var3>=dim) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
          if(var4>=dim) var4 = 0;
	}
        var5 = 0;
        while(var5==var1 || var5==var2 || var5==var3 || var5==var4)
	{
	  var5++;
          if(var5>=dim) var5 = 0;
	}
        var6 = 0;
        while(var6==var1 || var6==var2 || var6==var3 || var6==var4 ||
              var6==var5)
	{
	  var6++;
          if(var6>=dim) var6 = 0;
	}
        var7 = 0;
        while(var7==var1 || var7==var2 || var7==var3 || var7==var4 ||
              var7==var5 || var7==var6)
	{
	  var7++;
          if(var7>=dim) var7 = 0;
	}
        var8 = 0;
        while(var8==var1 || var8==var2 || var8==var3 || var8==var4 ||
              var8==var5 || var8==var6 || var8==var7)
	{
	  var8++;
          if(var8>=dim) var8 = 0;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        v5step = nn[var5]-1;
        v6step = nn[var6]-1;
        v7step = nn[var7]-1;
        v8step = nn[var8]-1;
        repaint();
      }
      else if(in_rect(width-215, height-25, 65, 20))
      {
	// next side
	requestFocus();
	var2++;
        if(var2>=dim) var2 = 0;
        if(var2==var1) var2++;
        if(var2>=dim) var2 = 0;
        while(var1==var3 || var2==var3)
	{
	  var3++;
          if(var3>=dim) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
          if(var4>=dim) var4 = 0;
	}
        var5 = 0;
        while(var5==var1 || var5==var2 || var5==var3 || var5==var4)
	{
	  var5++;
          if(var5>=dim) var5 = 0;
	}
        var6 = 0;
        while(var6==var1 || var6==var2 || var6==var3 || var6==var4 ||
              var6==var5)
	{
	  var6++;
          if(var6>=dim) var6 = 0;
	}
        var7 = 0;
        while(var7==var1 || var7==var2 || var7==var3 || var7==var4 ||
              var7==var5 || var7==var6)
	{
	  var7++;
          if(var7>=dim) var7 = 0;
	}
        var8 = 0;
        while(var8==var1 || var8==var2 || var8==var3 || var8==var4 ||
              var8==var5 || var8==var6 || var8==var7)
	{
	  var8++;
          if(var8>=dim) var8 = 0;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        v5step = nn[var5]-1;
        v6step = nn[var6]-1;
        v7step = nn[var7]-1;
        v8step = nn[var8]-1;
        repaint();
      }
      else if(in_rect(width-295, height-25, 70, 20))
      {
	// next front
	requestFocus();
        var1++;
        if(var1>=dim) var1 = 0;
        if(var1==var2) var2++;
        if(var2>=dim) var2 = 0;
        while(var1==var3 || var2==var3)
	{
	  var3++;
          if(var3>=dim) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
          if(var4>=dim) var4 = 0;
	}
        var5 = 0;
        while(var5==var1 || var5==var2 || var5==var3 || var5==var4)
	{
	  var5++;
          if(var5>=dim) var5 = 0;
	}
        var6 = 0;
        while(var6==var1 || var6==var2 || var6==var3 || var6==var4 ||
              var6==var5)
	{
	  var6++;
          if(var6>=dim) var6 = 0;
	}
        var7 = 0;
        while(var7==var1 || var7==var2 || var7==var3 || var7==var4 ||
              var7==var5 || var7==var6)
	{
	  var7++;
          if(var7>=dim) var7 = 0;
	}
        var8 = 0;
        while(var8==var1 || var8==var2 || var8==var3 || var8==var4 ||
              var8==var5 || var8==var6 || var8==var7)
	{
	  var8++;
          if(var8>=dim) var8 = 0;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        v5step = nn[var5]-1;
        v6step = nn[var6]-1;
        v7step = nn[var7]-1;
        v8step = nn[var8]-1;
        repaint();
      }
      if(in_rect(width-35, height-25, 30, 20)) System.exit(0);
    } // end mousePressed 
  } // end mousePressHandler

  boolean in_rect(int x, int y, int w, int h)
  {
    return xm>x && xm<x+w && ym>y && ym<y+h;
  } // end in_rect

  boolean not_in(int i, int a[], int n)
  {
    boolean found = false;
    int j;

    for(j=0; j<n; j++)
    {
      if(i==a[j]) { found=true; break; }
    }
    return !found;
  } // end not_in

 
  public void paint(Graphics g)
  {
    double z, t, u; 
    double U1, U2, hU, dhU, nearz;
    int xp1, yp1, xp2, yp2; // line segment
    int i4, i5, i6;
    int ncol = 10;
    String fstring;

    dhU = (dUmax-dUmin)/(double)(ncol-1);
    // buttons
    g.setColor(Color.red);
    g.fillRect(width-35,height-25,30,20);
    g.setColor(Color.black);
    g.drawString("quit", width-30, height-10);

    g.setColor(Color.green);
    g.fillRect(width-70,height-25,30,20);
    g.setColor(Color.black);
    g.drawString("run", width-65, height-10);
    
    g.setColor(Color.red);
    g.fillRect(width-70,height-50,35,20);
    g.setColor(Color.black);
    g.drawString("stop", width-65, height-35);

    g.setColor(Color.green);
    g.fillRect(width-120,height-50,45,20);
    g.setColor(Color.black);
    g.drawString("faster", width-115, height-35);

    g.setColor(Color.yellow);
    g.fillRect(width-180,height-50,45,20);
    g.setColor(Color.black);
    g.drawString("slower", width-175, height-35);

    g.setColor(Color.gray);
    g.fillRect(width-55,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step6D", width-50, height-60);

    g.setColor(Color.gray);
    g.fillRect(width-110,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step5D", width-105, height-60);

    g.setColor(Color.gray);
    g.fillRect(width-165,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step4D", width-160, height-60);
    
    g.setColor(Color.gray);
    g.fillRect(width-220,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step3D", width-215, height-60);

    g.setColor(Color.gray);
    g.fillRect(width-275,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step2D", width-270, height-60);

    g.setColor(Color.gray);
    g.fillRect(width-330,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step1D", width-325, height-60);

    g.setColor(new Color(188,143,143)); // Color.pink); now brown
    g.fillRect(width-140,height-25,65,20);
    g.setColor(Color.black);
    g.drawString("next scan", width-135, height-10);

    g.setColor(Color.yellow);
    g.fillRect(width-215,height-25,65,20);
    g.setColor(Color.black);
    g.drawString("next side", width-210, height-10);

    g.setColor(Color.orange);
    g.fillRect(width-295,height-25,70,20);
    g.setColor(Color.black);
    g.drawString("next front", width-290, height-10);

    // x,y,z,t,u,v,w,p min-max
    g.drawString("xmin=", 300, 40);
    fstring = Double.toString(dxmin);
    g.drawString(fstring, 340, 40);
    g.drawString("xmax=", 500, 40);
    fstring = Double.toString(dxmax);
    g.drawString(fstring, 540, 40);
    g.drawString("nx=", 700, 40);
    fstring = Integer.toString(nx);
    g.drawString(fstring, 740, 40);

    g.drawString("ymin=", 300, 57);
    fstring = Double.toString(dymin);
    g.drawString(fstring, 340, 57);
    g.drawString("ymax=", 500, 57);
    fstring = Double.toString(dymax);
    g.drawString(fstring, 540, 57);
    g.drawString("ny=", 700, 57);
    fstring = Integer.toString(ny);
    g.drawString(fstring, 740, 57);

    g.drawString("zmin=", 300, 74);
    fstring = Double.toString(dzmin);
    g.drawString(fstring, 340, 74);
    g.drawString("zmax=", 500, 74);
    fstring = Double.toString(dzmax);
    g.drawString(fstring, 540, 74);
    g.drawString("nz=", 700, 74);
    fstring = Integer.toString(nz);
    g.drawString(fstring, 740, 74);

    g.drawString("tmin=", 300, 91);
    fstring = Double.toString(dtmin);
    g.drawString(fstring, 340, 91);
    g.drawString("tmax=", 500, 91);
    fstring = Double.toString(dtmax);
    g.drawString(fstring, 540, 91);
    g.drawString("nt=", 700, 91);
    fstring = Integer.toString(nt);
    g.drawString(fstring, 740, 91);

    g.drawString("umin=", 300, 108);
    fstring = Double.toString(dumin);
    g.drawString(fstring, 340, 108);
    g.drawString("umax=", 500, 108);
    fstring = Double.toString(dumax);
    g.drawString(fstring, 540, 108);
    g.drawString("nu=", 700, 108);
    fstring = Integer.toString(nt);
    g.drawString(fstring, 740, 108);
    fstring = Integer.toString(nu);
    g.drawString(fstring, 740, 108);

    g.drawString("vmin=", 300, 125);
    fstring = Double.toString(dvmin);
    g.drawString(fstring, 340, 125);
    g.drawString("vmax=", 500, 125);
    fstring = Double.toString(dvmax);
    g.drawString(fstring, 540, 125);
    g.drawString("nv=", 700, 125);
    fstring = Integer.toString(nv);
    g.drawString(fstring, 740, 125);

    g.drawString("wmin=", 300, 142);
    fstring = Double.toString(dwmin);
    g.drawString(fstring, 340, 142);
    g.drawString("wmax=", 500, 142);
    fstring = Double.toString(dwmax);
    g.drawString(fstring, 540, 142);
    g.drawString("nw=", 700, 142);
    fstring = Integer.toString(nw);
    g.drawString(fstring, 740, 142);

    g.drawString("pmin=", 300, 159);
    fstring = Double.toString(dpmin);
    g.drawString(fstring, 340, 159);
    g.drawString("pmax=", 500, 159);
    fstring = Double.toString(dpmax);
    g.drawString(fstring, 540, 159);
    g.drawString("np=", 700, 159);
    fstring = Integer.toString(np);
    g.drawString(fstring, 740, 159);

    // axis labels bottom
    if(var1==0) g.drawString("xmin", 25, height-15);
    if(var1==1) g.drawString("ymin", 25, height-15);
    if(var1==2) g.drawString("zmin", 25, height-15);
    if(var1==3) g.drawString("tmin", 25, height-15);
    if(var1==4) g.drawString("umin", 25, height-15);
    if(var1==5) g.drawString("vmin", 25, height-15);
    if(var1==6) g.drawString("wmin", 25, height-15);
    if(var1==7) g.drawString("pmin", 25, height-15);
    if(var1==0) g.drawString("xmax", (int)(gfct*width-100), height-15);
    if(var1==1) g.drawString("ymax", (int)(gfct*width-100), height-15);
    if(var1==2) g.drawString("zmax", (int)(gfct*width-100), height-15);
    if(var1==3) g.drawString("tmax", (int)(gfct*width-100), height-15);
    if(var1==4) g.drawString("umax", (int)(gfct*width-100), height-15);
    if(var1==5) g.drawString("vmax", (int)(gfct*width-100), height-15);
    if(var1==6) g.drawString("wmax", (int)(gfct*width-100), height-15);
    if(var1==7) g.drawString("pmax", (int)(gfct*width-100), height-15);

    // axis labels edge
    if(var2==0) g.drawString("xmin", (int)(gfct*width-50), height-25);
    if(var2==1) g.drawString("ymin", (int)(gfct*width-50), height-25);
    if(var2==2) g.drawString("zmin", (int)(gfct*width-50), height-25);
    if(var2==3) g.drawString("tmin", (int)(gfct*width-50), height-25);
    if(var2==4) g.drawString("umin", (int)(gfct*width-50), height-25);
    if(var2==5) g.drawString("vmin", (int)(gfct*width-50), height-25);
    if(var2==6) g.drawString("wmin", (int)(gfct*width-50), height-25);
    if(var2==7) g.drawString("pmin", (int)(gfct*width-50), height-25);
    if(var2==0) g.drawString("xmax", (int)(width-248), (int)(gfct*height+125));
    if(var2==1) g.drawString("ymax", (int)(width-248), (int)(gfct*height+125));
    if(var2==2) g.drawString("zmax", (int)(width-248), (int)(gfct*height+125));
    if(var2==3) g.drawString("tmax", (int)(width-248), (int)(gfct*height+125));
    if(var2==4) g.drawString("umax", (int)(width-248), (int)(gfct*height+125));
    if(var2==5) g.drawString("vmax", (int)(width-248), (int)(gfct*height+125));
    if(var2==6) g.drawString("wmax", (int)(width-248), (int)(gfct*height+125));
    if(var2==7) g.drawString("pmax", (int)(width-248), (int)(gfct*height+125));

    // scan labels
    if(var3==0) g.drawString("xmin", (int)(width-236), height-280);
    if(var3==1) g.drawString("ymin", (int)(width-236), height-280);
    if(var3==2) g.drawString("zmin", (int)(width-236), height-280);
    if(var3==3) g.drawString("tmin", (int)(width-236), height-280);
    if(var3==4) g.drawString("umin", (int)(width-236), height-280);
    if(var3==5) g.drawString("vmin", (int)(width-236), height-280);
    if(var3==6) g.drawString("wmin", (int)(width-236), height-280);
    if(var3==7) g.drawString("pmin", (int)(width-236), height-280);
    if(var3==0) g.drawString("xmax", (int)(width-236), 170);
    if(var3==1) g.drawString("ymax", (int)(width-236), 170);
    if(var3==2) g.drawString("zmax", (int)(width-236), 170);
    if(var3==3) g.drawString("tmax", (int)(width-236), 170);
    if(var3==4) g.drawString("umax", (int)(width-236), 170);
    if(var3==5) g.drawString("vmax", (int)(width-236), 170);
    if(var3==6) g.drawString("wmax", (int)(width-236), 170);
    if(var3==7) g.drawString("pmax", (int)(width-236), 170);

    if(var4==0) g.drawString("xmin", (int)(width-194), height-280);
    if(var4==1) g.drawString("ymin", (int)(width-194), height-280);
    if(var4==2) g.drawString("zmin", (int)(width-194), height-280);
    if(var4==3) g.drawString("tmin", (int)(width-194), height-280);
    if(var4==4) g.drawString("umin", (int)(width-194), height-280);
    if(var4==5) g.drawString("vmin", (int)(width-194), height-280);
    if(var4==6) g.drawString("wmin", (int)(width-194), height-280);
    if(var4==7) g.drawString("pmin", (int)(width-194), height-280);
    if(var4==0) g.drawString("xmax", (int)(width-194), 170);
    if(var4==1) g.drawString("ymax", (int)(width-194), 170);
    if(var4==2) g.drawString("zmax", (int)(width-149), 170);
    if(var4==3) g.drawString("tmax", (int)(width-194), 170);
    if(var4==4) g.drawString("umax", (int)(width-194), 170);
    if(var4==5) g.drawString("vmax", (int)(width-194), 170);
    if(var4==6) g.drawString("wmax", (int)(width-194), 170);
    if(var4==7) g.drawString("pmax", (int)(width-194), 170);

    if(var5==0) g.drawString("xmin", (int)(width-158), height-280);
    if(var5==1) g.drawString("ymin", (int)(width-158), height-280);
    if(var5==2) g.drawString("zmin", (int)(width-158), height-280);
    if(var5==3) g.drawString("tmin", (int)(width-158), height-280);
    if(var5==4) g.drawString("umin", (int)(width-158), height-280);
    if(var5==5) g.drawString("vmin", (int)(width-158), height-280);
    if(var5==6) g.drawString("wmin", (int)(width-158), height-280);
    if(var5==7) g.drawString("pmin", (int)(width-158), height-280);
    if(var5==0) g.drawString("xmax", (int)(width-158), 170);
    if(var5==1) g.drawString("ymax", (int)(width-158), 170);
    if(var5==2) g.drawString("zmax", (int)(width-158), 170);
    if(var5==3) g.drawString("tmax", (int)(width-158), 170);
    if(var5==4) g.drawString("umax", (int)(width-158), 170);
    if(var5==5) g.drawString("vmax", (int)(width-158), 170);
    if(var5==6) g.drawString("wmax", (int)(width-158), 170);
    if(var5==7) g.drawString("pmax", (int)(width-158), 170);

    if(var6==0) g.drawString("xmin", (int)(width-122), height-280);
    if(var6==1) g.drawString("ymin", (int)(width-122), height-280);
    if(var6==2) g.drawString("zmin", (int)(width-122), height-280);
    if(var6==3) g.drawString("tmin", (int)(width-122), height-280);
    if(var6==4) g.drawString("umin", (int)(width-122), height-280);
    if(var6==5) g.drawString("vmin", (int)(width-122), height-280);
    if(var6==6) g.drawString("wmin", (int)(width-122), height-280);
    if(var6==7) g.drawString("pmin", (int)(width-122), height-280);
    if(var6==0) g.drawString("xmax", (int)(width-122), 170);
    if(var6==1) g.drawString("ymax", (int)(width-122), 170);
    if(var6==2) g.drawString("zmax", (int)(width-122), 170);
    if(var6==3) g.drawString("tmax", (int)(width-122), 170);
    if(var6==4) g.drawString("umax", (int)(width-122), 170);
    if(var6==5) g.drawString("vmax", (int)(width-122), 170);
    if(var6==6) g.drawString("wmax", (int)(width-122), 170);
    if(var6==7) g.drawString("pmax", (int)(width-122), 170);

    if(var7==0) g.drawString("xmin", (int)(width-86), height-280);
    if(var7==1) g.drawString("ymin", (int)(width-86), height-280);
    if(var7==2) g.drawString("zmin", (int)(width-86), height-280);
    if(var7==3) g.drawString("tmin", (int)(width-68), height-280);
    if(var7==4) g.drawString("umin", (int)(width-68), height-280);
    if(var7==5) g.drawString("vmin", (int)(width-86), height-280);
    if(var7==6) g.drawString("wmin", (int)(width-86), height-280);
    if(var7==7) g.drawString("pmin", (int)(width-86), height-280);
    if(var7==0) g.drawString("xmax", (int)(width-86), 170);
    if(var7==1) g.drawString("ymax", (int)(width-86), 170);
    if(var7==2) g.drawString("zmax", (int)(width-86), 170);
    if(var7==3) g.drawString("tmax", (int)(width-86), 170);
    if(var7==4) g.drawString("umax", (int)(width-86), 170);
    if(var7==5) g.drawString("vmax", (int)(width-86), 170);
    if(var7==6) g.drawString("wmax", (int)(width-86), 170);
    if(var7==7) g.drawString("pmax", (int)(width-86), 170);

    if(var8==0) g.drawString("xmin", (int)(width-50), height-280);
    if(var8==1) g.drawString("ymin", (int)(width-50), height-280);
    if(var8==2) g.drawString("zmin", (int)(width-50), height-280);
    if(var8==3) g.drawString("tmin", (int)(width-50), height-280);
    if(var8==4) g.drawString("umin", (int)(width-50), height-280);
    if(var8==5) g.drawString("vmin", (int)(width-50), height-280);
    if(var8==6) g.drawString("wmin", (int)(width-50), height-280);
    if(var8==7) g.drawString("pmin", (int)(width-50), height-280);
    if(var8==0) g.drawString("xmax", (int)(width-50), 170);
    if(var8==1) g.drawString("ymax", (int)(width-50), 170);
    if(var8==2) g.drawString("zmax", (int)(width-50), 170);
    if(var8==3) g.drawString("tmax", (int)(width-50), 170);
    if(var8==4) g.drawString("umax", (int)(width-50), 170);
    if(var8==5) g.drawString("vmax", (int)(width-50), 170);
    if(var8==6) g.drawString("wmax", (int)(width-50), 170);
    if(var8==7) g.drawString("pmax", (int)(width-50), 170);

    g.drawString("Umin", (int)(width-238), (int)(gfct*height+95));
    g.drawString("Umax", (int)(width-238), (int)(190));

    // height color scale
    int hgt = 210;
    for(int i=0; i<ncol; i++)
    {
      set_color(i, g);
      g.fillRect(20,hgt-20*i+20,50,15);
    }
    g.drawString("U value", 80, 40);
    fstring = Double.toString(dUmax);
    g.drawString(fstring, 80, 62);
    nearz = dUmin;
    if(Math.abs(nearz)<1.0E-4) nearz = 0.0;
    fstring = Double.toString(nearz);
    if(fstring.length()>11)
      fstring = fstring.substring(0,10);
    g.drawString(fstring, 80, 242);
    for(int i=1; i<ncol-1; i++)
    {
      fstring = Double.toString(dUmax-dhU*(double)i);
      // limit digits
      if(fstring.length()>11)
        fstring = fstring.substring(0,10);
      g.drawString(fstring, 80, 62+20*i);
    }
    // draw box, bottom
    nv1 = nn[var1];
    nv2 = nn[var2];
    nv3 = nn[var3];
    nv4 = nn[var4];
    nv5 = nn[var5];
    nv6 = nn[var6];
    nv7 = nn[var7];
    nv8 = nn[var8];
    if(var1==0) { v1min = xmin; v1max = xmax; }
    if(var1==1) { v1min = ymin; v1max = ymax; }
    if(var1==2) { v1min = zmin; v1max = zmax; }
    if(var1==3) { v1min = tmin; v1max = tmax; }
    if(var1==4) { v1min = umin; v1max = umax; }
    if(var1==5) { v1min = vmin; v1max = vmax; }
    if(var1==6) { v1min = wmin; v1max = wmax; }
    if(var1==7) { v1min = pmin; v1max = pmax; }
    if(var2==0) { v2min = xmin; v1max = xmax; }
    if(var2==1) { v2min = ymin; v1max = ymax; }
    if(var2==2) { v2min = zmin; v1max = zmax; }
    if(var2==3) { v2min = tmin; v1max = tmax; }
    if(var2==4) { v2min = umin; v1max = umax; }
    if(var2==5) { v2min = vmin; v1max = vmax; }
    if(var2==6) { v2min = wmin; v1max = wmax; }
    if(var2==7) { v2min = pmin; v1max = pmax; }
    if(var3==0) { v3min = xmin; v1max = xmax; }
    if(var3==1) { v3min = ymin; v1max = ymax; }
    if(var3==2) { v3min = zmin; v1max = zmax; }
    if(var3==3) { v3min = tmin; v1max = tmax; }
    if(var3==4) { v3min = umin; v1max = umax; }
    if(var3==5) { v3min = vmin; v1max = vmax; }
    if(var3==6) { v3min = wmin; v1max = wmax; }
    if(var3==7) { v3min = pmin; v1max = pmax; }
    if(var4==0) { v4min = xmin; v1max = xmax; }
    if(var4==1) { v4min = ymin; v1max = ymax; }
    if(var4==2) { v4min = zmin; v1max = zmax; }
    if(var4==3) { v4min = tmin; v1max = tmax; }
    if(var4==4) { v4min = umin; v1max = umax; }
    if(var4==5) { v4min = vmin; v1max = vmax; }
    if(var4==6) { v4min = wmin; v1max = wmax; }
    if(var4==7) { v4min = pmin; v1max = pmax; }
    if(var5==0) { v5min = xmin; v1max = xmax; }
    if(var5==1) { v5min = ymin; v1max = ymax; }
    if(var5==2) { v5min = zmin; v1max = zmax; }
    if(var5==3) { v5min = tmin; v1max = tmax; }
    if(var5==4) { v5min = umin; v1max = umax; }
    if(var5==5) { v5min = vmin; v1max = vmax; }
    if(var5==6) { v5min = wmin; v1max = wmax; }
    if(var5==7) { v5min = pmin; v1max = pmax; }
    if(var6==0) { v6min = xmin; v1max = xmax; }
    if(var6==1) { v6min = ymin; v1max = ymax; }
    if(var6==2) { v6min = zmin; v1max = zmax; }
    if(var6==3) { v6min = tmin; v1max = tmax; }
    if(var6==4) { v6min = umin; v1max = umax; }
    if(var6==5) { v6min = vmin; v1max = vmax; }
    if(var6==6) { v6min = wmin; v1max = wmax; }
    if(var6==7) { v6min = pmin; v1max = pmax; }
    if(var7==0) { v7min = xmin; v1max = xmax; }
    if(var7==1) { v7min = ymin; v1max = ymax; }
    if(var7==2) { v7min = zmin; v1max = zmax; }
    if(var7==3) { v7min = tmin; v1max = tmax; }
    if(var7==4) { v7min = umin; v1max = umax; }
    if(var7==5) { v7min = vmin; v1max = vmax; }
    if(var7==6) { v7min = wmin; v1max = wmax; }
    if(var7==7) { v7min = pmin; v1max = pmax; }
    if(var8==0) { v8min = xmin; v1max = xmax; }
    if(var8==1) { v8min = ymin; v1max = ymax; }
    if(var8==2) { v8min = zmin; v1max = zmax; }
    if(var8==3) { v8min = tmin; v1max = tmax; }
    if(var8==4) { v8min = umin; v1max = umax; }
    if(var8==5) { v8min = vmin; v1max = vmax; }
    if(var8==6) { v8min = wmin; v1max = wmax; }
    if(var8==7) { v8min = pmin; v1max = pmax; }
    set_color(0, g);
    ortho(v1min, v2min, Umin); xp1=xp; yp1=yp;
    ortho(v1max, v2min, Umin); xp2=xp; yp2=yp;
    g.drawLine(xp1, yp1, xp2, yp2);
    ortho(v1max, v2max, Umin); xp1=xp; yp1=yp;
    g.drawLine(xp2, yp2, xp1, yp1);
    ortho(v1min, v2max, Umin); xp2=xp; yp2=yp;
    g.drawLine(xp1, yp1, xp2, yp2);
    ortho(v1min, v2min, Umin); xp1=xp; yp1=yp;
    g.drawLine(xp2, yp2, xp1, yp1);
    set_color(ncol-1, g); // top
    ortho(v1min, v2min, Umax); xp1=xp; yp1=yp;
    ortho(v1max, v2min, Umax); xp2=xp; yp2=yp;
    g.drawLine(xp1, yp1, xp2, yp2);
    ortho(v1max, v2max, Umax); xp1=xp; yp1=yp;
    g.drawLine(xp2, yp2, xp1, yp1);
    ortho(v1min, v2max, Umax); xp2=xp; yp2=yp;
    g.drawLine(xp1, yp1, xp2, yp2);
    ortho(v1min, v2min, Umax); xp1=xp; yp1=yp;
    g.drawLine(xp2, yp2, xp1, yp1);
    // draw box edges with z value colors
    U1 = Umin;
    hU = (Umax-Umin)/(ncol);
    for(int i=0; i<ncol; i++)
    {
      U2 = U1+hU;
      set_color(i,g);
      ortho(v1min, v2min, U1); xp1=xp; yp1=yp;
      ortho(v1min, v2min, U2); xp2=xp; yp2=yp;
      g.drawLine(xp1, yp1, xp2, yp2);
      ortho(v1min, v2max, U1); xp1=xp; yp1=yp;
      ortho(v1min, v2max, U2); xp2=xp; yp2=yp;
      g.drawLine(xp1, yp1, xp2, yp2);
      ortho(v1max, v2max, U1); xp1=xp; yp1=yp;
      ortho(v1max, v2max, U2); xp2=xp; yp2=yp;
      g.drawLine(xp1, yp1, xp2, yp2);
      ortho(v1max, v2min, U1); xp1=xp; yp1=yp;
      ortho(v1max, v2min, U2); xp2=xp; yp2=yp;
      g.drawLine(xp1, yp1, xp2, yp2);
      U1 = U2;
    }

    // var3 and var4 and var5 and var6 and var7 and var8 color position
    i4 = i4x(0, 0, 0, 0, 0, 0, 0, v8step);
    if(debug) System.out.println("i4="+i4+" var8="+var8); 
    v8 = pt[i4][var8];
    set_color((int)(ncol*((v8-v8min)/(v8max-v8min))+0.5), g);
    g.fillRect(width-44,height-280-30-10-v8step*(310/(nv7-1)),25,30);
    i4 = i4x(0, 0, 0, 0, 0, 0, v7step, 0);
    v7 = pt[i4][var7];
    set_color((int)(ncol*((v7-v7min)/(v7max-v7min))+0.5), g);
    g.fillRect(width-81,height-280-30-10-v7step*(310/(nv6-1)),25,30);
    i4 = i4x(0, 0, 0, 0, 0, v6step, 0, 0);
    v6 = pt[i4][var6];
    set_color((int)(ncol*((v6-v6min)/(v6max-v6min))+0.5), g);
    g.fillRect(width-118,height-280-30-10-v6step*(310/(nv6-1)),25,30);
    i4 = i4x(0, 0, 0, 0, v5step, 0, 0, 0);
    v5 = pt[i4][var5];
    set_color((int)(ncol*((v5-v5min)/(v5max-v5min))+0.5), g);
    g.fillRect(width-155,height-280-30-10-v5step*(310/(nv5-1)),25,30);
    i4 = i4x(0, 0, 0, v4step, 0, 0, 0, 0);
    v4 = pt[i4][var4];
    set_color((int)(ncol*((v4-v4min)/(v4max-v4min))+0.5), g);
    g.fillRect(width-192,height-280-30-10-v4step*(310/(nv4-1)),25,30);
    i4 = i4x(0, 0, v3step, 0, 0, 0, 0, 0);
    v3 = pt[i4][var3];
    set_color((int)(ncol*((v3-v3min)/(v3max-v3min))+0.5), g);
    g.fillRect(width-229,height-280-30-10-v3step*(310/(nv3-1)),25,30);

    // plot function or data with u value colors
    int iii = v3step;
    int iiii = v4step;
    int iiiii = v5step;
    int iiiiii = v6step;
    int iiiiiii = v7step;
    int iiiiiiii = v8step;

    if(debug) System.out.println("paint var1="+var1+", var2="+var2+
              ", var3="+var3+", var4="+var4+", var5="+var5+", var6="+var6+
              ", var7="+var7+", var8="+var8);
    for(int i=0; i<nv1-1; i++) // var1 == front
    {
      for(int ii=0; ii<nv2-1; ii++) // var2 == side
      {
	i4 = i4x(i, ii, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
             // depends on var1..8
	i5 = i4x(i+1, ii, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
             // depends on var1..8
	i6 = i4x(i, ii+1, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
             // depends on var1..8
        v1 = pt[i4][var1];
	v2 = pt[i4][var2];
        v3 = pt[i4][var3];
	v4 = pt[i4][var4];
	v5 = pt[i4][var5];
	v6 = pt[i4][var6];
	v7 = pt[i4][var7];
	v8 = pt[i4][var8];
        U1 = pt[i4][dim];

        if(debug) System.out.println("i="+i+", ii="+ii+", iii="+iii+
                           ", iiii="+iiii+", iiiii="+iiiii+", iiiiii="+
                           iiiiii+", iiiiiii="+iiiiiii+
                           ", iiiiiiii="+iiiiiiii);
        if(debug) System.out.println("i4="+i4+", i5="+i5+", i6="+i6);
        if(debug) System.out.println("v1="+v1+", v2="+v2+", v3="+v3+
                                     ", v4="+v4+", v5="+v5+", v6"+v6+
                                     ", v7="+v7+", v8="+v8+", U1="+U1);
        ortho(v1, v2, U1); xp1=xp; yp1=yp; // xp and yp are front and side
        U2 = pt[i5][dim];
        if(debug) System.out.println("v1p="+pt[i5][var1]+", v2="+v2+", U="+U2);
        ortho(pt[i5][var1], v2, U2); xp2=xp; yp2=yp;
        set_color((int)((ncol*(((U1+U2)/2.0)-Umin)/(Umax-Umin))+0.5), g);
        g.drawLine(xp1, yp1, xp2, yp2);
        U2 = pt[i6][dim];
        if(debug) System.out.println("v1="+v1+", v2p="+pt[i6][var2]+", U="+U2);
        ortho(v1, pt[i6][var2], U2); xp2=xp; yp2=yp;
        set_color((int)((ncol*(((U1+U2)/2.0)-Umin)/(Umax-Umin))+0.5), g);
        g.drawLine(xp1, yp1, xp2, yp2);
      }
    }
    for(int i=0; i<nv1-1; i++)
    {
      int ii = nv2-1;
      i4 = i4x(i, ii, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
      i5 = i4x(i+1, ii, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
      v1 = pt[i4][var1];
      v2 = v2max;
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      v5 = pt[i4][var5];
      v6 = pt[i4][var6];
      v7 = pt[i4][var7];
      v8 = pt[i4][var8];
      U1 = pt[i4][dim];
      if(debug) System.out.println("i4="+i4+", i5="+i5);
      if(debug) System.out.println("v1="+v1+", v2="+v2+", v3="+v3+
                                   ", v4="+v4+", v5="+v5+", v6="+v6+
                                   ", v7="+v7+", v8="+v8+", U1="+U1);
      ortho(v1, v2, U1); xp1=xp; yp1=yp;
      U2 = pt[i5][dim];
      ortho(pt[i5][var1], v2, U2); xp2=xp; yp2=yp;
      set_color((int)((ncol*(((U1+U2)/2.0)-Umin)/(Umax-Umin))+0.5), g);
      g.drawLine(xp1, yp1, xp2, yp2);
    }
    for(int ii=0; ii<nv2-1; ii++)
    {
      int i = nv1-1;
      i4 = i4x(i, ii, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
      i6 = i4x(i, ii+1, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii);
      v2 = pt[i4][var2];
      v1 = v1max;
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      v5 = pt[i4][var5];
      v6 = pt[i4][var6];
      v7 = pt[i4][var7];
      v8 = pt[i4][var8];
      U1 = pt[i4][dim];
      if(debug) System.out.println("i4="+i4+", i6="+i6);
      if(debug) System.out.println("v1="+v1+", v2="+v2+", v3="+v3+
                                   ", v4="+v4+", v5="+v5+", v6="+v6+
                                   ", v7="+v7+", v8="+v8+", U1="+U1);
      ortho(v1, v2, U1); xp1=xp; yp1=yp;
      U2 = pt[i6][dim];
      ortho(v1, pt[i6][var2], U2); xp2=xp; yp2=yp;
      set_color((int)((ncol*(((U1+U2)/2.0)-Umin)/(Umax-Umin))+0.5), g);
      g.drawLine(xp1, yp1, xp2, yp2);
    }
  } // end paint

  int i4x(int i, int ii, int iii, int iiii, int iiiii, int iiiiii,
          int iiiiiii, int iiiiiiii)
      // i is var1, ii is var2, iii is var3, iiii is var4,
      // iiiii is var5, iiiiii is var6, iiiiiii is var7, iiiiiiii is var8
  {
    int lin;
    int offset[] = { ny*nz*nt*nu*nv*nw*np, nz*nt*nu*nv*nw*np, nt*nu*nv*nw*np,
                     nu*nv*nw*np, nv*nw*np, nw*np, np, 1 };
    lin = i*offset[var1] + ii*offset[var2] + iii*offset[var3] + 
	  iiii*offset[var4] + iiiii*offset[var5] +
          iiiiii*offset[var6] + iiiiiii*offset[var7] +
          iiiiiiii*offset[var8];
    if(lin>=nxyztuvwp || lin<0)
    {
      System.out.println("index error, neg or, lin="+lin+" >= "+nxyztuvwp);
      System.out.println("var1="+var1+", var2="+var2+", var3="+var3+
                         ", var4="+var4+", var5="+var5+", var6="+var6+
                         ", var7="+var7+", var8="+var8);
      lin = nxyztuvwp-1;
    }
    return lin; 
  } // end i4x

  // orthographic projection, sets xp,yp
  void ortho(double x, double y, double U)
  {
    double x1, y1, U1, x2, y2, x3, y3;
    x1 = (x-xmin)/(xmax-xmin);   // zero base, normalized
    y1 = (y-ymin)/(ymax-ymin); 
    U1 = (U-Umin)/(Umax-Umin);  // U-Umin;
    x2 = x1+y1*ya; // ortho z is up, y is back
    y2 = U1+y1*ya;
    x3 = x2*xs;    // scale 
    y3 = y2*ys;
    x3 = x3+25;        // away from boarder
    y3 = height-y3-25; // away from boarder
    xp = (int)x3;
    yp = (int)y3;
    //System.out.println("ortho xp="+xp+", yp="+yp);
    //System.out.println("x1="+x1+", y1="+y1+", U1="+U1);
    //System.out.println(" ");
  } // end ortho

  void set_color(int i, Graphics g)
  {
    if(i<0) {g.setColor(Color.black); return;}
    if(i>9) {g.setColor(Color.gray); return; }
    switch(i)
    {
      case 0: g.setColor(Color.black); break;
      case 1: g.setColor(new Color(188,143,143)); break; // Color.pink); brown
      case 2: g.setColor(Color.red); break;
      case 3: g.setColor(Color.orange); break;
      case 4: g.setColor(Color.yellow); break;
      case 5: g.setColor(Color.green); break;
      case 6: g.setColor(Color.blue); break;
      case 7: g.setColor(Color.magenta); break;
      case 8: g.setColor(Color.cyan); break;
      case 9: g.setColor(Color.gray); break;
    }
  } // end set_color

  void read_data() throws IOException // big ugly input method
  {
    try
    {
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      String input_line;
      double amount;
      int len;
      int index;
      int last;
   
      System.out.println("read_data running");
      input_line = in.readLine(); // dim nx ny nz nt nu nv nw np
                                  // one space between each, dim should be 8
      System.out.println("input: "+input_line);
      len = input_line.length();
      index = 0;
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      if(debug) System.out.println(input_line.substring(index,last)+
			  "| len="+(input_line.substring(index,last).length()));
      dim = Integer.parseInt(input_line.substring(index,last));
      System.out.println("dim="+dim);

      index = last; // nx
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      if(debug) System.out.println(input_line.substring(index+1,last));
      nx = Integer.parseInt(input_line.substring(index,last));
      System.out.println("nx="+nx);

      index = last; // ny
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      if(debug) System.out.println(input_line.substring(index+1,last));
      ny = Integer.parseInt(input_line.substring(index,last));
      System.out.println("ny="+ny);

      index = last; // nz
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      if(debug) System.out.println(input_line.substring(index+1,last));
      nz = Integer.parseInt(input_line.substring(index,last));
      System.out.println("nz="+nz);

      index = last; // nt
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      nt = Integer.parseInt(input_line.substring(index,last));
      System.out.println("nt="+nt);

      index = last; // nu
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      nu = Integer.parseInt(input_line.substring(index,last));
      System.out.println("nu="+nu);

      index = last; // nv
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("last="+last);
      nv = Integer.parseInt(input_line.substring(index,last));
      System.out.println("nv="+nv);

      index = last; // nw
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(last==-1) last = len;
      if(debug) System.out.println("last="+last);
      nw = Integer.parseInt(input_line.substring(index,last));
      System.out.println("nw="+nw);

      index = last; // np
      while(input_line.charAt(index)==' ') index++;
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index);
      if(last==-1) last = len;
      if(debug) System.out.println("last="+last);
      np = Integer.parseInt(input_line.substring(index,last));
      System.out.println("np="+np);

      nxyztuvwp = nx*ny*nz*nt*nu*nv*nw*np;
      System.out.println("about to allocate "+(nxyztuvwp*(dim+1))+" doubles");
      pt = new double[nxyztuvwp][dim+1];
      n_input = 0;

      // read data points, last index varies by 1
      input_line = in.readLine(); // tested for short in 'while'
      while(input_line.length()>8) // exit on blank or short line
      {
	if(debug && n_input==0) System.out.println("input: "+input_line);
        len = input_line.length();
        index = 0; // first x
        while(input_line.charAt(index)==' ') index++;
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index);
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][0] = amount;
        index = input_line.indexOf(' ',last); // second y
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][1] = amount;
        index = input_line.indexOf(' ',last); // third z
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][2] = amount;
        index = input_line.indexOf(' ',last); // fourth t
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][3] = amount;
        index = input_line.indexOf(' ',last); // fifth u
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][4] = amount;
        index = input_line.indexOf(' ',last); // sixth v
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(last==-1) last = len;
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][5] = amount;
        index = input_line.indexOf(' ',last); // seventh w
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(last==-1) last = len;
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][6] = amount;
        index = input_line.indexOf(' ',last); // eighth p
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(last==-1) last = len;
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][7] = amount;
        index = input_line.indexOf(' ',last); // U
        if(debug && n_input==0) System.out.println("index="+index);
        last = input_line.indexOf(' ',index+1);
        if(last==-1) last = len;
        if(debug && n_input==0) System.out.println("last="+last);
        amount = Double.parseDouble(input_line.substring(index+1,last));
        if(debug && n_input==0) System.out.println("amount="+amount);
        pt[n_input][8] = amount;
        if(n_input==0)
	{
	  dxmin = pt[n_input][0];
	  dxmax = pt[n_input][0];
	  dymin = pt[n_input][1];
	  dymax = pt[n_input][1];
	  dzmin = pt[n_input][2];
	  dzmax = pt[n_input][2];
	  dtmin = pt[n_input][3];
	  dtmax = pt[n_input][3];
	  dumin = pt[n_input][4];
	  dumax = pt[n_input][4];
	  dvmin = pt[n_input][5];
	  dvmax = pt[n_input][5];
	  dwmin = pt[n_input][6];
	  dwmax = pt[n_input][6];
	  dpmin = pt[n_input][7];
	  dpmax = pt[n_input][7];
	  dUmin = pt[n_input][8];
	  dUmax = pt[n_input][8];
          System.out.println("first x="+dxmin+", y="+dymin+", z="+dzmin);
          System.out.println("first t="+dtmin+", u="+dumin+", v="+dvmin);
          System.out.println("first w="+dwmin+", d="+dpmin+", U="+dUmin);
	}
	else
	{
	  dxmin = Math.min(dxmin,pt[n_input][0]);
	  dxmax = Math.max(dxmax,pt[n_input][0]);
	  dymin = Math.min(dymin,pt[n_input][1]);
	  dymax = Math.max(dymax,pt[n_input][1]);
	  dzmin = Math.min(dzmin,pt[n_input][2]);
	  dzmax = Math.max(dzmax,pt[n_input][2]);
	  dtmin = Math.min(dtmin,pt[n_input][3]);
	  dtmax = Math.max(dtmax,pt[n_input][3]);
	  dumin = Math.min(dumin,pt[n_input][4]);
	  dumax = Math.max(dumax,pt[n_input][4]);
	  dvmin = Math.min(dvmin,pt[n_input][5]);
	  dvmax = Math.max(dvmax,pt[n_input][5]);
	  dwmin = Math.min(dwmin,pt[n_input][6]);
	  dwmax = Math.max(dwmax,pt[n_input][6]);
	  dpmin = Math.min(dpmin,pt[n_input][7]);
	  dpmax = Math.max(dpmax,pt[n_input][7]);
	  dUmin = Math.min(dUmin,pt[n_input][8]);
	  dUmax = Math.max(dUmax,pt[n_input][8]);
	}
        n_input++;
        if(n_input>=nxyztuvwp) break;
        input_line = in.readLine(); // done with this line, read next
      } // end while
    } // end try
    catch(IOException exception)
    {
      System.out.println(exception);
    }
    System.out.println("read_data finished, n_input="+n_input);
    System.out.println("xmin="+dxmin+", xmax="+dxmax+", last="+pt[nxyztuvwp-1][0]);
    System.out.println("ymin="+dymin+", ymax="+dymax+", last="+pt[nxyztuvwp-1][1]);
    System.out.println("zmin="+dzmin+", zmax="+dzmax+", last="+pt[nxyztuvwp-1][2]);
    System.out.println("tmin="+dtmin+", tmax="+dtmax+", last="+pt[nxyztuvwp-1][3]);
    System.out.println("umin="+dumin+", umax="+dumax+", last="+pt[nxyztuvwp-1][4]);
    System.out.println("vmin="+dvmin+", vmax="+dvmax+", last="+pt[nxyztuvwp-1][5]);
    System.out.println("wmin="+dwmin+", wmax="+dwmax+", last="+pt[nxyztuvwp-1][6]);
    System.out.println("pmin="+dpmin+", pmax="+dpmax+", last="+pt[nxyztuvwp-1][7]);
    System.out.println("Umin="+dUmin+", Umax="+dUmax+", last="+pt[nxyztuvwp-1][8]);
    
    for(int i=0; i<nxyztuvwp; i++)
    {
      pt[i][0] = (pt[i][0]-dxmin)/(dxmax-dxmin);
      pt[i][1] = (pt[i][1]-dymin)/(dymax-dymin);
      pt[i][2] = (pt[i][2]-dzmin)/(dzmax-dzmin);
      pt[i][3] = (pt[i][3]-dtmin)/(dtmax-dtmin);
      pt[i][4] = (pt[i][4]-dumin)/(dumax-dumin);
      pt[i][5] = (pt[i][5]-dvmin)/(dvmax-dvmin);
      pt[i][6] = (pt[i][6]-dwmin)/(dwmax-dwmin);
      pt[i][7] = (pt[i][7]-dpmin)/(dpmax-dpmin);
      pt[i][8] = (pt[i][8]-dUmin)/(dUmax-dUmin);
    }
    repaint();
  } // end read_data
 
  public static void main(String[] args)
  {
    new plot8d();
  }
} // end class  plot8d.java