import java.awt.*;
import java.lang.*;


public class Matrix3D {
  
  private static int size = 4;
  private static int vecSize = 3;
  private float element[];
  private float origElement[];
  private boolean isLtMult;
  private StringBuffer trforms;
  private StringBuffer origTrforms;
  
  ///////  CONSTRUCTORS /////////////////////////////  
  
  // zero argument constructor for future expansion 
  public Matrix3D() {
    element = new float[size*size];
    origElement = new float[size*size];
    trforms = new StringBuffer();
    origTrforms = new StringBuffer();
    loadIdentity();
    setToIdentity(origElement);
    isLtMult = true; //this = newmatrix*this
  }

    //NOT TESTED YET
  // constructor using Matrix3d
  public Matrix3D( Matrix3D copy) {
    this.isLtMult = copy.getIsLtMult();
    element = new float[size*size];
    origElement = new float[size*size];
    trforms = new StringBuffer( copy.getTrforms() );
    origTrforms = new StringBuffer( copy.getOrigTrforms() );
    //COPYING ELEMENT
    System.arraycopy( copy.getMatArray(), 0, this.element, 0, copy.getMatArray().length );
    System.arraycopy( copy.getMatArray(), 0, this.origElement, 0, copy.getMatArray().length );
 }	


  public Matrix3D( Raster r) {
    int width = r.getWidth();   
    int height = r.getHeight();
    element = new float[size*size];
    origElement = new float[size*size];
    trforms = new StringBuffer();
    origTrforms = new StringBuffer();
    loadIdentity();
    isLtMult = false;
    //CANONICAL TO RASTER TRANSFROMATION IS USED TO INITIALIZE
    //RIGHT MULTIPLICATION REQD LATER ON
    //RIGHT = TOP = NEAR = 1; LEFT=BOTTOM=FAR=-1
    float zmax = width;
    element[index(0,0)] =  width/2.0f ;
    element[index(0,3)] =  width/2.0f ;
    element[index(1,1)] =  height/(-2.0f) ;
    element[index(1,3)] =  height/2.0f ;
    element[index(2,2)] =  -zmax/2.0f ;
    element[index(2,3)] =  zmax/2.0f ;
    System.arraycopy( this.element, 0, this.origElement, 0, this.element.length );
//     System.out.println("PRINTING CANONICAL-DISPLAY TRANS ");
//     printMatrix3D( element );
  }	
  
  /////////  TRANSFORM METHODS  ////////////////////////////
  
  public final void loadIdentity(){
    for( int i=0; i<size; i++){
      for(int j=0; j<size; j++){
	if(i==j)
	  element[index(i,j)] = 1.0f;
	else
	  element[index(i,j)] = 0.0f;
      }
    }
    trforms.insert(0, "Id" );
    trforms.setLength(2);
    origTrforms.insert(0, "Id" );
    origTrforms.setLength(2);
  }


  // constructor using Matrix3d
  public void setTo( Matrix3D copy) {

      if( this.isLtMult == copy.getIsLtMult() ) {
	  trforms.insert(0, copy.getTrforms() );
	  trforms.setLength( copy.getTrforms().length() );
	  origTrforms.insert(0, copy.getTrforms() );
	  origTrforms.setLength(copy.getOrigTrforms().length() );
	  //COPYING ELEMENT
	  System.arraycopy( copy.getMatArray(), 0, this.element, 0, copy.getMatArray().length );
	  System.arraycopy( copy.getMatArray(), 0, this.origElement, 0, copy.getMatArray().length );
      } else {
	  System.err.println("ERROR:(Matrix3D.setTo(Matrix3D) isLtMult are different in the two matrices ");
      }
 }	

  public final void toOriginalMat(){
//     for( int i=0; i<size; i++){
//       for(int j=0; j<size; j++){
// 	  element[index(i,j)] = origElement[index(i,j)] ;
//       }
//     }

    System.arraycopy( this.origElement, 0, this.element, 0, this.origElement.length );
    trforms.insert(0, origTrforms.toString() );
    trforms.setLength(origTrforms.length() );
  }

 
  public void transform( Point3D in[], Point3D out[], int start, int length){
    float sum;
    for( int pt=start; pt < (start+length); pt++){
      for( int i=0; i< this.size; i++){
	sum=0.0f;
	for( int j=0; j< this.size; j++){
	  sum += this.element[index(i,j)] * in[pt].getCoord(j);
	}
	out[pt].setCoord(i,sum);
      }
    } //FOR PT
  } //TRANSFORM
 
