// tri_split.java  plot 3d data Utah graphics .dat
//                 java -cp . tri_split inp.dat out.dat
//                 split every triangle into 4 triangle
//   ip1  np1  ip2
//     *---+---*
//      \1/4\2/        * initial points
//   np3 +---+ np2     + new points at edge center of initial triangle
//        \3/          four triangles replace initial triangle
//         *           remember, in utah .dat  ip and np are +1 of subscript
//        ip3 

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

public class tri_split extends Frame
{
  // mouse and display variables
  boolean debug = true;
  int xm, ym, bm; // mouse position 
  int height = 700;
  int width = 700;
  double xmin, xmax, ymin, ymax, zmin, zmax;
  double ya, xs, ys, zs; // scale for data 0..1
  int xp, yp; // ortho returns
  int pts, pt, k;
  datread DR; // = new datread(filename); // defines data structures
  int grid = 1; // box off/on
  int colora = 0; // black, X, Y, Z
  int points = 0; // lines, points only, both
  int num_points = 0; // set from datread
  int num_polys = 0; // set from datread
  int new_points = 0; // 3 added for each poly (triangle)
  int new_polys = 0; // 1 changed and 3 added for each poly
  double xyz[][] = new double[5000][3]; // x, y, z for output
  int newpts[] = new int[10000]; // 3, xyz1, xyz2, xyz3 for output
 
  public tri_split(String filename, String fileout)
  {
    System.out.println("tri_split.java running");
    setTitle("tri_split");
    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());

    System.out.println("datread.java reading "+filename);
    DR = new datread(filename); // defines data structures
    num_points = DR.num_points;
    num_polys = DR.num_polys;
    System.out.println("num_points="+DR.num_points+
                       ", num_polys="+DR.num_polys);
    System.out.println("print vertices");
    xmin = DR.data_points[0].x;
    xmax = DR.data_points[0].x;
    ymin = DR.data_points[0].y;
    ymax = DR.data_points[0].y;
    zmin = DR.data_points[0].z;
    zmax = DR.data_points[0].z;
    for(int i=0; i<DR.num_points; i++) // vertices
    {
      System.out.println(+(i+1)+"  "+DR.data_points[i].x+
                         "  "+DR.data_points[i].y+"  "+DR.data_points[i].z);
      xmin = Math.min(xmin, DR.data_points[i].x);
      xmax = Math.max(xmax, DR.data_points[i].x);
      ymin = Math.min(ymin, DR.data_points[i].y);
      ymax = Math.max(ymax, DR.data_points[i].y);
      zmin = Math.min(zmin, DR.data_points[i].z);
      zmax = Math.max(zmax, DR.data_points[i].z);
    } // end print vertices

    if(Math.abs(zmin-zmax)<0.001) zmax=zmin+0.1;

    ya = 0.5;     //  orthographic typ 0.1 to 0.5 
    xs = (0.65*(width-100));  // (xmax-xmin); in ortho
    ys = (0.65*(height-100)); // (ymax-ymin);
    zs = (0.65*(height-100)); // (zmax-zmin);

