/*----------------------------------------------------------------------*/
/* HBlock -- contains hyperblock data
                                                                        */
/*----------------------------------------------------------------------*/
/*         Jim Morey -- morey@math.ubc.ca -- February 4, 1997           */
/*----------------------------------------------------------------------*/

import java.io.*;
import java.awt.*;
import java.lang.*;
import java.awt.Color;
import java.net.*;
import O4matrix;

public class HBlock extends Object{
  public O4matrix orient;
  public int cenx,ceny,W,H,npoints,ncons;
  public double Scale,Zeye=10;
  public int[][][][] hblock;

  public double[][] points, rotPts;
  public int[][] cons, scrPts;
  public int[] dim;
  Color colours[];
  int colourIndex=0;
 
  HBlock(InputStream is, int wid, int heig) 
    throws IOException{
    getSolidData(is);
    rotPts = new double[npoints][4];
    scrPts = new int[npoints][2];

    /* .. regular setup .. */

    W = wid / 2;
    H = heig / 2;

    orient = new O4matrix();

    int i,j;
    double bound[][];
    bound = new double[4][2];
    double len;
    for (i=0;i<4;i++){
      bound[i][0]= 100000;
      bound[i][1]= -100000;
    }
    for (i=0;i<npoints;i++){
      for (j=0;j<4;j++){
        if (bound[j][0]> points[i][j]) bound[j][0] = points[i][j];
        if (bound[j][1]< points[i][j]) bound[j][1] = points[i][j];
      }
    }

    double max=0;
    for (i=0;i<4;i++){
      max+= (bound[i][1]-bound[i][0])*(bound[i][1]-bound[i][0]);
      bound[i][0] = (bound[i][0]+bound[i][1])/2;
    }
    max = Math.sqrt(max)/1.4;
    for (i=0;i<npoints;i++){
      for (j=0;j<4;j++){
        points[i][j]-=bound[j][0];
      }
    }
   
    if (W>H) Scale= (double)H/max;
    else Scale= (double)W/max;

    CalcScrPts((double)W,(double)H,0);
    colours = new Color[4];
    colourChange();
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  void colourChange(){
    colours[colourIndex %4] = Color.black;
    colours[(colourIndex+1) %4] = Color.red;
    colours[(colourIndex+2) %4] = Color.white;
    colours[(colourIndex+3) %4] = Color.blue;
    colourIndex++;
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  void getSolidData(InputStream is) throws IOException{
    String              str, name, thing;
 
    StreamTokenizer token = new StreamTokenizer(is);
    token.eolIsSignificant(false);
    token.commentChar('#');
 
    /* .. get the block parameters .. */
    dim = new int[4];
    token.nextToken();
    dim[0] = (int)token.nval;
    token.nextToken();
    dim[1] = (int)token.nval;
    token.nextToken();
    dim[2] = (int)token.nval;
    token.nextToken();
    dim[3] = (int)token.nval;
    token.nextToken();
    npoints = (int)token.nval;
    token.nextToken();
    ncons = (int)token.nval;
    
    /* .. get the block data .. */
    hblock = new int[dim[0]][dim[1]][dim[2]][dim[3]];
    points = new double[npoints][4];
    cons = new int[ncons][3];
    npoints = 0;
    ncons = 0;

    for (int i=0;i<dim[0];i++){ 
      for (int j=0;j<dim[1];j++){ 
        for (int k=0;k<dim[2];k++){ 
          for (int m=0;m<dim[3];m++){ 
            token.nextToken();
             hblock[i][j][k][m] = (int)token.nval;
          }
        }
      }
    }
    setupBlock();
  }
 
  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  void setupBlock() {
    int line,d,i,j,k,m,n1,n2,n3,lastD;
    int[] od,pos[],chkPos;

    int lines[][][];
    lines= new int[3][2][2];
    od = new int[4];
    pos = new int[4][2];
    chkPos = new int[4];
    lastD =-1;
    for(d=0;d<4;d++){
      od[0] = d;
      od[1] = (d+1)%4;
      od[2] = (d+2)%4;
      od[3] = (d+3)%4;
      for (j=0;j<dim[od[1]]+1;j++){ 
        for (k=0;k<dim[od[2]]+1;k++){ 
          for (m=0;m<dim[od[3]]+1;m++){ 
            for (i=0;i<dim[od[0]];i++){ 
              line=0; 
              int on;
              
              for (n1=0;n1<3;n1++)
                for (n2=0;n2<2;n2++)
                  for (n3=0;n3<2;n3++)
                    lines[n1][n2][n3]=0;
              for (n1=0;n1<2;n1++)
                for (n2=0;n2<2;n2++)
                  for (n3=0;n3<2;n3++){
                    chkPos[od[0]]=i;
                    chkPos[od[1]]=j-n1;
                    chkPos[od[2]]=k-n2;
                    chkPos[od[3]]=m-n3;
                    on = check(chkPos[0],chkPos[1],chkPos[2],chkPos[3]); 
                    line += on;
                    lines[0][n2][n3] +=on;
                    lines[1][n1][n3] +=on;
                    lines[2][n1][n2] +=on;
                  }
              /* 
                uses the line info to decide whether to draw the intersecting
                line of 8 hypercubes 
                 */
              boolean chck=false;
              if ((line % 2)==1)chck =true;
              else if (line==2) {
/*                System.out.println("there are 2"); */
                chck=true;
                for (n1=0;n1<3;n1++)
                  for (n2=0;n2<2;n2++)
                    for (n3=0;n3<2;n3++)
                      if (lines[n1][n2][n3]==2){
                        chck =false;
/*                        System.out.println("direction "+n1+" ("+n2+","+n3+")"); */
                      }
        
              } else if (line==4) {
/*                System.out.println("there are 4"); */
                chck=true;
                int count;
                for (n1=0;n1<3;n1++){
                  count=0;
                  for (n2=0;n2<2;n2++)
                    for (n3=0;n3<2;n3++)
                      if (lines[n1][n2][n3]==2) count++;
                  if (count==2){
                    chck =false;
/*                     System.out.println("direction "+n1+" ("+n2+","+n3+")"); */
                  }
                } 
              } else if (line==6) {
/*                System.out.println("there are 6"); */
                chck=true;
                for (n1=0;n1<3;n1++)
                  for (n2=0;n2<2;n2++)
                    for (n3=0;n3<2;n3++)
                      if (lines[n1][n2][n3]==0){
                        chck =false;
/*                        System.out.println("direction "+n1+" ("+n2+","+n3+")"); */
                      }
        
              }
              if (chck){
                pos[od[0]][0]=i;
                pos[od[1]][0]=j;
                pos[od[2]][0]=k;
                pos[od[3]][0]=m;
                pos[od[0]][1]=i+1;
                pos[od[1]][1]=j;
                pos[od[2]][1]=k;
                pos[od[3]][1]=m;
                addLine(d,(d==lastD),pos[0][0],pos[1][0],pos[2][0],pos[3][0],
                    pos[0][1],pos[1][1],pos[2][1],pos[3][1]);
                lastD =d;
              }
            }
          }
        }
      }
    }
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  int check(int i,int j,int k,int m){
    if (i>-1 && i<dim[0] &&
        j>-1 && j<dim[1] &&
        k>-1 && k<dim[2] &&
        m>-1 && m<dim[3])
      return hblock[i][j][k][m];
    else return 0;
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  void addLine(int d,boolean same,int i,int j,int k,int m,
               int i2,int j2, int k2,int m2){
    boolean doit = false;
    /* .. After all lines are added sort and remove duplicates points*/
    if (same) {
      int x = npoints - 1;
      if (points[x][0] == i && points[x][1] == j &&points[x][2] == k &&
          points[x][1] == m){
        points[x][0] = i2;
        points[x][1] = j2;
        points[x][2] = k2;
        points[x][3] = m2;
      } else doit = true;
    } else doit = true;

    if (doit){
      points[npoints][0] = i;
      points[npoints][1] = j;
      points[npoints][2] = k;
      points[npoints][3] = m;
      cons[ncons][0] = npoints;
      npoints++;
      points[npoints][0] = i2;
      points[npoints][1] = j2;
      points[npoints][2] = k2;
      points[npoints][3] = m2;
      cons[ncons][1] = npoints;
      npoints++;
      cons[ncons][2] = d;
      ncons++;
    }   
  }
  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public void CalcScrPts(double x,double y,double z){
    double persp;
    int p,i;
 
    for (p=0;p<npoints;p++){
      for (i=0;i<4;i++){
        rotPts[p][i] = points[p][0]*orient.M[i][0] + 
                     points[p][1]*orient.M[i][1] +
                     points[p][2]*orient.M[i][2] +
                     points[p][3]*orient.M[i][3];
      }
    }
    for (p=0;p<npoints;p++){
      rotPts[p][2] += z;
      persp = (Zeye - rotPts[p][2])/(Scale*Zeye);
      if (persp == 0){
        System.out.println("Solid: CalcScrPts: Problems with persp = 0!");
        persp = 0.01;
      }
      scrPts[p][0] = (int)(rotPts[p][0]/persp+x);
      scrPts[p][1] = (int)(-rotPts[p][1]/persp+y);
    }
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public void Draw(Graphics offscreen,int x0,int y0,double z){
    CalcScrPts((double)x0,(double)y0,z);
     
    for (int i=0;i<ncons;i++){
      offscreen.setColor(colours[cons[i][2]]); 
      offscreen.drawLine(scrPts[cons[i][0]][0],scrPts[cons[i][0]][1],
          scrPts[cons[i][1]][0],scrPts[cons[i][1]][1]);
    }
  } 

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public String toString() {
    String              str;
 
    str ="Zeye "+Zeye+"\npoints "+npoints+"\n ";
    for (int i=0;i<npoints;i++){ 
      str = str.concat("   "+i+
        " ("+points[i][0]+" "+points[i][1]+" "+points[i][2]+
        " "+points[i][3]+")\n");
    }

    for (int i=0;i<dim[0];i++){ 
        for (int k=0;k<dim[2];k++){ 
      for (int j=0;j<dim[1];j++){ 
          for (int m=0;m<dim[3];m++) 
             str = str.concat(hblock[i][j][k][m]+"  "); 
          str = str.concat("     "); 
        }
        str = str.concat("\n"); 
      }
      str = str.concat("\n"); 
    }
    return str;
  }
}