  public final void compose( Matrix3D src ){
    float sum;
    trforms.append( src.getTrforms() );
    float temp[] = new float[size*size];
    if( isLtMult){
      for( int i=0; i< this.size; i++){
	for( int j=0; j< this.size; j++){
	  sum=0.0f;
	  for( int k=0; k< this.size; k++){
	    sum += this.element[index(k,j)] * src.getElem(i,k);
	  }
	  temp[index(i,j)]  = sum;
	}
      }
    } //IF ISLTMULT
    else {
      for( int i=0; i< this.size; i++){
	for( int j=0; j< this.size; j++){
	  sum=0.0f;
	  for( int k=0; k< this.size; k++){
	    sum += this.element[index(i,k)] * src.getElem(k,j);
	  }
	  temp[index(i,j)]  = sum;
	}
      }
    }
    for( int i=0; i< this.size; i++){
	for( int j=0; j< this.size; j++){
	   setElem(i,j, temp[index(i,j)]); 
	}
    }
  } //COMPPOSE



  public final void translate( float tx, float ty, float tz ){
    float transMat[] = new float[size*size];
    setToIdentity(transMat);
    transMat[ index(0,size-1) ] = tx; 
    transMat[ index(1,size-1) ] = ty;
    transMat[ index(2,size-1) ] = tz;
    matmul(transMat);
    trforms.append("Tr");
  }

  public final void scale( float sx, float sy, float sz ){
    float scaleMat[] = new float[size*size];
    setToIdentity( scaleMat );
    scaleMat[ index(0,0) ] = sx; 
    scaleMat[ index(1,1) ] = sy; 
    scaleMat[ index(2,2) ] = sz; 
    matmul( scaleMat);
    trforms.append("Sc");
  }

  public final void shear( float kxy, float kyz , float kzx,  float kyx, float kzy , float kxz ){
    float shearMat[] = new float[size*size];
    setToIdentity( shearMat );
    shearMat[ index(0,1) ] = kxy; 
    shearMat[ index(1,2) ] = kyz; 
    shearMat[ index(2,0) ] = kzx; 
    shearMat[ index(1,0) ] = kyx; 
    shearMat[ index(2,1) ] = kzy; 
    shearMat[ index(0,2) ] = kxz; 
    matmul( shearMat);
    trforms.append("Sh");
  }


  public void rotate( float ax, float ay, float az, float ang){
    Vector3D axis = new Vector3D(ax, ay, az);
    axis.normalize();
    float symOfAxis[] = new float[ vecSize*vecSize ];
    axis.symmetrify( symOfAxis);
    float skewOfAxis[] = new float[vecSize*vecSize ];
    axis.skewify( skewOfAxis);
    float idenOfAxis[] = new float[ vecSize*vecSize  ];
    axis.setToIdentity( idenOfAxis );
    axis.scalarMul( symOfAxis, (float) (1-Math.cos(ang)) );
    axis.scalarMul( skewOfAxis, (float) Math.sin(ang) );    
    axis.scalarMul( idenOfAxis, (float)Math.cos(ang) );
    axis.matAdd( symOfAxis, skewOfAxis);
    axis.matAdd( symOfAxis, idenOfAxis);
    float rotMat[] = new float[size*size];
    homogenize(symOfAxis, rotMat);
    matmul( rotMat);
    trforms.append("Ro");
//     System.out.println("PRINTING ROTATION ");
//     printMatrix3D(rotMat);
  } //ROTATE


