// Datei:     Function_Wuerfelnetz.java
// Compiler:  JDK 1.1.5
// Autor:     Timo Ehmke
// Beginn:    17.06.99
// Stand:     17.06.99

import java.lang.Math;


// ----------------------------------------------------------------- Function_Wuerfelnetz 
public class Functional_Wuerfelnetz extends Functional {
  
  PointElement P1, P2, P3, P4, P5, P6;

  public void init(int numElem, String[] eList, Slate sl, Measure parent) {
      slate = sl;
      numElement = numElem;
      elementList = eList;
      
      P1 = (PointElement) slate.lookupElement(elementList[1]);
      P2 = (PointElement) slate.lookupElement(elementList[2]);
      P3 = (PointElement) slate.lookupElement(elementList[3]);
      P4 = (PointElement) slate.lookupElement(elementList[4]);
      P5 = (PointElement) slate.lookupElement(elementList[5]);
      P6 = (PointElement) slate.lookupElement(elementList[6]);
      parent.addParent(P1,P2,P3);
      parent.addParent(P4,P5,P6);
  }
  
   public double getValue() {    
      //System.out.println("text" + checkWuerfelnetz());       
      return (double) checkWuerfelnetz();
   }

   // ------------------------------------------------------------------ checkWuerfelnetz
   // Bedeutung der Rückgabewerte:
   //  1 := gültiges Würfelnetz
   // -1 := Die sechs Punkte liegen nicht auf einem (ganzzahligen) Quadratraster
   // -2 := Punkte liegen in einem 2x5 Rechteck, bilden aber kein gültiges Würfelnetz
   // -3 := Punkte liegen in einem 3x4 Rechteck, bilden aber kein gültiges Würfelnetz
   // -4 := Punkte liegen in einem Rechteck, bilden aber kein gültiges Würfelnetz
   private int checkWuerfelnetz() {

       double step = 2.0;
       double[][] P = new double[6][2];
       
/*
       P[0][0] = P1.X_WindowToWorld(P1.x);
       P[0][1] = P1.Y_WindowToWorld(P1.y);
       P[1][0] = P1.X_WindowToWorld(P2.x);
       P[1][1] = P1.Y_WindowToWorld(P2.y);
       P[2][0] = P1.X_WindowToWorld(P3.x);
       P[2][1] = P1.Y_WindowToWorld(P3.y);
       P[3][0] = P1.X_WindowToWorld(P4.x);
       P[3][1] = P1.Y_WindowToWorld(P4.y);
       P[4][0] = P1.X_WindowToWorld(P5.x);
       P[4][1] = P1.Y_WindowToWorld(P5.y);
       P[5][0] = P1.X_WindowToWorld(P6.x);
       P[5][1] = P1.Y_WindowToWorld(P6.y);
*/   
       P[0][0] = Math.round(P1.X_WindowToWorld(P1.x));
       P[0][1] = Math.round(P1.Y_WindowToWorld(P1.y));
       P[1][0] = Math.round(P1.X_WindowToWorld(P2.x));
       P[1][1] = Math.round(P1.Y_WindowToWorld(P2.y));
       P[2][0] = Math.round(P1.X_WindowToWorld(P3.x));
       P[2][1] = Math.round(P1.Y_WindowToWorld(P3.y));
       P[3][0] = Math.round(P1.X_WindowToWorld(P4.x));
       P[3][1] = Math.round(P1.Y_WindowToWorld(P4.y));
       P[4][0] = Math.round(P1.X_WindowToWorld(P5.x));
       P[4][1] = Math.round(P1.Y_WindowToWorld(P5.y));
       P[5][0] = Math.round(P1.X_WindowToWorld(P6.x));
       P[5][1] = Math.round(P1.Y_WindowToWorld(P6.y));
   
       // Kontrolle:
       for (int i=0;i<6;i++) {
           for (int j=0;j<6;j++) {
               //System.out.println(Math.abs(P[i][0]-P[j][0])%step);
               if ((Math.abs(P[i][0]-P[j][0])%step!=0)||(Math.abs(P[i][1]-P[j][1])%step!=0)) {
                   return -1;
               } // if
           } // for
       } // for

       double xMin = Double.MAX_VALUE;
       double yMin = Double.MAX_VALUE;
       double xMax = -1000;
       double yMax = -1000;

       // Bestimme kleinste und größte x- und y-Koordinate
       for (int i=0;i<6;i++) {
           if (P[i][0] < xMin) {
               xMin = P[i][0];
           } // if
           if (P[i][1] < yMin) {
               yMin = P[i][1];
           } // if
           if (P[i][0] > xMax) {
               xMax = P[i][0];
           } // if
           if (P[i][1] > yMax) {
               yMax = P[i][1];
           } // if
       } // for
/*
       System.out.println("xMin = " + xMin);
       System.out.println("xMax = " + xMax);
       System.out.println("yMin = " + yMin);
       System.out.println("yMax = " + yMax);
       System.out.println("step = " + step);
*/

       int dx = (int) Math.round((xMax-xMin)/step);
       int dy = (int) Math.round((yMax-yMin)/step);
       //System.out.println("dx = " + dx);
       //System.out.println("dy = " + dy);

       int c = 0;
       
       if (dx>=dy) {
           if (dx==3 && dy==2) {
               c = 1;
           } // if
           if (dx==4 && dy==1) {
               c = 2;
           } // if
       } // if
       
       
       double[][] matrix = new double[dx+1][dy+1];
       for (int i=0;i<6;i++) {
           //System.out.print(" i=" + i );
           int mx = (int) Math.round(Math.abs(P[i][0]-xMin)/step);
           int my = (int) Math.round(Math.abs(P[i][1]-yMax)/step);
           //System.out.print(" i=" + i + " matrix[ " + mx + " ][ " + my + " ] = 1" );
           matrix[ mx ][ my ] = 1;
       } // for
/*       
       for (int j=0;j<=dy;j++) {
           for (int i=0;i<=dx;i++) {
               //System.out.print("  [" + i + "," + j + "] = " + matrix[i][j] );
               System.out.print(" " + matrix[i][j] );
               //System.out.print(" i=" + i + " j=" + j );
           } // for
           System.out.println();
       } // for
       System.out.println();
*/
       if (dy>dx) {
           
           matrix = rotateMatrix(matrix,dx,dy);
           int d = dx;
           dx = dy;
           dy = d;
       } // if
       
/*
       for (int j=0;j<=dy;j++) {
           for (int i=0;i<=dx;i++) {
               //System.out.print("  [" + i + "," + j + "] = " + matrix[i][j] );
               System.out.print(" " + matrix[i][j] );
               //System.out.print(" i=" + i + " j=" + j );
           } // for
           System.out.println();
       } // for
       System.out.println();
*/
       if (dx==4 && dy==1) {          
           if (checkMatrix2(matrix)) {
              return 1;
           } // if 
           else {
              return -2;
           } // else

       } // if
      
       if (dx==3 && dy==2) {
          
           if (checkMatrix(matrix)) {
              return 1;
           } // if 
           
           matrix = mirrorHorizontal(matrix);

           if (checkMatrix(matrix)) {
              return 1;
           } // if 

           matrix = mirrorHorizontal(matrix);
           matrix = mirrorVertical(matrix);

           if (checkMatrix(matrix)) {
              return 1;
           } // if 
           
           matrix = mirrorHorizontal(matrix);

           if (checkMatrix(matrix)) {
              return 1;
           } // if 
           return -3;
      } // if
       
           
       return -4;
   }
   
