// tri_split44.java  split 4D data Utah graphics .dat  and plot
//                   split every 5 point into 3 triangle
//                   split every quadrangle into 2 triangle
//                   split every triangle into 4 triangle
//                   may use dat_clean44.java later
//
//   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 
//                             ip1 *--* ip2  no new points
//        ip1                      |\ |      4  1 2 3 4 replaced by:
// ip5 *---*---* ip2               | \|      3  1 2 3
//      \ / \ /                ip4 *--* ip3  3  3 4 1
//   ip4 *---* ip3
//
// 5  1 2 3 4 5  replaced by  3  1 2 3    3  3 4 1    3  4 5 1

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

public class tri_split44 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, wmin, wmax;
  double ya, xs, ys, zs; // scale for data 0..1
  int xp, yp; // ortho returns
  int pts, pt, k;
  datread44 DR; // = new datread44(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 xyzw[][] = new double[5000][4]; // x, y, z, w for output
  int newpts[] = new int[10000]; // 3, xyzw1, xyzw2, xyzw3 for output
 
  public tri_split44(String filename, String fileout)
  {
    System.out.println("tri_split44.java running");
    setTitle("tri_split44");
    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("datread44.java reading "+filename);
    DR = new datread44(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 input");
    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;
    wmin = DR.data_points[0].z;
    wmax = 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+
			 "  "+DR.data_points[i].w);
      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);
      wmin = Math.min(wmin, DR.data_points[i].w);
      wmax = Math.max(wmax, DR.data_points[i].w);
    } // 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 input");
      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_split44 constructor

  void split(String fileout)
  {
    // double xyzw[][] = new double[5000][3]; // x, y, z, w for output
    // int newpts[] = new int[10000]; // 3, xyzw1, xyzw2, xyzw3 for output
    int ip1, ip2, ip3, np1, np2, np3, ixp;
    double x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4, w1, w2, w3, w4,
	   xh, yh, zh, wh;

    for(int i=0; i<num_points; i++)
    {
      xyzw[i][0] = DR.data_points[i].x;
      xyzw[i][1] = DR.data_points[i].y;
      xyzw[i][2] = DR.data_points[i].z;
      xyzw[i][3] = DR.data_points[i].w;
    }
    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 >5)
      {
        for(int j=0; j<pts; j++)
        {
	  k++; // ignoring input
        }
        continue; // only up to 5 sides for now
      } // end if
      else
      {
        newpts[new_polys++] = 3;
        newpts[new_polys++] = DR.data_polys[k++]; // 1
        newpts[new_polys++] = DR.data_polys[k++]; // 2
        newpts[new_polys++] = DR.data_polys[k++]; // 3

	if(pts>3)
	{
          newpts[new_polys++] = 3;
          newpts[new_polys++] = DR.data_polys[k];   // 3
          newpts[new_polys++] = DR.data_polys[k++]; // 4
          newpts[new_polys++] = DR.data_polys[k-4]; // 1
	}

	if(pts>4)
	{
          newpts[new_polys++] = 3;
          newpts[new_polys++] = DR.data_polys[k];   // 4
          newpts[new_polys++] = DR.data_polys[k++]; // 5
          newpts[new_polys++] = DR.data_polys[k-5]; // 1
	}
      } // 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 may include quad split ...
    {
      ixp = i*4;
      ip1 = newpts[ixp+1];
      ip2 = newpts[ixp+2];
      ip3 = newpts[ixp+3];
      x1 = xyzw[ip1-1][0];
      y1 = xyzw[ip1-1][1];
      z1 = xyzw[ip1-1][2];
      w1 = xyzw[ip1-1][3];
      x2 = xyzw[ip2-1][0];
      y2 = xyzw[ip2-1][1];
      z2 = xyzw[ip2-1][2];
      w2 = xyzw[ip2-1][3];
      x3 = xyzw[ip3-1][0];
      y3 = xyzw[ip3-1][1];
      z3 = xyzw[ip3-1][2];
      w3 = xyzw[ip3-1][3];

      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);
      xyzw[np1-1][0] = (x1 + x2)/2.0;
      xyzw[np1-1][1] = (y1 + y2)/2.0;
      xyzw[np1-1][2] = (z1 + z2)/2.0;
      xyzw[np1-1][3] = (w1 + w2)/2.0;
      xyzw[np2-1][0] = (x2 + x3)/2.0;
      xyzw[np2-1][1] = (y2 + y3)/2.0;
      xyzw[np2-1][2] = (z2 + z3)/2.0;
      xyzw[np2-1][3] = (w2 + w3)/2.0;
      xyzw[np3-1][0] = (x3 + x1)/2.0;
      xyzw[np3-1][1] = (y3 + y1)/2.0;
      xyzw[np3-1][2] = (z3 + z1)/2.0;
      xyzw[np3-1][3] = (w3 + w1)/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 datwrite44(fileout, xyzw, 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, w0=0.0, w1=0.0, w2=0.0;
    double z1=0.0, z2=0.0, x1=0.0, x2=0.0, y1=0.0, y2=0.0, hx, hy, hz, hw;
    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, 45);
    fstring = Double.toString(xmin);
    g.drawString(fstring, 300, 45);
    g.drawString("xmax=", 400, 45);
    fstring = Double.toString(xmax);
    g.drawString(fstring, 450, 45);
    g.drawString("npts=", 550, 45);
    fstring = Integer.toString(DR.num_points);
    g.drawString(fstring, 600, 45);
    g.drawString("ymin=", 250, 60);
    fstring = Double.toString(ymin);
    g.drawString(fstring, 300, 60);
    g.drawString("ymax=", 400, 60);
    fstring = Double.toString(ymax);
    g.drawString(fstring, 450, 60);
    g.drawString("npoly=", 550, 60);
    fstring = Integer.toString(DR.num_polys);
    g.drawString(fstring, 600, 60);
    g.drawString("zmin=", 250, 75);
    fstring = Double.toString(zmin);
    g.drawString(fstring, 300, 75);
    g.drawString("zmax=", 400, 75);
    fstring = Double.toString(zmax);
    g.drawString(fstring, 450, 75);
    g.drawString("wmin=", 250, 90);
    fstring = Double.toString(wmin);
    g.drawString(fstring, 300, 90);
    g.drawString("wmax=", 400, 90);
    fstring = Double.toString(wmax);
    g.drawString(fstring, 450, 90);

    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("wmin="+wmin+", wmax="+wmax);
      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, wmin); xp1=xp; yp1=yp;
        ortho(x2, ymin, zmin, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymax, zmin, wmin); xp1=xp; yp1=yp;
        ortho(x2, ymax, zmin, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymax, zmax, wmin); xp1=xp; yp1=yp;
        ortho(x2, ymax, zmax, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymin, zmax, wmin); xp1=xp; yp1=yp;
        ortho(x2, ymin, zmax, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymin, zmin, wmax); xp1=xp; yp1=yp;
        ortho(x2, ymin, zmin, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymax, zmin, wmax); xp1=xp; yp1=yp;
        ortho(x2, ymax, zmin, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymax, zmax, wmax); xp1=xp; yp1=yp;
        ortho(x2, ymax, zmax, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(x1, ymin, zmax, wmax); xp1=xp; yp1=yp;
        ortho(x2, ymin, zmax, wmax); 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, wmin); xp1=xp; yp1=yp;
        ortho(xmin, y2, zmin, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, y1, zmin, wmin); xp1=xp; yp1=yp;
        ortho(xmax, y2, zmin, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, y1, zmax, wmin); xp1=xp; yp1=yp;
        ortho(xmax, y2, zmax, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, y1, zmax, wmin); xp1=xp; yp1=yp;
        ortho(xmin, y2, zmax, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, y1, zmin, wmax); xp1=xp; yp1=yp;
        ortho(xmin, y2, zmin, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, y1, zmin, wmax); xp1=xp; yp1=yp;
        ortho(xmax, y2, zmin, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, y1, zmax, wmax); xp1=xp; yp1=yp;
        ortho(xmax, y2, zmax, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, y1, zmax, wmax); xp1=xp; yp1=yp;
        ortho(xmin, y2, zmax, wmax); 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, wmin); xp1=xp; yp1=yp;
        ortho(xmin, ymin, z2, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, ymax, z1, wmin); xp1=xp; yp1=yp;
        ortho(xmin, ymax, z2,wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, ymax, z1, wmin); xp1=xp; yp1=yp;
        ortho(xmax, ymax, z2, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, ymin, z1, wmin); xp1=xp; yp1=yp;
        ortho(xmax, ymin, z2, wmin); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, ymin, z1, wmax); xp1=xp; yp1=yp;
        ortho(xmin, ymin, z2, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmin, ymax, z1, wmax); xp1=xp; yp1=yp;
        ortho(xmin, ymax, z2, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, ymax, z1, wmax); xp1=xp; yp1=yp;
        ortho(xmax, ymax, z2, wmax); xp2=xp; yp2=yp;
        g.drawLine(xp1, yp1, xp2, yp2);
        ortho(xmax, ymin, z1, wmax); xp1=xp; yp1=yp;
        ortho(xmax, ymin, z2, wmax); 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, 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);

      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-40); // ??
      g.drawString("W", 30, height-35);
      g.drawLine(25, height-40, 23, height-34);
      g.drawLine(25, height-40, 18, height-36);
    } // 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;
          w1 = DR.data_points[pt-1].w;
          ortho(x1, y1, z1, w1); 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;
        w2 = DR.data_points[pt-1].w;
        ortho(x2, y2, z2, w2); 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(colora==4)
	  set_color((int)((ncol*(((w1+w2)/2.0)-wmin)/(wmax-wmin))), 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(colora==4)
	  set_color((int)((ncol*((w1-wmin)/(wmax-wmin)))), 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, w0); 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(colora==4)
	set_color((int)((ncol*(((w0+w2)/2.0-wmin)/(wmax-wmin)))), 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 w)
  {
      double x1, y1, z1, w1, x2, y2, z2, w2, x3, y3, z3, w3;
    x1 = (x-xmin)/(xmax-xmin);   // zero base
    y1 = (y-ymin)/(ymax-ymin); 
    z1 = (z-zmin)/(zmax-zmin);
    w1 = (w-wmin)/(wmax-wmin);
    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
 
  class MyThread extends Thread
  {
    MyThread()
    {
    } // end MyThread constructor
    
    public void run()
    {
      repaint(); // dummy in 2D
    } // end Run
  } // end class MyThread

  public static void main(String[] args)
  {
    String filename = args[0];
    String fileout = args[1];
    new tri_split44(filename, fileout);
  }
} // end class  tri_split44.java