  public void lookAt(float eyex, float eyey, float eyez, float atx,  float aty,                     float atz, float upx,  float upy,  float upz) {

      //  System.out.println( atz + " " + eyez);
    Vector3D l = new Vector3D( atx-eyex, aty-eyey, atz-eyez );
    //    System.out.println( atz + " " + eyez);
    //System.out.println("PRINTING L");
    //printVector3D( l );
    l.normalize();
    //System.out.println("PRINTING L");
    //printVector3D( l );
    //System.out.println(l.getMag());
    Vector3D up = new Vector3D( upx, upy, upz );
    up.normalize();
    //System.out.println(up.getMag());
    Vector3D r = new Vector3D();  
    l.crossProd( up, r);
    r.normalize();
    //System.out.println(r.getMag());
    Vector3D u = new Vector3D();  
    r.crossProd( l, u);
    u.normalize();
    //System.out.println(u.getMag());
    
    float viewMat[] = new float[size*size];
    loadNull( viewMat );
    viewMat[ index(size-1,size-1) ] = 1.0f;
    for( int j=0; j<(size-1); j++ ){
      viewMat[ index(0,j) ] = r.getV(j);
    }
    for( int j=0; j<(size-1); j++ ){
      viewMat[ index(1,j) ] = u.getV(j);
    }
    for( int j=0; j<(size-1); j++ ){
      viewMat[ index(2,j) ] =  -l.getV(j);
    }
    Vector3D eye = new Vector3D( eyex, eyey, eyez );
    viewMat[ index(0,size-1) ] = -r.dotProd(eye);
    viewMat[ index(1,size-1) ] = -u.dotProd(eye);
    viewMat[ index(2,size-1) ] =  l.dotProd(eye);
    matmul( viewMat );
    trforms.append("Ey");
    //System.out.println("PRINTING UP");
    //printVector3D( up );
    //System.out.println("PRINTING R");
    //printVector3D( r );
    //System.out.println("PRINTING U");
    //printVector3D( u );
    //System.out.println("PRINTING L");
    //printVector3D( l );
//     System.out.println("PRINTING EYEVIEW TRANS ");
//     printMatrix3D( viewMat);

  }

  public void perspective(float l, float r, float b, float t, float n, float f) {
  float pers[] = new float[size*size];
  loadNull( pers );
  pers[ index(0,0) ] = 2.0f *n / (r-l);
  pers[ index(0,2) ] = -(r+l)/ (r-l);
  pers[ index(1,1) ] = -2.0f *n / (b-t);
  pers[ index(1,2) ] = (b+t)/ (b-t);
  pers[ index(2,2) ] = -(f+n) / (f-n);
  pers[ index(2,3) ] = 2.0f*f*n / (f-n);
  pers[ index(3,2) ] = 1.0f;
  matmul(pers);
  trforms.append("Ps");
//   System.out.println("PRINTING PERSPEC PROJ ");
//   printMatrix3D( pers);
}

  public void orthographic(float l, float r, float b, float t, float n, float f) {
  float ortho[] = new float[size*size];
  loadNull( ortho );
  ortho[ index(0,0) ] = 2.0f/ (r-l);
  ortho[ index(0,3) ] = -(r+l)/ (r-l);
  ortho[ index(1,1) ] = -2.0f / (b-t);
  ortho[ index(1,3) ] = (b+t)/ (b-t);
  ortho[ index(2,2) ] = -2.0f/ (f-n);
  ortho[ index(2,3) ] = (f+n) / (f-n);
  ortho[ index(3,3) ] = 1.0f;
  matmul(ortho);
  trforms.append("Or");
//   System.out.println("PRINTING ORTHOGRAPHIC PROJ ");
//   printMatrix3D( ortho);
}


  ///////////// SUPPORT METHODS ///////////////////////////

  //	to obtain index  		
  private int index( int i, int j ) {
    return( i*size+j );
  }

  //	to obtain index  		
  private int vecIndex( int i, int j ) {
    return( i*vecSize+j );
  }

  //	to obtain matrix 		
  private float[] getMatArray() {
    return( element);
  }

  //	to obtain isLtMult 		
  private boolean getIsLtMult() {
    return( isLtMult);
  }

  public void setElem(int i, int j, float value) {
    element[index(i,j)] = value;
    return;
  }

 
 public float getElem(int i, int j) {
   return element[index(i,j)];
  }

 public String getTrforms() {
   return trforms.toString();
  }

 public String getOrigTrforms() {
   return origTrforms.toString();
  }


  public final void matmul( float[] ary) {
    float sum;
    float temp[] = new float[size*size];
    if( isLtMult){
      for( int i=0; i< this.size; i++){
	for( int j=0; j< this.size; j++){
	  sum=0.0f;
	  for( int k=0; k< this.size; k++){
	    sum += this.element[index(k,j)] * ary[index(i,k)];
	  }
	  temp[index(i,j)]  = sum;
	}
      }
    } //IF ISLTMULT
    else {
      for( int i=0; i< this.size; i++){
	for( int j=0; j< this.size; j++){
	  sum=0.0f;
	  for( int k=0; k< this.size; k++){
	    sum += this.element[index(i,k)] * ary[index(k,j)];
	  }
	  temp[index(i,j)]  = sum;
	}
      }
    }
    for( int i=0; i< this.size; i++){
	for( int j=0; j< this.size; j++){
	   setElem(i,j, temp[index(i,j)]); 
	}
    }
  } //MATMUL


