// plot_4d.java   plot up to 4d data, mouse select choice

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

public class plot_4d extends Frame
{
  // mouse and display variables
  int xm, ym, bm; // mouse position 
  int height = 800;
  int width = 800;
  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 = 5; // computed based on data
  int ny = 5;
  int nz = 5;
  int nt = 5;
  int nv1 = 5; // nx, ny, nz, nt based on var1, var2, var3, var4
  int nv2 = 5;
  int nv3 = 5;
  int nv4 = 5;
  int nxyzt = nx*ny*nz*nt;
  double pt[][]; // = new double[nxyzt][dim+1];
  double ya = 0.5; //  orthographic typ 0.2 to 0.7, must fix text 
  double xs = (0.666*(width-100));
  double ys = (0.666*(height-100));
  int xp, yp; // for passing back ortho point
  boolean debug = true;
  int n_input;
  boolean run34 = false;

  public plot_4d()
  {
    System.out.println("plot_4d.java running.");
    setTitle("plot_4d 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[var1];
      nv2 = nn[var2];
      nv3 = nn[var3];
      nv4 = nn[var4];
      v3step = nn[var3]-1;
      v4step = nn[var4]-1;
    } // end try
    catch(IOException exception)
    {
      System.out.println(exception);
    }
    repaint();
  } // plot_4d constructor

  public class do_scan extends Thread 
  // var1, var2, var3, var4, v3step, v4step can be changed
  {
    do_scan()
    {
      System.out.println("do_scan on var3="+var3+" with nv3="+nv3);
      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(200); // 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-20, 30, 20))
      {
	// dynamic display, run34
	requestFocus();
        new do_scan().start();
      }
      else if(in_rect(width-55, height-40, 50, 20))
      {
	// step2D
	requestFocus();
        v4step++;
	if(v4step>=nv4) v4step=0;  
        repaint();
      }
      else if(in_rect(width-110, height-40, 50, 20))
      {
	// step1D
	requestFocus();
        v3step++;
	if(v3step>=nv3) v3step=0;  
        repaint();
      }
      else if(in_rect(width-140, height-20, 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++;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        repaint();
      }
      else if(in_rect(width-215, height-20, 65, 20))
      {
	// next side
	requestFocus();
	var2++;
        if(var2>3) var2 = 0;
        if(var2==var1) var2++;
        while(var1==var3 || var2==var3)
	{
	  var3++;
          if(var3>3) var3 = 0;
	}
        var4 = 0;
        while(var4==var1 || var4==var2 || var4==var3)
	{
	  var4++;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        repaint();
      }
      else if(in_rect(width-295, height-20, 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++;
	}
        v3step = nn[var3]-1;
        v4step = nn[var4]-1;
        repaint();
      }
      if(in_rect(width-35, height-20, 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;
    int xp1, yp1, xp2, yp2; // line segment
    int i4, i5, i6;

    g.setColor(Color.black);
    g.drawString("plot_4d  u(x,y,z,t) control buttons bottom right", 200, 50);
    // buttons
    g.setColor(Color.red);
    g.fillRect(width-35,height-20,30,15);
    g.setColor(Color.black);
    g.drawString("quit", width-30, height-10);

    g.setColor(Color.green);
    g.fillRect(width-70,height-20,30,15);
    g.setColor(Color.black);
    g.drawString("run", width-65, height-10);
    
    g.setColor(Color.gray);
    g.fillRect(width-55,height-40,50,15);
    g.setColor(Color.black);
    g.drawString("step2D", width-50, height-30);

    g.setColor(Color.gray);
    g.fillRect(width-110,height-40,50,15);
    g.setColor(Color.black);
    g.drawString("step1D", width-105, height-30);

    g.setColor(Color.pink);
    g.fillRect(width-140,height-20,60,15);
    g.setColor(Color.black);
    g.drawString("next scan", width-135, height-10);

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

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

    // 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.66*width-70), height-15);
    if(var1==1) g.drawString("ymax", (int)(0.66*width-70), height-15);
    if(var1==2) g.drawString("zmax", (int)(0.66*width-70), height-15);
    if(var1==3) g.drawString("tmax", (int)(0.66*width-70), height-15);

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

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

    if(var4==0) g.drawString("xmin", (int)(width-36), height-300);
    if(var4==1) g.drawString("ymin", (int)(width-36), height-300);
    if(var4==2) g.drawString("zmin", (int)(width-36), height-300);
    if(var4==3) g.drawString("tmin", (int)(width-36), height-300);
    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-75), (int)(0.66*height+5));
    g.drawString("umax", (int)(width-75), (int)(85));

    // height color scale
    int hgt = 210;
    int ncol = 10;
    for(int i=0; i<ncol; i++)
    {
      set_color(i, g);
      g.fillRect(20,hgt-20*i,50,15);
    }
    g.drawString("u value", 80, 40);

    // draw box, bottom
    if(var1==0) { v1min = xmin; v1max = xmax; nv1 = nx; }
    if(var1==1) { v1min = ymin; v1max = ymax; nv1 = ny; }
    if(var1==2) { v1min = zmin; v1max = zmax; nv1 = nz; }
    if(var1==3) { v1min = tmin; v1max = tmax; nv1 = nt; }
    if(var2==0) { v2min = xmin; v1max = xmax; nv2 = nx; }
    if(var2==1) { v2min = ymin; v1max = ymax; nv2 = ny; }
    if(var2==2) { v2min = zmin; v1max = zmax; nv2 = nz; }
    if(var2==3) { v2min = tmin; v1max = tmax; nv2 = nt; }
    if(var3==0) { v3min = xmin; v1max = xmax; nv3 = nx; }
    if(var3==1) { v3min = ymin; v1max = ymax; nv3 = ny; }
    if(var3==2) { v3min = zmin; v1max = zmax; nv3 = nz; }
    if(var3==3) { v3min = tmin; v1max = tmax; nv3 = nt; }
    if(var4==0) { v4min = xmin; v1max = xmax; nv4 = nx; }
    if(var4==1) { v4min = ymin; v1max = ymax; nv4 = ny; }
    if(var4==2) { v4min = zmin; v1max = zmax; nv4 = nz; }
    if(var4==3) { v4min = tmin; v1max = tmax; nv4 = nt; }
    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-300-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-300-30-10-v3step*(310/(nv3-1)),25,30);

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

    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];

        System.out.println("i="+i+", ii="+ii+", iii="+iii+
                           ", iiii="+iiii);
        System.out.println("i4="+i4+", i5="+i5+", i6="+i6);
        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];
        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];
        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;
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      u1 = pt[i4][dim];
      System.out.println("i4="+i4+", i5="+i5);
      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;
      v3 = pt[i4][var3];
      v4 = pt[i4][var4];
      u1 = pt[i4][dim];
      System.out.println("i4="+i4+", i6="+i6);
      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, lin="+lin+" >= "+nxyzt);
      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(Color.pink); break; // should be 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 rderiv(int order, int npts, int point, double h, double c[])
  {
    nderiv D = new nderiv();
    int a[] = new int[npts]; // basic discretization from nderiv
    int b[] = new int[1];    // out parameter, denominator

    D.deriv(order,npts,point,a,b);
    for(int i=0; i<npts; i++)
    {
      c[i] = (double)a[i]/((double)b[0]);
      for(int j=0; j<order; j++) c[i] = c[i]/h;
    }
  } // end rderiv

  int S(int i, int ii, int iii, int iiii)
  {
      return i*ny*nz*nt + ii*nz*nt + iii*nt + iiii;
  } // end S

  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];
	}
	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 plot_4d();
  }
} // end class  plot_4d.java