// plot4d.java   plot up to 4d data, mouse select choice
//               data  4 nx ny nz nt

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

public class plot4d extends Frame
{
  // mouse and display variables
  int xm, ym, bm; // mouse position 
  int height = 750;
  int width = 750;
  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 dxmin, dxmax, dymin, dymax, dzmin, dzmax, dtmin, dtmax, dUmin, dUmax;
  double v1min = 0.0; // 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 xw, yh, xoff, yoff;
  int dim = 4; // should be read in
  int nn[] = new int[dim]; // nx, ny, nz, nt in var order
  int var1 = 0; // x=0, y=1, z=2, t=3 front axis mouse change
  int var2 = 1; // x=0, y=1, z=2, t=3 side axis
  int var3 = 2; // x=0, y=1, z=2, t=3 scan-run 
  int var4 = 3; // x=0, y=1, z=2, t=3 other-run 
  double v1, v2, v3, v4;
  int v3step = 1;
  int v4step = 1;
  int nx; // computed based on data
  int ny;
  int nz;
  int nt;
  int nv1; // nx, ny, nz, nt based on var1, var2, var3, var4
  int nv2;
  int nv3;
  int nv4;
  int nxyzt;
  double pt[][]; // = new double[nxyzt][dim+1];
  double ya = 0.5; //  orthographic typ 0.2 to 0.7, must fix text 
  double xs = (0.60*(width-100));
  double ys = (0.60*(height-100));
  int xp, yp; // for passing back ortho point
  boolean debug = false;
  int n_input;
  boolean run34 = false;
  boolean stop = false;
  int speed = 100; // millisecond delay
  // set up double buffering for smooth "run"
  Image dbImage;
  Graphics dbg; // double buffered graphics