  public final void setToIdentity(float[] ary) {
    for( int i=0; i<size; i++){
      for(int j=0; j<size; j++){
	if(i==j)
	  ary[index(i,j)] = 1.0f;
	else
	  ary[index(i,j)] = 0.0f;
      }
    }
  }

  public final void loadNull(float[] ary) {
    for( int i=0; i<size; i++){
      for(int j=0; j<size; j++){
	  ary[index(i,j)] = 0.0f;
      }
    }
  }

  public final void matAdd( float[] mat1, float[] mat2) {
    for( int i=0; i< this.size; i++){
      for( int j=0; j< this.size; j++){
	mat1[ index(i,j) ] += mat2[ index(i,j) ];
      }
    }   
  }

  public final void scalarMul( float[] mat, float k) {
    for( int i=0; i< this.size; i++){
      for( int j=0; j< this.size; j++){
	mat[ index(i,j) ] *= k;
      }
    }   
  }

  public final void homogenize( float[] mat, float[] res) {
    for( int i=0; i< vecSize; i++){
      for( int j=0; j< vecSize; j++){
	  res[ index(i,j) ]=	mat[ vecIndex(i,j) ];
      }
    } 
    for(int j=0; j<(size-1); j++)  res[ index(3,j)]=0.0f; 
    for(int i=0; i<(size-1); i++)  res[ index(i,3)]=0.0f;
    res[ index(3,3)] = 1.0f;	 
  }


  public final void printMatrix3D(float[] ary) {
    for( int i=0; i< size; i++ ) {
      for( int j=0; j< size; j++ ) {
	System.out.println( " ele[ "+ i +", " + j +"]=" + ary[index(i,j)] );
      }
    }
  }

  public final void printCompMat( ) {
    for( int i=0; i< size; i++ ) {
      for( int j=0; j< size; j++ ) {
	System.out.println( " ele[ "+ i +", " + j +"]="+element[index(i,j)] );
      }
    }
  }

  public final void printVector3D(Vector3D vec) {
    for( int i=0; i< size-1; i++ ) {
	System.out.println( " vec[ "+ i+"]=" + vec.getV(i) );
    }
  }


} // CLASS MATRIX3D

*******************************************************************************

import java.awt.*;
import java.awt.image.*;


public class Point3D{
  
  private float coord[];
  protected int size = 4;
  private int color;

  ///////////////////////// CONSTRUCTORS ///////////////////
  
  /**
   *  This constructor, which takes no arguments,
   *  allows for future extension.
   */
  public Point3D() {
    coord = new float[size];
    loadOrigin();
  }
  
  /**
    initialize components
   */
  public Point3D( float x, float y, float z, float w) {
    coord = new float[size];
    coord[0]=x; coord[1]=y; coord[2]=z; coord[3]=w;
  }
  
  /**
    initialize components
   */
  public Point3D( float x, float y, float z, float w, int clr) {
    coord = new float[size];
    coord[0]=x; coord[1]=y; coord[2]=z; coord[3]=w;
    color = clr;
  }
  

  /**
    initialize components
   */
  public Point3D( float x, float y, float z) {
    coord = new float[size];
    coord[0]=x; coord[1]=y; coord[2]=z; coord[3]=1.0f;
  }
   
   /**
    initialize components
   */
  public Point3D( float x, float y, float z, int clr) {
    coord = new float[size];
    coord[0]=x; coord[1]=y; coord[2]=z; coord[3]=1.0f;
    color = clr;
  }
    
  ////////////////////////// METHODS //////////////////// 

  public final void loadOrigin( ) {
      for( int i=0; i< (size-1); i++){
	  coord[i] = 0.0f;
      }
      coord[size-1] = 1.0f;
      return;
  }
    
    public final float getCoord( int i) {
	return coord[i];
    }

    public final void setCoord( int i, float val) {
	coord[i] = val;
    }

    public final int getColor() {
	return color;
    }
 
} //POINT3D