    if(debug)
    {
      System.out.println("print polygons");
      k = 0; // polygons
      for(int i=0; i<DR.num_polys; i++)
      {
        pts = DR.data_polys[k++];
        System.out.print(+pts); // no cr
        for(int j=0; j<pts; j++)
        {
          pt = DR.data_polys[k++];
          System.out.print(" "+ pt);
        }
        System.out.println(" ");
      } // end print polygons
    } // end if
    split(fileout);

  } // tri_split constructor

  void split(String fileout)
  {
    // double xyz[][] = new double[5000][3]; // x, y, z for output
    // int newpts[] = new int[10000]; // 3, xyz1, xyz2, xyz3 for output
    int ip1, ip2, ip3, np1, np2, np3, ixp;
    double x1, x2, x3, y1, y2, y3, z1, z2, z3, xh, yh, zh;

    for(int i=0; i<num_points; i++)
    {
      xyz[i][0] = DR.data_points[i].x;
      xyz[i][1] = DR.data_points[i].y;
      xyz[i][2] = DR.data_points[i].z;
    }
    new_points = num_points;

    k = 0; // polygons
    new_polys = 0;
    for(int i=0; i<DR.num_polys; i++)
    {
      pts = DR.data_polys[k++];
      if(pts !=3)
      {
        for(int j=0; j<pts; j++)
        {
          k++;
        }
        continue; // only triangles for now
      } // end if
      else
      {
        newpts[new_polys++] = 3;
        for(int j=0; j<pts; j++)
        {
          newpts[new_polys++] = DR.data_polys[k++];
        }
      } // end else
    } // end copy polygons
    new_polys = new_polys/4;
    System.out.println("split new_points="+new_points+", new_polys="+new_polys);
    num_polys = new_polys;
    for(int i=0; i<num_polys; i++) // from old
    {
      ixp = i*4;
      ip1 = newpts[ixp+1];
      ip2 = newpts[ixp+2];
      ip3 = newpts[ixp+3];
      x1 = xyz[ip1-1][0];
      y1 = xyz[ip1-1][1];
      z1 = xyz[ip1-1][2];
      x2 = xyz[ip2-1][0];
      y2 = xyz[ip2-1][1];
      z2 = xyz[ip2-1][2];
      x3 = xyz[ip3-1][0];
      y3 = xyz[ip3-1][1];
      z3 = xyz[ip3-1][2];

      np1 = new_points+1;
      np2 = new_points+2;
      np3 = new_points+3;
      new_points = new_points+3;
      System.out.println("np1="+np1+", np2="+np2+", np3="+np3);
      xyz[np1-1][0] = (x1 + x2)/2.0;
      xyz[np1-1][1] = (y1 + y2)/2.0;
      xyz[np1-1][2] = (z1 + z2)/2.0;
      xyz[np2-1][0] = (x2 + x3)/2.0;
      xyz[np2-1][1] = (y2 + y3)/2.0;
      xyz[np2-1][2] = (z2 + z3)/2.0;
      xyz[np3-1][0] = (x3 + x1)/2.0;
      xyz[np3-1][1] = (y3 + y1)/2.0;
      xyz[np3-1][2] = (z3 + z1)/2.0;

      // now build 4 triangles, first overwrites triangle being split
      newpts[ixp] = 3; // new tri1
      newpts[ixp+1] = ip1;
      newpts[ixp+2] = np1;
      newpts[ixp+3] = np3;
      ixp = 4*new_polys;
      newpts[ixp] = 3; // new tri2
      newpts[ixp+1] = np1;
      newpts[ixp+2] = ip2;
      newpts[ixp+3] = np2;
      ixp = ixp+4;
      newpts[ixp] = 3; // new tri3
      newpts[ixp+1] = np2;
      newpts[ixp+2] = ip3;
      newpts[ixp+3] = np3;
      ixp = ixp+4;
      newpts[ixp] = 3; // new tri4
      newpts[ixp+1] = np1;
      newpts[ixp+2] = np2;
      newpts[ixp+3] = np3;
      new_polys = new_polys+3;
    } // end i

    new datwrite(fileout, xyz, new_points, newpts, new_polys);
  } // end split

  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

      if(in_rect(width-100, height-30, 40, 30)) // bigger is down
      {
	// do something, color axis
	colora = colora+1;
	if(colora>3) colora = 0;
	requestFocus();
        repaint();
      }
      else if(in_rect(width-135, height-30, 30, 30))
      {
	// do something, grid on/off
	grid = grid+1;
	if(grid>1) grid = 0;
	requestFocus();
        repaint();
      }
      else if(in_rect(width-175, height-30, 35, 30))
      {
	// do something, points
        points = points+1;
        if(points>2) points = 0;
	requestFocus();
        repaint();
      }
      if(in_rect(width-50, height-30, 30, 30)) 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;
  }
 
  public void paint(Graphics g)
  {
    double x, y, z;
    double x0=0.0, y0=0.0, z0=0.0;
    double z1=0.0, z2=0.0, x1=0.0, x2=0.0, y1=0.0, y2=0.0, hx, hy, hz;
    int xp1=0, yp1=0, xp2=0, yp2=0; // line segment
    String fstring;
    int hgt = 240;
    int ncol = 10;

    if(debug==false) return; // ???
    
    // buttons
    g.setColor(Color.red);
    g.fillRect(width-55,height-20,30,15);
    g.setColor(Color.black);
    g.drawString("quit", width-50, height-10);
    g.setColor(Color.green);
    g.fillRect(width-100,height-20,40,15);
    g.setColor(Color.black);
    g.drawString("color", width-95, height-10);
    g.setColor(Color.yellow);
    g.fillRect(width-135,height-20,30,15);
    g.setColor(Color.black);
    g.drawString("grid", width-130, height-10);
    g.setColor(Color.orange);
    g.fillRect(width-175,height-20,35,15);
    g.setColor(Color.black);
    g.drawString("pts", width-170, height-10);


    //  color scale
    if(colora==1)
    {
      g.drawString("x value", 80, 50);
      for(int i=0; i<ncol; i++)
      {
        set_color(i, g);
        g.fillRect(20,hgt-20*i,50,15);
        fstring = Double.toString(xmin + (double)i*(xmax-xmin)/(double)(ncol-1));
        g.drawString(fstring, 80, hgt-20*i+15);
      } // end height
    } // end X scale
    if(colora==2)
    {
      g.drawString("y value", 80, 50);
      for(int i=0; i<ncol; i++)
      {
        set_color(i, g);
        g.fillRect(20,hgt-20*i,50,15);
        fstring = Double.toString(ymin + (double)i*(ymax-ymin)/(double)(ncol-1));
        g.drawString(fstring, 80, hgt-20*i+15);
      } // end height
    } // end Y scale
    if(colora==3)
    {
      g.drawString("z value", 80, 50);
      for(int i=0; i<ncol; i++)
      {
        set_color(i, g);
        g.fillRect(20,hgt-20*i,50,15);
        fstring = Double.toString(zmin + (double)i*(zmax-zmin)/(double)(ncol-1));
        g.drawString(fstring, 80, hgt-20*i+15);
      } // end height
    } // end Z scale

    g.setColor(Color.black);
    // min and max
    g.drawString("xmin=", 250, 50);
    fstring = Double.toString(xmin);
    g.drawString(fstring, 300, 50);
    g.drawString("xmax=", 400, 50);
    fstring = Double.toString(xmax);
    g.drawString(fstring, 450, 50);
    g.drawString("npts=", 550, 50);
    fstring = Integer.toString(DR.num_points);
    g.drawString(fstring, 600, 50);
    g.drawString("ymin=", 250, 65);
    fstring = Double.toString(ymin);
    g.drawString(fstring, 300, 65);
    g.drawString("ymax=", 400, 65);
    fstring = Double.toString(ymax);
    g.drawString(fstring, 450, 65);
    g.drawString("npoly=", 550, 65);
    fstring = Integer.toString(DR.num_polys);
    g.drawString(fstring, 600, 65);
    g.drawString("zmin=", 250, 80);
    fstring = Double.toString(zmin);
    g.drawString(fstring, 300, 80);
    g.drawString("zmax=", 400, 80);
    fstring = Double.toString(zmax);
    g.drawString(fstring, 450, 80);

    if(grid==1)
    {
      // axis labels
      g.drawString("xmin", 25, height-15);
      g.drawString("xmax", (int)(0.65*width-70), height-15);
      g.drawString("ymin", (int)(0.65*width-30), height-20);
      g.drawString("ymax", (int)(width-80), (int)(0.65*height)+40);
      g.drawString("zmin", (int)(width-75), (int)(0.65*height)+20);
      g.drawString("zmax", (int)(width-75), (int)(100));

      // draw box, colora
      if(debug) System.out.println("xmin="+xmin+", xmax="+xmax);
      if(debug) System.out.println("ymin="+ymin+", ymax="+ymax);
      if(debug) System.out.println("zmin="+zmin+", zmax="+zmax);
      if(debug) System.out.println("xs="+xs+", ys="+ys);
      if(debug) System.out.println("zs="+zs+", ya="+ya);

      // draw box edges with X value colors
      x1 = xmin;
      hx = (xmax-xmin)/(ncol);
      for(int i=0; i<ncol; i++)
      {
        x2 = x1+hx;
        g.setColor(Color.black);
        if(colora==1)set_color(i,g);
        ortho(x1, ymin, zmin); xp1=xp; yp1=yp;
        ortho(x2, ymin, zmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymax, zmin); xp1=xp; yp1=yp;
        ortho(x2, ymax, zmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymax, zmax); xp1=xp; yp1=yp;
        ortho(x2, ymax, zmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymin, zmax); xp1=xp; yp1=yp;
        ortho(x2, ymin, zmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        x1 = x2;
      } // end X colors

      // draw box edges with Y value colors
      y1 = ymin;
      hy = (ymax-ymin)/(ncol);
      for(int i=0; i<ncol; i++)
      {
        y2 = y1+hy;
        g.setColor(Color.black);
        if(colora==2)set_color(i,g);
        ortho(xmin, y1, zmin); xp1=xp; yp1=yp;
        ortho(xmin, y2, zmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, y1, zmin); xp1=xp; yp1=yp;
        ortho(xmax, y2, zmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, y1, zmax); xp1=xp; yp1=yp;
        ortho(xmax, y2, zmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, y1, zmax); xp1=xp; yp1=yp;
        ortho(xmin, y2, zmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        y1 = y2;
      } // end Y colors

      // draw box edges with z value colors
      z1 = zmin;
      hz = (zmax-zmin)/(ncol);
      for(int i=0; i<ncol; i++)
      {
        z2 = z1+hz;
        g.setColor(Color.black);
        if(colora==3)set_color(i,g);
        ortho(xmin, ymin, z1); xp1=xp; yp1=yp;
        ortho(xmin, ymin, z2); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, ymax, z1); xp1=xp; yp1=yp;
        ortho(xmin, ymax, z2); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, ymax, z1); xp1=xp; yp1=yp;
        ortho(xmax, ymax, z2); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, ymin, z1); xp1=xp; yp1=yp;
        ortho(xmax, ymin, z2); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        z1 = z2;
      } // end Z colors
    } // end grid
    else  // grid==0
    {
      g.setColor(Color.black);
      g.drawLine(10, height-15, 30, height-15);
      g.drawString("X", 35, height-10);
      g.drawLine(30, height-15, 25, height-17);
      g.drawLine(30, height-15, 25, height-13);

      g.drawLine(10, height-15, 10, height-35);
      g.drawString("Z", 10, height-40);
      g.drawLine(10, height-35, 12, height-30);
      g.drawLine(10, height-35,  8, height-30);

      g.drawLine(10, height-15, 25, height-30);
      g.drawString("Y", 30, height-35);
      g.drawLine(25, height-30, 23, height-24);
      g.drawLine(25, height-30, 18, height-26);
    } // end else grid

    // plot function or data with optional colors, points
    k = 0; // polygons auto incr
    for(int i=0; i<DR.num_polys; i++)
    {
      pts = DR.data_polys[k++];
      if(debug) System.out.println("k="+(k-1)+", ipoly="+i+", pts="+pts);
      for(int j=0; j<pts-1; j++)
      {
	if(j<1)
	{
          pt = DR.data_polys[k++];
          x1 = DR.data_points[pt-1].x;
          y1 = DR.data_points[pt-1].y;
          z1 = DR.data_points[pt-1].z;
          ortho(x1, y1, z1); xp1=xp; yp1=yp;
          x0 = x1;
          y0 = y1;
          z0 = z1;
	}
        pt = DR.data_polys[k++];
        x2 = DR.data_points[pt-1].x;
        y2 = DR.data_points[pt-1].y;
        z2 = DR.data_points[pt-1].z;
        ortho(x2, y2, z2); xp2=xp; yp2=yp;
        g.setColor(Color.black);
        if(colora==1)
	  set_color((int)((ncol*(((x1+x2)/2.0)-xmin)/(xmax-xmin))), g);
        if(colora==2)
	  set_color((int)((ncol*(((y1+y2)/2.0)-ymin)/(ymax-ymin))), g);
        if(colora==3)
	  set_color((int)((ncol*(((z1+z2)/2.0)-zmin)/(zmax-zmin))), g);
        if(points==0 || points==2) g.drawLine(xp1, yp1, xp2, yp2);

        if(colora==1)
	  set_color((int)((ncol*((x1-xmin)/(xmax-xmin)))), g);
        if(colora==2)
	  set_color((int)((ncol*((y1-ymin)/(ymax-ymin)))), g);
        if(colora==3)
	  set_color((int)((ncol*((z1-zmin)/(zmax-zmin)))), g);
        if(points>0) g.fillOval(xp1-4, yp1-4, 8, 8);
        xp1 = xp2;
        yp1 = yp2;
      } // end this poly, now close
      ortho(x0, y0, z0); xp2=xp; yp2=yp;
      g.setColor(Color.black);
      if(colora==1)
	set_color((int)((ncol*(((x0+x2)/2.0-xmin)/(xmax-xmin)))), g);
      if(colora==2)
        set_color((int)((ncol*(((y0+y2)/2.0-ymin)/(ymax-ymin)))), g);
      if(colora==3)
	set_color((int)((ncol*(((z0+z2)/2.0-zmin)/(zmax-zmin)))), g);
      if(points==0 || points==2) g.drawLine(xp1, yp1, xp2, yp2);
    } // end polygons

  } // end paint

  // orthographic projection, sets xp,yp
  void ortho(double x, double y, double z)
  {
    double x1, y1, z1, x2, y2, x3, y3;
    x1 = (x-xmin)/(xmax-xmin);   // zero base
    y1 = (y-ymin)/(ymax-ymin); 
    z1 = (z-zmin)/(zmax-zmin);
    x2 = x1+y1*ya; // ortho z is up, y is back
    y2 = z1+y1*ya;
    x3 = x2*xs;    // scale 
    y3 = y2*zs;    // was ys
    x3 = x3+25;
    y3 = height-y3-25; // away from boarder and text
    xp = (int)x3;
    yp = (int)y3;
  }

  void set_color(int i, Graphics g)
  {
    if(i<0) {g.setColor(Color.black); return;}
    if(i>9) {g.setColor(Color.yellow); return; }
    switch(i)
    {
      case 0: g.setColor(Color.black); break;
      case 1: g.setColor(Color.gray); break;
      case 2: g.setColor(Color.blue); break;
      case 3: g.setColor(Color.green); break;
      case 4: g.setColor(Color.red); break;
      case 5: g.setColor(Color.magenta); break;
      case 6: g.setColor(Color.cyan); break;
      case 7: g.setColor(Color.orange); break;
      case 8: g.setColor(Color.pink); break;
      case 9: g.setColor(Color.yellow); break;
    }
  } // end set_color
 
  public static void main(String[] args)
  {
    String filename = args[0];
    String fileout = args[1];
    new tri_split(filename, fileout);
  }
} // end class  tri_split.java