// plot5d.java  plot  5d data
//             reads from stdin, first line  5 nx ny nz nt nu
//                               many lines  x y z t u U
//                               sorted x first, y next, ...
//                               one space separator
//    java -cp . plot5d <  file.dat > file.out
//                               converted from plot4d.java

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

public class plot5d extends Frame
{
  // mouse and display variables
  int xm, ym, bm; // mouse position 
  int height = 800;
  int width = 850;
  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 Umin = 0.0;
  double Umax = 1.0;
  double dxmin, dxmax, dymin, dymax, dzmin, dzmax;
  double dtmin, dtmax, dumin, dumax, 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 v5min = 0.0;
  double v5max = 1.0;
  double xw, yh, xoff, yoff;
  int dim = 5; // 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, u=4  front axis mouse change
  int var2 = 1; // x=0, y=1, z=2, t=3, u=4  side axis
  int var3 = 2; // x=0, y=1, z=2, t=3, u=4  scan-run 
  int var4 = 3; // x=0, y=1, z=2, t=3, u=4  other-run 
  int var5 = 4; // x=0, y=1, z=2, t=3, u=4  other-run 
  double v1, v2, v3, v4, v5;
  int v3step = 1;
  int v4step = 1;
  int v5step = 1;
  int nx; // computed based on data
  int ny;
  int nz;
  int nt;
  int nu;
  int nv1; //  nx, ny, nz, nt, nu based on var1, var2, var3, var4, var5
  int nv2;
  int nv3;
  int nv4;
  int nv5;
  int nxyztu;
  double pt[][]; // = new double[nxyztu][dim+1];
  double ya = 0.5; //  orthographic typ 0.2 to 0.7, must fix text 
  double xs = (0.60*(width-150));
  double ys = (0.60*(height-100));
  int xp, yp; // for passing back ortho point
  boolean debug = true;
  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 plot5d()
  {
    System.out.println("plot5d.java running.");
    setTitle("plot5d x,y,z,t,u  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;  
      nv1 = nn[0];
      nv2 = nn[1];
      nv3 = nn[2];
      nv4 = nn[3];
      nv5 = nn[4];
      v3step = nn[var3]-1;
      v4step = nn[var4]-1;
      v5step = nn[var5]-1;
    } // end try
    catch(IOException exception)
    {
      System.out.println(exception);
    }
    // repaint();
  } // plot5d 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, v3step, v4step, vstep5 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;
	  for(int iiiii=0; iiiii<nv5; iiiii++)
	  {
	    v5step = iiiii;
            repaint();
            try
	    {
	      sleep(speed); // milliseconds delay
	    }
            catch(InterruptedException excp)
	    {
	      System.out.println("caught Exception");
	    } // end try catch
          } // 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 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))
      {
	// step3D
	requestFocus();
        v5step++;
	if(v5step>=nv5) v5step=0;  
        if(debug) System.out.println("step3D v5step="+v5step);
        repaint();
      }
      else if(in_rect(width-110, height-75, 50, 20))
      {
	// step2D
	requestFocus();
        v4step++;
	if(v4step>=nv4) v4step=0;  
        repaint();
      }
      else if(in_rect(width-160, 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;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        v5step = nn[var5]-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;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        v5step = nn[var5]-1;
        if(debug) System.out.println("next side var1="+var1+",var2="+
		  var2+", var3="+var3+", var4="+var4+", var5="+var5);
        if(debug) System.out.println("v3step="+v3step+", v4step="+
				     v4step+", v5step="+v5step);
        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;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        v5step = nn[var5]-1;
        if(debug) System.out.println("next front var1="+var1+",var2="+
		  var2+", var3="+var3+", var4="+var4+", var5="+var5);
        if(debug) System.out.println("v3step="+v3step+", v4step="+
				     v4step+", v5step="+v5step);
        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("step3D", width-50, height-60);

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

    g.setColor(Color.gray);
    g.fillRect(width-165,height-75,50,20);
    g.setColor(Color.black);
    g.drawString("step1D", width-160, 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);

    // w,x,y,z,t min-max
    g.drawString("xmin=", 300, 50);
    fstring = Double.toString(dxmin);
    g.drawString(fstring, 340, 50);
    g.drawString("xmax=", 500, 50);
    fstring = Double.toString(dxmax);
    g.drawString(fstring, 540, 50);
    g.drawString("nx=", 700, 50);
    fstring = Integer.toString(nx);
    g.drawString(fstring, 740, 50);
    g.drawString("ymin=", 300, 65);
    fstring = Double.toString(dymin);
    g.drawString(fstring, 340, 65);
    g.drawString("ymax=", 500, 65);
    fstring = Double.toString(dymax);
    g.drawString(fstring, 540, 65);
    g.drawString("ny=", 700, 65);
    fstring = Integer.toString(ny);
    g.drawString(fstring, 740, 65);
    g.drawString("zmin=", 300, 80);
    fstring = Double.toString(dzmin);
    g.drawString(fstring, 340, 80);
    g.drawString("zmax=", 500, 80);
    fstring = Double.toString(dzmax);
    g.drawString(fstring, 540, 80);
    g.drawString("nz=", 700, 80);
    fstring = Integer.toString(nz);
    g.drawString(fstring, 740, 80);
    g.drawString("tmin=", 300, 95);
    fstring = Double.toString(dtmin);
    g.drawString(fstring, 340, 95);
    g.drawString("tmax=", 500, 95);
    fstring = Double.toString(dtmax);
    g.drawString(fstring, 540, 95);
    g.drawString("nt=", 700, 95);
    fstring = Integer.toString(nu);
    g.drawString(fstring, 740, 95);
    g.drawString("umin=", 300, 110);
    fstring = Double.toString(dumin);
    g.drawString(fstring, 340, 110);
    g.drawString("umax=", 500, 110);
    fstring = Double.toString(dumax);
    g.drawString(fstring, 540, 110);
    g.drawString("nu=", 700, 110);
    fstring = Integer.toString(nt);
    g.drawString(fstring, 740, 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==4) g.drawString("umin", 25, height-15);
    if(var1==0) g.drawString("xmax", (int)(0.60*width-100), height-15);
    if(var1==1) g.drawString("ymax", (int)(0.60*width-100), height-15);
    if(var1==2) g.drawString("zmax", (int)(0.60*width-100), height-15);
    if(var1==3) g.drawString("tmax", (int)(0.60*width-100), height-15);
    if(var1==4) g.drawString("umax", (int)(0.60*width-100), height-15);

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

    if(var3==0) g.drawString("xmin", (int)(width-122), height-300);
    if(var3==1) g.drawString("ymin", (int)(width-122), height-300);
    if(var3==2) g.drawString("zmin", (int)(width-122), height-300);
    if(var3==3) g.drawString("tmin", (int)(width-122), height-300);
    if(var3==4) g.drawString("umin", (int)(width-122), height-300);
    if(var3==0) g.drawString("xmax", (int)(width-122), 145);
    if(var3==1) g.drawString("ymax", (int)(width-122), 145);
    if(var3==2) g.drawString("zmax", (int)(width-122), 145);
    if(var3==3) g.drawString("tmax", (int)(width-122), 145);
    if(var3==4) g.drawString("umax", (int)(width-122), 145);

    if(var4==0) g.drawString("xmin", (int)(width-86), height-300);
    if(var4==1) g.drawString("ymin", (int)(width-86), height-300);
    if(var4==2) g.drawString("zmin", (int)(width-86), height-300);
    if(var4==3) g.drawString("tmin", (int)(width-86), height-300);
    if(var4==4) g.drawString("umin", (int)(width-86), height-300);
    if(var4==0) g.drawString("xmax", (int)(width-86), 145);
    if(var4==1) g.drawString("ymax", (int)(width-86), 145);
    if(var4==2) g.drawString("zmax", (int)(width-86), 145);
    if(var4==3) g.drawString("tmax", (int)(width-86), 145);
    if(var4==4) g.drawString("umax", (int)(width-86), 145);

    if(var5==0) g.drawString("xmin", (int)(width-50), height-300);
    if(var5==1) g.drawString("ymin", (int)(width-50), height-300);
    if(var5==2) g.drawString("zmin", (int)(width-50), height-300);
    if(var5==3) g.drawString("tmin", (int)(width-50), height-300);
    if(var5==4) g.drawString("umin", (int)(width-50), height-300);
    if(var5==0) g.drawString("xmax", (int)(width-50), 145);
    if(var5==1) g.drawString("ymax", (int)(width-50), 145);
    if(var5==2) g.drawString("zmax", (int)(width-50), 145);
    if(var5==3) g.drawString("tmax", (int)(width-50), 145);
    if(var5==4) g.drawString("umax", (int)(width-50), 145);

    g.drawString("Umin", (int)(width-190), (int)(0.60*height+75));
    g.drawString("Umax", (int)(width-190), (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+20,50,15);
    }
    g.drawString("U value", 80, 50);
    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);
      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];
    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(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(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(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(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; }
    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 color position
    i4 = i4x(0, 0, 0, 0, v5step);
    v5 = pt[i4][var5];
    set_color((int)(ncol*((v5-v5min)/(v5max-v5min))+0.5), g);
    g.fillRect(width-44,height-300-30-10-v5step*(310/(nv5-1)),25,30);
    i4 = i4x(0, 0, 0, v4step, 0);
    v4 = pt[i4][var4];
    set_color((int)(ncol*((v4-v4min)/(v4max-v4min))+0.5), g);
    g.fillRect(width-81,height-300-30-10-v4step*(310/(nv4-1)),25,30);
    i4 = i4x(0, 0, v3step, 0, 0);
    v3 = pt[i4][var3];
    set_color((int)(ncol*((v3-v3min)/(v3max-v3min))+0.5), g);
    g.fillRect(width-118,height-300-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;

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

        if(debug) System.out.println("i="+i+", ii="+ii+", iii="+iii+
                                     ", iiii="+iiii+", iiiii="+iiiii);
        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+", 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);
      i5 = i4x(i+1, ii, iii, iiii, iiiii);
      v1 = pt[i4][var1];
      v2 = v2max;
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      v5 = pt[i4][var5];
      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+", 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);
      i6 = i4x(i, ii+1, iii, iiii, iiiii);
      v2 = pt[i4][var2];
      v1 = v1max;
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      v5 = pt[i4][var5];
      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+", 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)
         // i is var1, ii is var2, iii is var3, iiii is var4, iiiii var5
  {
    int lin;
    int offset[] = { ny*nz*nt*nu, nz*nt*nu, nt*nu, nu, 1 };
    lin = i*offset[var1] + ii*offset[var2] + iii*offset[var3] + 
	  iiii*offset[var4] + iiiii*offset[var5];
    if(lin>=nxyztu)
    {
      System.out.println("index error, lin="+lin+" >= "+nxyztu);
      lin = nxyztu-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;
      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 = 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);
      index = input_line.indexOf(' ',last); // nu
      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);
      nu = Integer.parseInt(input_line.substring(index+1,last));
      System.out.println("nu="+nu);
      nxyztu = nx*ny*nz*nt*nu;
      System.out.println("about to allocate "+(nxyztu*(dim+1))+" doubles");
      pt = new double[nxyztu][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
        while(input_line.charAt(index)==' ') index++; // remove leading spaces
        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,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); // 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][5] = 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];
	  dUmin = pt[n_input][5];
	  dUmax = pt[n_input][5];
          System.out.println("first x="+dxmin+", y="+dymin+", z="+dzmin);
          System.out.println("first t="+dtmin+", u="+dumin+", 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]);
	  dUmin = Math.min(dUmin,pt[n_input][5]);
	  dUmax = Math.max(dUmax,pt[n_input][5]);
	}
        n_input++;
        if(n_input>=nxyztu) 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[nxyztu-1][0]);
    System.out.println("ymin="+dymin+", ymax="+dymax+", last="+pt[nxyztu-1][1]);
    System.out.println("zmin="+dzmin+", zmax="+dzmax+", last="+pt[nxyztu-1][2]);
    System.out.println("tmin="+dtmin+", tmax="+dtmax+", last="+pt[nxyztu-1][3]);
    System.out.println("umin="+dumin+", umax="+dumax+", last="+pt[nxyztu-1][4]);
    System.out.println("Umin="+dUmin+", Umax="+dUmax+", last="+pt[nxyztu-1][5]);
    
    for(int i=0; i<nxyztu; 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]-dUmin)/(dUmax-dUmin);
    }
  } // end read_data
 
  public static void main(String[] args)
  {
    new plot5d();
  }
} // end class  plot5d.java