***********************************************************


import java.awt.*;
import java.awt.image.*;


public class Vector3D{
  
  private float v[];
  protected int vecSize = 3;
    //protected int size = 4;
  protected float vMag;
  

  ///////////////////////// CONSTRUCTORS ///////////////////
  
  /**
   *  This constructor, which takes no arguments,
   *  allows for future extension.
   */
  public Vector3D() {
    v = new float[vecSize];
    loadNull();
  }
  
  /**
    initialize components
   */
  public Vector3D( float vx, float vy, float vz) {
    v = new float[vecSize];
    v[0]=vx; v[1]=vy; v[2]=vz;
    vMag = (float) Math.sqrt( v[0]*v[0] +  v[1]*v[1] +  v[2]*v[2] );
  }
  
 
  
  ////////////////////////// METHODS //////////////////// 

  public final void loadNull( ) {
    for( int i=0; i<vecSize; i++){
	  v[i] = 0.0f;
    }
    vMag = 0.0f;
    return;
  }

  public final void loadNull(float[] ary) {
    for( int i=0; i<vecSize; i++){
      for(int j=0; j<vecSize; j++){
	  ary[index(i,j)] = 0.0f;
      }
      return;
    }
  }
  
  /**
   *  Returns the components
   */
  public final float getV( int i ) {
    return v[i];
  }
  public final float getVx( ) {
    return v[0];
  }
    public final float getVy( ) {
    return v[1];
  }
    public final float getVz( ) {
    return v[2];
  }
  
    public final float getMag( ) {
    return vMag;
  }
  
  /**
   *  Sets the components
   */
  public final void setV( int i, float val ) {
    v[i] = val;
  }

  public void normalize(){
    if( vMag!=0) {
      for( int i=0; i<vecSize; i++) v[i] = v[i]/ vMag;
    }
    return;
  }

  public void symmetrify( float[] symMat ) {
    loadNull( symMat );
    //symMat[ index(size-1, size-1) ] = 1.0f;
    for( int i=0; i<vecSize; i++ ){
      for( int j=0; j<vecSize; j++ ){
	symMat[ index(i,j) ] = v[i]*v[j];
      } 
    } 
    return;
  }

   public void skewify( float[] skewMat ) {
    loadNull( skewMat );
    //skewMat[ index(size-1, size-1) ] = 1.0f;
    skewMat[ index(0,1) ] = -v[2];
    skewMat[ index(1,0) ] = v[2];
    skewMat[ index(0,2) ] = v[1];
    skewMat[ index(2,0) ] = -v[1];
    skewMat[ index(1,2) ] = -v[0];
    skewMat[ index(2,1) ] = v[0];
    return;
  }
 
   public void crossProd( Vector3D vec, Vector3D res ) {
     res.setV( 0,  this.v[1]*vec.getV(2) - this.v[2]*vec.getV(1) );
     res.setV( 1,  this.v[2]*vec.getV(0) - this.v[0]*vec.getV(2) );
     res.setV( 2,  this.v[0]*vec.getV(1) - this.v[1]*vec.getV(0) );
     return;
   }

   public float dotProd( Vector3D vec ) {
     return( this.v[0]*vec.getV(0) + this.v[1]*vec.getV(1) + this.v[2]*vec.getV(2) );
   }

   private int index(int i, int j) {
     return( i*vecSize+j );
   }

  public final void scalarMul( float[] mat, float k) {
    for( int i=0; i< vecSize; i++){
      for( int j=0; j< vecSize; j++){
	mat[ index(i,j) ] *= k;
      }
    }   
  }

 public final void setToIdentity(float[] ary) {
    for( int i=0; i<vecSize; i++){
      for(int j=0; j<vecSize; j++){
	if(i==j)
	  ary[index(i,j)] = 1.0f;
	else
	  ary[index(i,j)] = 0.0f;
      }
    }
  }

 public final void matAdd( float[] mat1, float[] mat2) {
    for( int i=0; i< vecSize; i++){
      for( int j=0; j< vecSize; j++){
	mat1[ index(i,j) ] += mat2[ index(i,j) ];
      }
    }   
  }


} //VECTOR3D

******************************************************************************


import java.applet.*;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.awt.event.*;
import java.lang.*;