   // ------------------------------------------------------------------ checkMatrix
   private static boolean checkMatrix( double[][] m) {
   

       // 1. Würfelnetz
       // 1 0 0 0
       // 1 1 1 1
       // 1 0 0 0
       if ( m[0][0]==1 && m[1][0]==0 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==1 && m[1][2]==0 && m[2][2]==0 && m[3][2]==0 ) {
           return true;
       } // if 

       // 2. Würfelnetz
       // 1 0 0 0
       // 1 1 1 1
       // 0 1 0 0
       if ( m[0][0]==1 && m[1][0]==0 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==1 && m[2][2]==0 && m[3][2]==0 ) {
           return true;
       } // if 

       // 3. Würfelnetz
       // 1 0 0 0
       // 1 1 1 1
       // 0 0 1 0
       if ( m[0][0]==1 && m[1][0]==0 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==0 && m[2][2]==1 && m[3][2]==0 ) {
           return true;
       } // if 

       // 4. Würfelnetz
       // 1 0 0 0
       // 1 1 1 1
       // 0 0 0 1
       if ( m[0][0]==1 && m[1][0]==0 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==0 && m[2][2]==0 && m[3][2]==1 ) {
           return true;
       } // if 

       // 5. Würfelnetz
       // 0 1 0 0
       // 1 1 1 1
       // 0 1 0 0
       if ( m[0][0]==0 && m[1][0]==1 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==1 && m[2][2]==0 && m[3][2]==0 ) {
           return true;
       } // if 

       // 6. Würfelnetz
       // 0 1 0 0
       // 1 1 1 1
       // 0 0 1 0
       if ( m[0][0]==0 && m[1][0]==1 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==0 && m[2][2]==1 && m[3][2]==0 ) {
           return true;
       } // if 

       // 7. Würfelnetz
       // 1 1 0 0
       // 0 1 1 1
       // 0 1 0 0
       if ( m[0][0]==1 && m[1][0]==1 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==0 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==1 && m[2][2]==0 && m[3][2]==0 ) {
           return true;
       } // if 

       // 8. Würfelnetz
       // 1 1 0 0
       // 0 1 1 1
       // 0 0 1 0
       if ( m[0][0]==1 && m[1][0]==1 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==0 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==0 && m[2][2]==1 && m[3][2]==0 ) {
           return true;
       } // if 

       // 9. Würfelnetz
       // 1 1 0 0
       // 0 1 1 1
       // 0 0 0 1
       if ( m[0][0]==1 && m[1][0]==1 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==0 && m[1][1]==1 && m[2][1]==1 && m[3][1]==1 && 
            m[0][2]==0 && m[1][2]==0 && m[2][2]==0 && m[3][2]==1 ) {
           return true;
       } // if 

       // 10. Würfelnetz
       // 1 1 0 0
       // 0 1 1 0
       // 0 0 1 1
       if ( m[0][0]==1 && m[1][0]==1 && m[2][0]==0 && m[3][0]==0 && 
            m[0][1]==0 && m[1][1]==1 && m[2][1]==1 && m[3][1]==0 && 
            m[0][2]==0 && m[1][2]==0 && m[2][2]==1 && m[3][2]==1 ) {
           return true;
       } // if 
       return false;
   }