  public plot4d()
  {
    System.out.println("plot4d.java running.");
    setTitle("plot4d x,y,z,t  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;  
      nv1 = nn[0];
      nv2 = nn[1];
      nv3 = nn[2];
      nv4 = nn[3];
      v3step = nn[var3]-1;
      v4step = nn[var4]-1;
    } // end try
    catch(IOException exception)
    {
      System.out.println(exception);
    }
    // repaint();
  } // plot4d 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, v3step, v4step 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);
    }

    public void run()
    {
      for(int iii=0; iii<nv3; iii++)
      {
	v3step = iii;
	for(int iiii=0; iiii<nv4; iiii++)
	{
	  v4step = iiii;
          repaint();
          try
	  {
	    sleep(speed); // milliseconds delay
	  }
          catch(InterruptedException excp)
	  {
	    System.out.println("caught Exception");
	  } // end try catch
        } // 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 scan direction, all unique

      if(in_rect(width-70, height-25, 30, 20))
      {
	// dynamic display, run34
	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))
      {
	// step2D
	requestFocus();
        v4step++;
	if(v4step>=nv4) v4step=0;  
        repaint();
      }
      else if(in_rect(width-110, 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>3) var3 = 0;
        while(var3==var1 || var3==var2)
	{
	  var3++;
          if(var3>3) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
          if(var4>3) var4 = 0;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        repaint();
      }
      else if(in_rect(width-215, height-25, 65, 20))
      {
	// next side
	requestFocus();
	var2++;
        if(var2>3) var2 = 0;
        if(var2==var1) var2++;
        if(var2>3) var2 = 0;
        while(var1==var3 || var2==var3)
	{
	  var3++;
          if(var3>3) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
          if(var4>3) var4 = 0;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        repaint();
      }
      else if(in_rect(width-295, height-25, 70, 20))
      {
	// next front
	requestFocus();
        var1++;
        if(var1>3) var1 = 0;
        if(var1==var2) var2++;
        if(var2>3) var2 = 0;
        while(var1==var3 || var2==var3)
	{
	  var3++;
          if(var3>3) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
          if(var4>3) var4 = 0;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-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("step2D", width-50, height-60);

    g.setColor(Color.gray);
    g.fillRect(width-110,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step1D", width-105, 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 min-max
    g.drawString("xmin=", 300, 50);
    fstring = Double.toString(dxmin);
    g.drawString(fstring, 340, 50);
    g.drawString("xmax=", 450, 50);
    fstring = Double.toString(dxmax);
    g.drawString(fstring, 490, 50);
    g.drawString("nx=", 600, 50);
    fstring = Integer.toString(nx);
    g.drawString(fstring, 640, 50);
    g.drawString("ymin=", 300, 70);
    fstring = Double.toString(dymin);
    g.drawString(fstring, 340, 70);
    g.drawString("ymax=", 450, 70);
    fstring = Double.toString(dymax);
    g.drawString(fstring, 490, 70);
    g.drawString("ny=", 600, 70);
    fstring = Integer.toString(ny);
    g.drawString(fstring, 640, 70);
    g.drawString("zmin=", 300, 90);
    fstring = Double.toString(dzmin);
    g.drawString(fstring, 340, 90);
    g.drawString("zmax=", 450, 90);
    fstring = Double.toString(dzmax);
    g.drawString(fstring, 490, 90);
    g.drawString("nz=", 600, 90);
    fstring = Integer.toString(nz);
    g.drawString(fstring, 640, 90);
    g.drawString("tmin=", 300, 110);
    fstring = Double.toString(dtmin);
    g.drawString(fstring, 340, 110);
    g.drawString("tmax=", 450, 110);
    fstring = Double.toString(dtmax);
    g.drawString(fstring, 490, 110);
    g.drawString("nt=", 600, 110);
    fstring = Integer.toString(nt);
    g.drawString(fstring, 640, 110);


    // axis labels
    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==0) g.drawString("xmax", (int)(0.60*width-80), height-15);
    if(var1==1) g.drawString("ymax", (int)(0.60*width-80), height-15);
    if(var1==2) g.drawString("zmax", (int)(0.60*width-80), height-15);
    if(var1==3) g.drawString("tmax", (int)(0.60*width-80), height-15);

    if(var2==0) g.drawString("xmin", (int)(0.60*width-25), height-25);
    if(var2==1) g.drawString("ymin", (int)(0.60*width-25), height-25);
    if(var2==2) g.drawString("zmin", (int)(0.60*width-25), height-25);
    if(var2==3) g.drawString("tmin", (int)(0.60*width-25), height-25);
    if(var2==0) g.drawString("xmax", (int)(width-145), (int)(0.60*height+100));
    if(var2==1) g.drawString("ymax", (int)(width-145), (int)(0.60*height+100));
    if(var2==2) g.drawString("zmax", (int)(width-145), (int)(0.60*height+100));
    if(var2==3) g.drawString("tmax", (int)(width-145), (int)(0.60*height+100));

    if(var3==0) g.drawString("xmin", (int)(width-72), height-240);
    if(var3==1) g.drawString("ymin", (int)(width-72), height-240);
    if(var3==2) g.drawString("zmin", (int)(width-72), height-240);
    if(var3==3) g.drawString("tmin", (int)(width-72), height-240);
    if(var3==0) g.drawString("xmax", (int)(width-72), 150);
    if(var3==1) g.drawString("ymax", (int)(width-72), 150);
    if(var3==2) g.drawString("zmax", (int)(width-72), 150);
    if(var3==3) g.drawString("tmax", (int)(width-72), 150);

    if(var4==0) g.drawString("xmin", (int)(width-36), height-240);
    if(var4==1) g.drawString("ymin", (int)(width-36), height-240);
    if(var4==2) g.drawString("zmin", (int)(width-36), height-240);
    if(var4==3) g.drawString("tmin", (int)(width-36), height-240);
    if(var4==0) g.drawString("xmax", (int)(width-36), 150);
    if(var4==1) g.drawString("ymax", (int)(width-36), 150);
    if(var4==2) g.drawString("zmax", (int)(width-36), 150);
    if(var4==3) g.drawString("tmax", (int)(width-36), 150);

    g.drawString("Umin", (int)(width-140), (int)(0.60*height+75));
    g.drawString("Umax", (int)(width-140), (int)(155));

    // height color scale
    int hgt = 210;
    for(int i=0; i<ncol; i++)
    {
      set_color(i, g);
      g.fillRect(20,hgt-20*i+30,50,15);
    }
    g.drawString("u value", 80, 50);
    fstring = Double.toString(dUmax);
    g.drawString(fstring, 80, 72);
    nearz = dUmin;
    if(Math.abs(nearz)<1.0E-4) nearz = 0.0;
    fstring = Double.toString(nearz);
    g.drawString(fstring, 80, 252);
    for(int i=1; i<ncol-1; i++)
    {
      fstring = Double.toString(dUmax-dhu*(double)i);
      g.drawString(fstring, 80, 72+20*i);
    }
    // draw box, bottom
    nv1 = nn[var1];
    nv2 = nn[var2];
    nv3 = nn[var3];
    nv4 = nn[var4];
    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(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(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(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; }
    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 color position
    i4 = i4x(0, 0, 0, v4step);
    v4 = pt[i4][var4];
    set_color((int)(ncol*((v4-v4min)/(v4max-v4min))+0.5), g);
    g.fillRect(width-31,height-240-30-10-v4step*(310/(nv4-1)),25,30);
    i4 = i4x(0, 0, v3step, 0);
    v3 = pt[i4][var3];
    set_color((int)(ncol*((v3-v3min)/(v3max-v3min))+0.5), g);
    g.fillRect(width-68,height-240-30-10-v3step*(310/(nv3-1)),25,30);

    // plot function or data with u value colors
    int iii = v3step;
    int iiii = v4step;

    if(debug) System.out.println("paint var1="+var1+", var2="+var2+", var3="+
                                 var3+", var4="+var4);
    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);   // depends on var1..4
	i5 = i4x(i+1, ii, iii, iiii); // depends on var1..4
	i6 = i4x(i, ii+1, iii, iiii); // depends on var1..4
        v1 = pt[i4][var1];
	v2 = pt[i4][var2];
        v3 = pt[i4][var3];
	v4 = pt[i4][var4];
        u1 = pt[i4][dim];

        if(debug) System.out.println("i="+i+", ii="+ii+", iii="+iii+
                                     ", iiii="+iiii);
        if(debug) System.out.println("i4="+i4+", i5="+i5+", i6="+i6);
        if(debug) System.out.println("v1="+v1+", v2="+v2+", v3="+v3+
                                     ", v4="+v4+", 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);
      i5 = i4x(i+1, ii, iii, iiii);
      v1 = pt[i4][var1];
      // ?? v2 = v2max;
      v2 = pt[i4][var2];
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      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+", 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);
      i6 = i4x(i, ii+1, iii, iiii);
      v2 = pt[i4][var2];
      // ?? v1 = v1max;
      v1 = pt[i4][var1];
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      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+", 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)
          // i is var1, ii is var2, iii is var3, iiii is var4
  {
    int lin;
    int offset[] = { ny*nz*nt, nz*nt, nt, 1 };
    lin = i*offset[var1] + ii*offset[var2] + iii*offset[var3] + 
	  iiii*offset[var4];
    if(lin>=nxyzt)
    {
      System.out.println("index error i4x, lin="+lin+" >= "+nxyzt);
      System.out.println("i="+i+" ii="+ii+" iii="+iii+"  iiii="+iiii);
      System.out.println("var1="+var1+" var2="+var2+" var3="+var3+"  var4="+var4);
      System.out.println("offest[0]="+offset[0]+" offset[1]="+offset[1]+" offset[2]="+offset[2]+
			 "  offset[3]="+offset[3]);
      lin = nxyzt-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
      System.out.println("input: "+input_line);
      len = input_line.length();
      index = 0;
      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 = input_line.indexOf(' ',index); // nx
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index+1);
      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+1,last));
      System.out.println("nx="+nx);
      index = input_line.indexOf(' ',last); // ny
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index+1);
      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+1,last));
      System.out.println("ny="+ny);
      index = input_line.indexOf(' ',last); // nz
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index+1);
      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+1,last));
      System.out.println("nz="+nz);
      index = input_line.indexOf(' ',last); // nt
      if(debug) System.out.println("index="+index);
      last = input_line.indexOf(' ',index+1);
      if(last==-1) last = len;
      if(debug) System.out.println("last="+last);
      nt = Integer.parseInt(input_line.substring(index+1,last));
      System.out.println("nt="+nt);
      nxyzt = nx*ny*nz*nt;
      System.out.println("about to allocate "+(nxyzt*(dim+1))+" doubles");
      pt = new double[nxyzt][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()>6) // 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
        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][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); // 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][4] = 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];
          System.out.println("first x="+dxmin+", y="+dymin+", z="+dzmin);
          System.out.println("first t="+dtmin+", 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]);
	}
        n_input++;
        if(n_input>=nxyzt) 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[nxyzt-1][0]);
    System.out.println("ymin="+dymin+", ymax="+dymax+", last="+pt[nxyzt-1][1]);
    System.out.println("zmin="+dzmin+", zmax="+dzmax+", last="+pt[nxyzt-1][2]);
    System.out.println("tmin="+dtmin+", tmax="+dtmax+", last="+pt[nxyzt-1][3]);
    System.out.println("Umin="+dUmin+", Umax="+dUmax+", last="+pt[nxyzt-1][4]);
    
    for(int i=0; i<nxyzt; 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);
    }
  } // end read_data
 
  public static void main(String[] args)
  {
    new plot4d();
  }
} // end class  plot4d.java