public class CowTestMatrix extends Applet implements MouseListener, MouseMotionListener {
    final static int CHUNKSIZE = 100;
    Raster raster;
    Image screen;
    Point3D vertList[];
    Point3D worldList[];
    Point3D tranList[];
    Point3D axesList[];
    Point3D tranAxesList[];

    int vertices;
    int axesVtcs;
    Matrix3D view; 
    Matrix3D axesView;
    Matrix3D model;

    float eyex, eyey, eyez;
    float lookatx, lookaty, lookatz;
    float upx, upy, upz;
    float fov;

    public void init( )
    {
        raster = new Raster(getSize().width, getSize().height);
        raster.fill(getBackground());
        screen = raster.toImage(this);

        eyex = 0;        eyey = 0;        eyez = -10;
        lookatx = 0;     lookaty = 0;     lookatz = 0;
        upx = 0;         upy = 1;         upz = 0;
        fov = 30;

        vertList = new Point3D[CHUNKSIZE];
        vertices = 0;
        axesList = new Point3D[CHUNKSIZE];
        axesVtcs = 0;
	
	this.addMouseListener(this);
	this.addMouseMotionListener(this);

        String filename = getParameter("datafile");
        showStatus("Reading "+filename);
        InputStream is = null;
        try {
            is = new URL(getDocumentBase(), filename).openStream();
            ReadInput(is);
            is.close();
        } catch (IOException e) {
            showStatus("Error reading "+filename);
        }
// 	System.out.println("PRINTING ORIGINAL VERTICES" );
//         for (int i = 0; i < vertices; i++) {
// 	    System.out.println("Vertex no.= " + i );
// 	    System.out.println(" x= " + vertList[i].getCoord(0)+ " y= " + vertList[i].getCoord(1)+  " z= " + vertList[i].getCoord(2)+  " w= " + vertList[i].getCoord(3)+  " color= " + vertList[i].getColor() );   
//         }
	
        worldList = new Point3D[vertList.length];
        tranList = new Point3D[vertList.length];
        tranAxesList = new Point3D[axesList.length];
	
        for (int i = 0; i < vertices; i++) {
            worldList[i] = new Point3D();
            tranList[i] = new Point3D();
        }

	for (int i = 0; i < axesVtcs; i++) {
            tranAxesList[i] = new Point3D();
        }

        view = new Matrix3D(raster);
        axesView = new Matrix3D(raster);

	//VIEW.PERSPEC IS INITIALIZED WITH COORDS IN VIEW SYSTEM
        float t = (float) Math.sin(Math.PI*(fov/2)/180);
        float s = (t*getSize().height)/getSize().width;
	view.perspective(-t, t, -s, s, -1, -200);
	axesView.perspective(-t, t, -s, s, -1, -200);
	
	//VIEW.ORTHOG IS INITIALIZED WITH COORDS IN VIEW SYSTEM
//         float t = 3;
//         float s = 3;
// 	view.orthographic(-t, t, -s, s, -1, -200);
// 	axesView.orthographic(-t, t, -s, s, -1, -200);

// 	System.out.println("PRINTING VIEW MATRIX SP");
//         view.printCompMat();

// 	view.lookAt(eyex, eyey, eyez, lookatx, lookaty, lookatz, upx, upy, upz);
// 	axesView.lookAt(eyex, eyey, eyez, lookatx, lookaty, lookatz, upx, upy, upz);
	setViewLine(eyex, eyey, eyez, lookatx, lookaty, lookatz, upx, upy, upz);
 
// 	System.out.println("PRINTING VIEW MATRIX SPE");
//         view.printCompMat();
        model = new Matrix3D();
	model.rotate(0,0,1, (float)(Math.PI)/4.0f);
        model.transform(vertList, worldList, 0, vertices);
// 	System.out.println("PRINTING MODELED VERTICES" );
// 	for (int i = 0; i < vertices; i++) {
// 	    System.out.println("Vertex no.= " + i );
// 	    System.out.println(" x= " + worldList[i].getCoord(0)+ " y= " + worldList[i].getCoord(1)+  " z= " + worldList[i].getCoord(2)+  " w= " + worldList[i].getCoord(3) );   
//         }
        view.transform(worldList, tranList, 0, vertices);
        axesView.transform(axesList, tranAxesList, 0, axesVtcs);
// 	System.out.println("PRINTING TRANFROMED VERTICES" );
// 	for (int i = 0; i < vertices; i++) {
// 	    System.out.println("Vertex no.= " + i );
// 	    System.out.println(" x= " + tranList[i].getCoord(0)+ " y= " + tranList[i].getCoord(1)+  " z= " + tranList[i].getCoord(2)+  " w= " + tranList[i].getCoord(3) );   
//         }
// 	System.out.println("PRINTING VIEW.TRN = " + view.getTrforms() );
// 	System.out.println("PRINTING MODEL.TRN = "+ model.getTrforms()  );
        DrawObject();
        screen = raster.toImage(this);

    }