   // ------------------------------------------------------------------ checkMatrix2
   private static boolean checkMatrix2( double[][] m) {
   

       // 1. Würfelnetz
       // 1 1 1 0 0  
       // 0 0 1 1 1 
       if ( m[0][0]==1 && m[1][0]==1 && m[2][0]==1 && m[3][0]==0 && m[4][0]==0 && 
            m[0][1]==0 && m[1][1]==0 && m[2][1]==1 && m[3][1]==1 && m[4][1]==1) {
           return true;
       } // if 

       // 2. Würfelnetz
       // 0 0 1 1 1 
       // 1 1 1 0 0  
       if ( m[0][0]==0 && m[1][0]==0 && m[2][0]==1 && m[3][0]==1 && m[4][0]==1 && 
            m[0][1]==1 && m[1][1]==1 && m[2][1]==1 && m[3][1]==0 && m[4][1]==0) {
           return true;
       } // if 
    return false;
    }
    
   // ------------------------------------------------------------- mirrorHorizontal
   // Voraussetzung m[4][3]!
  private static double[][] mirrorHorizontal( double[][] m1) {
      double[][] m2 = new double[4][3];
      m2[0][0] = m1[0][2];
      m2[0][1] = m1[0][1];
      m2[0][2] = m1[0][0];
    
      m2[1][0] = m1[1][2];
      m2[1][1] = m1[1][1];
      m2[1][2] = m1[1][0];

      m2[2][0] = m1[2][2];
      m2[2][1] = m1[2][1];
      m2[2][2] = m1[2][0];
      
      m2[3][0] = m1[3][2];
      m2[3][1] = m1[3][1];
      m2[3][2] = m1[3][0];
      
      return m2;
  }      
    
   // ------------------------------------------------------------- mirrorVertical
   // Voraussetzung m[4][3]!
  private static double[][] mirrorVertical( double[][] m1) {
      double[][] m2 = new double[4][3];
      m2[0][0] = m1[3][0];
      m2[0][1] = m1[3][1];
      m2[0][2] = m1[3][2];
    
      m2[1][0] = m1[2][0];
      m2[1][1] = m1[2][1];
      m2[1][2] = m1[2][2];

      m2[2][0] = m1[1][0];
      m2[2][1] = m1[1][1];
      m2[2][2] = m1[1][2];
      
      m2[3][0] = m1[0][0];
      m2[3][1] = m1[0][1];
      m2[3][2] = m1[0][2];
      
      return m2;
  }      
    
  // ------------------------------------------------------------- rotateMatrix
  private static double[][] rotateMatrix( double[][] m1, int c, int r ) {
      
      double[][] m2 = new double[r+1][c+1];
      
      for (int i=0;i<=r;i++) {
          for (int j=0;j<=c;j++) {
              m2[i][j] = m1[j][i];
          } // for
      } // for
      return m2;
  }      
    
    
    
}