/* -------------------------------------------------------------------
    * Java source file for the class QuadSurfaceModeler
    * 
    * Copyright (c), 2003, Masahiro Takatsuka.
    * All Rights Researved.
    * 
    * Original Author: Masahiro Takatsuka (masa@jbeans.net)
    * $Author: takatsukam $
    * 
   * $Date: 2004/03/03 11:53:05 $
   * 
   * $Id: QuadSurfaceModeler.java,v 1.3 2004/03/03 11:53:05 takatsukam Exp $
   * 
   * Reference:		Document no:
   * ___				___
   * 
   * To Do:
   * ___
   * 
  ------------------------------------------------------------------- */
  
  /* --------------------------- Package ---------------------------- */
  package net.jbeans.j3d.modeler.geometry;
  
  /* ------------------ Import classes (packages) ------------------- *//package-summary/html">class="comment"> ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment"> ------------------ Import classes (packages) ------------------- */
  import java.awt.*;
  import java.awt.event.*;
  import java.io.*;
  import java.lang.reflect.*;
  import java.util.*;
  import javax.media.j3d.*;
  import javax.vecmath.*;
  import com.sun.j3d.utils.geometry.*;
  
  import net.jbeans.util.debug.*;
  
  /*====================================================================
                Implementation of class QuadSurfaceModeler              
  ====================================================================*/
  /***
   * QuadSurfaceModeler generates a suface geometry from the specified data.
   * 
   * @version $Revision: 1.3 $
   * @author Masahiro Takatsuka (masa@jbeans.net)
   * @see QuadModeler
   */
  
  public class QuadSurfaceModeler extends QuadModeler {
  	private static final boolean DEBUG = Debug.getDebugFlag(QuadSurfaceModeler.class);
  	/* ------------------------ not serialized ------------------------ */
  	transient private int xSize;
  	transient private int ySize;
  	transient private int xQSize;
  	transient private int yQSize;
  	transient private int[] indices;
  	transient private boolean useQuadModeler = false;
  	
  	/* -------------------------- serialized -------------------------- */
  	private double voidValue = Double.NaN;
  	private boolean blanking = false;
  	
  	public QuadSurfaceModeler() {
  		super();
  	}
  
  	public void setBlanking(boolean b) {
  		this.blanking = b;
  	}
  
  	public boolean getBlanking() {
  		return this.blanking;
  	}
  
  	public void setVoidValue(double voidvalue) {
  		this.voidValue = voidvalue;
  	}
  
  	public double getVoidValue() {
  		return this.voidValue;
  	}
  
  	public void setXSize(int x) {
  		this.xSize = x;
  	}
  
  	public int getXSize() {
  		return this.xSize;
  	}
  	
  	public void setYSize(int y) {
  		this.ySize = y;
  	}
  
  	public int getYSize() {
  		return this.ySize;
  	}
  	
  	protected boolean checkSize() {
  		if (this.xSize < 2 || this.ySize < 2) {
 			return false;
 		}
 		return super.checkSize();
 	}
 
 	protected boolean needsModel() {
 		boolean ret = super.needsModel();
 		double[] x = (double[]) this.entryArray[XC];
 		
 		ret = (ret || (this.xSize * this.ySize != x.length) ||
 			   (this.xSize != (this.xQSize + 1)) ||
 			   (this.ySize != (this.yQSize + 1)));
 		
 		if (ret || this.blanking) {
 			ret = true;
 			computeIndices();
 		}
 		return ret;
 	}
 
 	private void computeIndices() {
 		this.xQSize = this.xSize - 1;
 		this.yQSize = this.ySize - 1;		
 		int numQuads = this.xQSize * this.yQSize;
 		int totalPoints = numQuads * 4;
 		this.indices = new int[totalPoints];
 		int tmpidx;
 		int v0, v1, v2, v3;
 		double[] z = (double[]) this.entryArray[ZC];
 		int k = 0;
 		for (int i = 0; i < this.yQSize; i++) {
 			for (int j = 0; j < this.xQSize; j++) {
 				tmpidx = k * 4;
 				v0 = i * this.xSize + j;
 				v1 = v0 + 1;
 				v2 = (i + 1) * this.xSize + (j + 1);
 				v3 = v2 - 1;
 				if (this.blanking &&
 					(z[v0] == this.voidValue ||
 					 z[v1] == this.voidValue ||
 					 z[v2] == this.voidValue ||
 					 z[v3] == this.voidValue)) {
 					this.useQuadModeler = true;
 					continue;
 				}
 				this.indices[tmpidx    ] = v0;
 				this.indices[tmpidx + 1] = v1;
 				this.indices[tmpidx + 2] = v2;
 				this.indices[tmpidx + 3] = v3;
 				k++;
 			}
 		}
 		if ((k * 4) < totalPoints) {
 			int[] tmpIndices = new int[k * 4];
 			System.arraycopy(this.indices, 0, tmpIndices, 0, tmpIndices.length);
 			this.indices = tmpIndices;
 		}
 	}
 	
 	protected synchronized void setData() {
 		double[] color = (double[]) this.entryArray[CC];
 		double[][] normal = (double[][]) this.entryArray[NC];
 		double[][] tCoord = (double[][]) this.entryArray[TC];				
 		
 		setCoordinateIndices(this.indices);
 		
 		if (color != null) {
 			setColorIndices(this.indices);
 		}
 		
 		if (normal != null) {
 			setNormalIndices(this.indices);
 		}
 		
 		if (tCoord != null) {
 			setTextureCoordinateIndices(this.indices);
 		}
 		super.setData();
 	}
 
 	/*
 	* uncomment the calculateNormals and modelGeometry method in order to
 	* create geometry without the help of GeometryInfo.
 	* Masahiro Takatsuka/2002-Feb-06
 	*/
 	private void calculateNormals() {
 		if (DEBUG) {
 			System.out.println("computing normals.");
 		}
         int i = this.coords3f.length;
         int j = this.indices.length / 4;
 
 		if (this.normals3f == null || this.normals3f.length != i) {
             this.normals3f = new Vector3f[i];
             for (int k = 0; k < i; k++) {
                 this.normals3f[k] = new Vector3f();
 			}
         } else {
             for (int l = 0; l < i; l++) {
                 this.normals3f[l].set(0.0f, 0.0f, 0.0f);
 			}
         }
         for (int i1 = 0; i1 < j; i1++) {
 			Vector3f vector3f = null;
 			Point3f p1 = this.coords3f[this.indices[i1 * 4]];
 			Point3f p2 = this.coords3f[this.indices[i1 * 4 + 1]];
 			Point3f p3 = this.coords3f[this.indices[i1 * 4 + 2]];
 
 			if (!this.blanking ||
 				(p1.z != this.voidValue &&
 				 p2.z != this.voidValue &&
 				 p3.z != this.voidValue)) {
 				vector3f = SurfaceModeler.geomCalcTriNormals(p1, p2, p3);
 				for (int k1 = 0; k1 < 3; k1++) {
 					this.normals3f[this.indices[i1 * 4 + k1]].add(vector3f);
 				}
 			}
 			p2 = p3;
 			p3 = this.coords3f[this.indices[i1 * 4 + 3]];
 			if (!this.blanking ||
 				(p1.z != this.voidValue &&
 				 p2.z != this.voidValue &&
 				p3.z != this.voidValue)) {
 				vector3f = SurfaceModeler.geomCalcTriNormals(p1, p2, p3);
 				for (int k1 = 0; k1 < 4; k1++) {
 					if (k1 == 1) {
 						continue;
 					}
 					this.normals3f[this.indices[i1 * 4 + k1]].add(vector3f);
 				}
 			}
         }
 		
         for (int j1 = 0; j1 < i; j1++) {
 			if (this.normals3f[j1].length() != 0) {
 				this.normals3f[j1].normalize();
 			}
 			if (DEBUG) {
 				System.out.println("normals3f = " + this.normals3f[j1]);
 			}
 		}
     }
 
 	/***
 	 * Construct a javax.media.j3d.GeometryArray object from quad data.
 	 */
 // 	protected void modelGeometry() {
 // 		int size = this.x.length;
 // 		this.coords3f = new Point3f[size];
 // 		int format = GeometryArray.BY_REFERENCE | GeometryArray.COORDINATES | GeometryArray.NORMALS;
 // 		if (this.color != null) {
 // 			this.hasColors = true;
 // 			if (this.alpha != null) {
 // 				format |= GeometryArray.COLOR_4;
 // 				this.colors4f = new Color4f[size];
 // 				this.colors3f = null;
 // 			} else {
 // 				format |= GeometryArray.COLOR_3;
 // 				this.colors4f = null;
 // 				this.colors3f = new Color3f[size];
 // 			}
 // 		}
 // 		if (this.tCoords != null) {
 // 			this.hasTCoords = true;
 // 			if (this.tCoords[0].length == 2) {
 // 				format |= GeometryArray.TEXTURE_COORDINATE_2;
 // 				this.texCoords2f = new TexCoord2f[size];
 // 				this.texCoords3f = null;
 // 			} else {
 // 				format |= GeometryArray.TEXTURE_COORDINATE_3;
 // 				this.texCoords2f = null;
 // 				this.texCoords3f = new TexCoord3f[size];
 // 			}
 // 		}
 
 // 		IndexedQuadArray geom = new IndexedQuadArray(size, format, this.indices.length);
 // 		if (DEBUG) {
 // 			System.out.println("size = " + size);
 // 			System.out.println("length = " + this.indices.length);
 // 		}
 // 		for (int i = 0; i < size; i++) {
 // 			this.coords3f[i] = new Point3f((float) this.x[i], (float) this.y[i], (float) this.z[i]);
 // 			if (DEBUG) {
 // 				System.out.println("coords3f = " + this.coords3f[i]);
 // 			}
 // 			//System.out.print("\rPoint3f = " + this.coords3f[i]);
 // 			if (this.hasColors) {
 // 				double[] tmp = this.lookupTable.mapValue(this.color[i]);
 // 				if (this.colors3f != null) {
 // 					this.colors3f[i] = new Color3f((float) tmp[0], (float) tmp[1], (float) tmp[2]);
 // 				} else {
 // 					this.colors4f[i] = new Color4f((float) tmp[0], (float) tmp[1], (float) tmp[2], (float) this.alpha[i]);
 // 				}
 // 			}
 // 			if (this.hasTCoords) {
 // 				if (this.texCoords2f != null) {
 // 					this.texCoords2f[i] = new TexCoord2f((float) this.tCoords[i][0], (float) this.tCoords[i][1]);
 // 				} else {
 // 					this.texCoords3f[i] = new TexCoord3f((float) this.tCoords[i][0], (float) this.tCoords[i][1], (float) this.tCoords[i][2]);
 // 				}
 // 			}
 // 		}
 // 		System.out.print("computing normals...");
 // 		calculateNormals();
 // 		System.out.println("\rcomputing normals...finished");
 
 // 		geom.setCoordRef3f(this.coords3f);
 // 		geom.setCoordinateIndices(0, this.indices);
 //  		geom.setNormalRef3f(this.normals3f);
 //   		geom.setNormalIndices(0, this.indices);
 // 		if (this.hasColors) {
 // 			if (this.colors3f != null) {
 // 				geom.setColorRef3f(this.colors3f);
 // 			} else {
 // 				geom.setColorRef4f(this.colors4f);
 // 			}
 // 			geom.setColorIndices(0, this.indices);
 // 		}
 // 		if (this.hasTCoords) {
 // 			if (this.texCoords2f != null) {
 // 				geom.setTexCoordRef2f(0, this.texCoords2f);
 // 			} else {
 // 				geom.setTexCoordRef3f(0, this.texCoords3f);
 // 			}
 // 			geom.setTextureCoordinateIndices(0, 0, this.indices);
 // 		}
 
 // 		// register this new geometry.
 // 		setGeometry(geom);
 // 	}
 
 	protected void modelGeometry() {
 		if (this.useQuadModeler) {
 			useQuadModeler();
 		}
 		super.modelGeometry();
 	}
 
 	protected void setupStripCounts() {
 		int quadNum = this.indices.length / 4;
 		int[] stripcounts = new int[quadNum];
 		for (int i = 0; i < quadNum; i++) {
 			stripcounts[i] = 4;
 		}
 		setStripCounts(stripcounts);
 	}
 	
 	private void useQuadModeler() {
 		// reset this.{x,y,z,...}.
 		int verticesNum = this.indices.length;
 		
 		double[] x = new double[verticesNum];
 		double[] y = new double[verticesNum];
 		double[] z = new double[verticesNum];
 		double[] color = null;
 		double[] alpha = null;
 		double[][] normal = null;
 		double[][] tCoords = null;
 		
 		if (this.color != null) {
 			color = new double[verticesNum];
 		}
 
 		if (this.alpha != null) {
 			alpha = new double[verticesNum];
 		}
 		
 		if (this.normal != null) {
 			normal = new double[verticesNum][];
 		}
 		
 		if (this.tCoords != null) {
 			tCoords = new double[verticesNum][];
 		}
 
 		for (int i = 0; i < verticesNum; i++) {
 			int idx = this.indices[i];
 			x[i] = this.x[idx];
 			y[i] = this.y[idx];
 			z[i] = this.z[idx];
 			if (DEBUG) {
 				System.out.println("QSM: x, y, z, c = " + x[i] + ", " +  y[i] + ", " +  z[i]);
 			}
 			
 			if (this.color != null) {
 				color[i] = this.color[idx];
 			}
 			
 			if (this.alpha != null) {
 				alpha[i] = this.alpha[idx];
 			}
 			
 			if (this.normal != null) {
 				normal[i] = this.normal[idx];
 			}
 		
 			if (this.tCoords != null) {
 				tCoords[i] = this.tCoords[idx];
 			}
 		}
 		this.x = x;
 		this.y = y;
 		this.z = z;
 		if (this.color != null) {
 			this.color = color;
 		}
 		if (this.alpha != null) {
 			this.alpha = alpha;
 		}
 		if (this.normal != null) {
 			this.normal = normal;
 		}
 		if (this.tCoords != null) {
 			this.tCoords = tCoords;
 		}
 		this.coordinateIndices = null;
 		this.colorIndices = null;
 		this.normalIndices = null;
 		this.texCoordIndices = null;
 	}
 	
 	public void test() {
 		double[] x = {441060.0, 441061.0, 441062.0, 441063.0, 441061.0, 441062.0, 441063.0, 441064.0, 441062.0, 441063.0, 441064.0, 441065.0, 441063.0, 441064.0, 441065.0, 441066.0, 441064.0, 441065.0, 441066.0, 441067.0};
 		double[] y = {561370.0, 561370.0, 561370.0, 561370.0, 561371.0, 561371.0, 561371.0, 561371.0, 561372.0, 561372.0, 561372.0, 561372.0, 561373.0, 561373.0, 561373.0, 561373.0, 561374.0, 561374.0, 561374.0, 561374.0};
 		double[] z = {0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0, 5.0, 5.0, 5.0, 5.0};
 		double[] color = {0.0, 0.2, 0.4, 0.6, 0.8, 0.8, 0.8, 0.0, 0.2, 0.4, 0.6, 0.8, 0.8, 0.8, 1.0, 1.0, 0.3, 0.3, 0.3, 0.3};
 
 		setBlanking(true);
 		setVoidValue(3.0);
 		setXSize(4);
 		setYSize(5);
 		setColors(color);
 		setXCoordinates(x);
 		setYCoordinates(y);
 		setZCoordinates(z);
 	}
 }