    // define legal characters for our parser
    // The remainder of a line after a '#' is ignored
    // you might find this helpful for debugging
    private void configureParser(StreamTokenizer st) {
	st.commentChar('#');
    }



    private double getNumber(StreamTokenizer st) throws IOException
    {
        if (st.nextToken() != StreamTokenizer.TT_NUMBER) {
            System.err.println("ERROR: line "+st.lineno()+": expected number");
            throw new IOException(st.toString());
        }
        return st.nval;
    }


    // parse a packed integer in hex, octal, or decimal
    private int getColor(StreamTokenizer st) throws IOException {
	st.nextToken();
	int pix;
        if (st.sval.startsWith("0x") || st.sval.startsWith("0X")) {
	    pix = (int) Long.parseLong(st.sval.substring(2), 16);
	} else
            if (st.sval.startsWith("0") || st.sval.length() > 1) {
                pix = (int) Long.parseLong(st.sval.substring(1), 8);
            } else
                pix = Integer.parseInt(st.sval);
        return pix;
    }



    public void ReadInput(InputStream is) throws IOException
    {
	Reader r = new BufferedReader(new InputStreamReader(is));
	StreamTokenizer st = new StreamTokenizer(r);
	configureParser(st);
    scan: while (true) {
	switch (st.nextToken()) {
	default:
	    break scan;
	case StreamTokenizer.TT_WORD:
	    
	    if (st.sval.equals("c")) {
		float x = (float) getNumber(st);
		float y = (float) getNumber(st);
		float z = (float) getNumber(st);
		//int clr =  getColor(st);
		int clr = (int) getNumber(st) ;
		if (axesVtcs == axesList.length) {
		    Point3D newList[] = new Point3D[vertList.length+CHUNKSIZE];
		    System.arraycopy(axesList, 0, newList, 0, axesList.length);
		    axesList = newList;
		}
		axesList[axesVtcs++] = new Point3D(x, y, z, 1, clr);
	    } else
		
		if (st.sval.equals("v")) {
		    float x = (float) getNumber(st);
		    float y = (float) getNumber(st);
		    float z = (float) getNumber(st);
		    //int clr =  getColor(st);
		    int clr = (int) getNumber(st) ;
		    if (vertices == vertList.length) {
			Point3D newList[] = new Point3D[vertList.length+CHUNKSIZE];
			System.arraycopy(vertList, 0, newList, 0, vertList.length);
			vertList = newList;
		    }
		    vertList[vertices++] = new Point3D(x, y, z, 1, clr);
		} else
		    if (st.sval.equals("eye")) {
			eyex = (float) getNumber(st);
			eyey = (float) getNumber(st);
			eyez = (float) getNumber(st);
		    } else
			if (st.sval.equals("look")) {
			    lookatx = (float) getNumber(st);
			    lookaty = (float) getNumber(st);
			    lookatz = (float) getNumber(st);
			} else
			    if (st.sval.equals("up")) {
				upx = (float) getNumber(st);
				upy = (float) getNumber(st);
				upz = (float) getNumber(st);
			    } else
				if (st.sval.equals("fov")) {
				    fov = (float) getNumber(st);
				} else {
				    System.err.println("ERROR: line "+st.lineno()+": unexpected token :"+st.sval);
				    break scan;
				}
	    break;
	}
	//if (vertices % 100 == 0)showStatus("vertices = " + (vertices+1));
	showStatus("vertices = " + vertices);
    }
        is.close();
	if (st.ttype != StreamTokenizer.TT_EOF) {
	    throw new IOException(st.toString());
	}
    }
    
    public void paint(Graphics g)
    {
        g.drawImage(screen, 0, 0, this);
    }

    public void update(Graphics g)
    {
        paint(g);
    }

    public void setViewLine(float eyex,float  eyey, float eyez, float lookatx, float  lookaty, float lookatz, float upx, float upy, float upz) {
	view.lookAt(eyex, eyey, eyez, lookatx, lookaty, lookatz, upx, upy, upz);
	axesView.lookAt(eyex, eyey, eyez, lookatx, lookaty, lookatz, upx, upy, upz);	
    }


    float v0x, v0y, v0z;
    int state=0;
    
    public void mousePressed( MouseEvent e )
    {
            int x=e.getX();
	    int y=e.getY();
	    if (e.isMetaDown()) {
		showStatus("Resetting model matrix");
		model.loadIdentity();
	    }
	    v0x = (float) (x - (getSize().width / 2));
	    v0y = (float) ((getSize().height / 2) - y);
	    v0z = (float) getSize().width;
	    float l0 = (float) (1 / Math.sqrt(v0x*v0x + v0y*v0y + v0z*v0z));
	    v0x *= l0;
	    v0y *= l0;
	    v0z *= l0;
	    state=0;
	    showStatus("Rotation about any axis");
	    return;
    }

    public void mouseReleased( MouseEvent e ) { ; }
    public void mouseEntered( MouseEvent e ) { ; }
    public void mouseExited( MouseEvent e ) { ;}
    public void mouseClicked( MouseEvent e ) { ; }

    public void mouseDragged( MouseEvent e)
    {
        int x=e.getX();
        int y=e.getY();
        if (e.isMetaDown()) {
            showStatus("Resetting model matrix");
        } else {
            float v1x = (float) (x - (getSize().width / 2));
            float v1y = (float) ((getSize().height / 2) - y);
            float v1z = (float) getSize().width;
            float l = (float) (1 / Math.sqrt(v1x*v1x + v1y*v1y + v1z*v1z));
            v1x *= l;
            v1y *= l;
            v1z *= l;

            float ax = v0y*v1z - v0z*v1y;
            float ay = v0z*v1x - v0x*v1z;
            float az = v0x*v1y - v0y*v1x;
            l = (float) Math.sqrt(ax*ax + ay*ay + az*az);
            float theta = (float) Math.asin(l);
            if (v0x*v1x + v0y*v1y + v0z*v1z < 0)
                theta += (float) Math.PI / 2;
            model.rotate(ax, ay, az, theta);
            v0x = v1x;
            v0y = v1y;
            v0z = v1z;
            model.transform(vertList, worldList, 0, vertices);
            view.transform(worldList, tranList, 0, vertices);
            DrawObject();
        }
        screen = raster.toImage(this);
        repaint();
        return;
    }

   public void mouseMoved( MouseEvent e ) { ; }

    void DrawObject(){
        int ix, iy;
	float iz, iw;
        int w, h;
        w = raster.getWidth();
        h = raster.getHeight();
	
        raster.fill(getBackground());

        for (int i = 0; i < axesVtcs; i++) {
	    if( tranAxesList[i].getCoord(3) !=0){
		ix = (int) (tranAxesList[i].getCoord(0) / tranAxesList[i].getCoord(3));
		iy = (int) (tranAxesList[i].getCoord(1) / tranAxesList[i].getCoord(3));
		iz = tranAxesList[i].getCoord(2) /tranAxesList[i].getCoord(3) ;
		iw = tranAxesList[i].getCoord(3) /tranAxesList[i].getCoord(3) ;
		if (ix >= 0 && iy >= 0 && ix < w && iy < h){
		    raster.setPixel(axesList[i].getColor(), ix, iy);
		}
	    }
        }

	int nRendered = 0;
        for (int i = 0; i < vertices; i++) {
	    if( tranList[i].getCoord(3) !=0){
		ix = (int) (tranList[i].getCoord(0) / tranList[i].getCoord(3));
		iy = (int) (tranList[i].getCoord(1) / tranList[i].getCoord(3));
		iz = tranList[i].getCoord(2) /tranList[i].getCoord(3) ;
		iw = tranList[i].getCoord(3) /tranList[i].getCoord(3) ;
		if (ix >= 0 && iy >= 0 && ix < w && iy < h){
		    nRendered++;
		    raster.setPixel(vertList[i].getColor(), ix, iy);
		}
	    }
        }
	showStatus("Vertices rendered = " + nRendered ); 
	showStatus("PercentNOT rendered = " + (vertices-nRendered)*100/vertices ); 
    }
    
}


********************************************************************************