/*
 *      @(#)Extrusion.java 1.23 99/03/24 15:56:40
 *
 * Copyright (c) 1996-1999 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
 * modify and redistribute this software in source and binary code form,
 * provided that i) this copyright notice and license appear on all copies of
 * the software; and ii) Licensee does not utilize the software in a manner
 * which is disparaging to Sun.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
 * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
 * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
 * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * This software is not designed or intended for use in on-line control of
 * aircraft, air traffic, aircraft navigation or aircraft communications; or in
 * the design, construction, operation or maintenance of any nuclear
 * facility. Licensee represents and warrants that it will not use or
 * redistribute the Software for such purposes.
 */

/*
 * @Author: Rick Goldberg
 *
 */
package com.sun.j3d.loaders.vrml97.impl;

import com.sun.j3d.loaders.vrml97.impl.*;
import com.sun.j3d.utils.geometry.GeometryInfo;
import com.sun.j3d.utils.geometry.NormalGenerator;
import com.sun.j3d.utils.geometry.Stripifier;
import javax.media.j3d.GeometryArray;
import javax.media.j3d.IndexedQuadArray;
import javax.media.j3d.BoundingBox;
import javax.media.j3d.Transform3D;
import javax.media.j3d.Shape3D;
import javax.vecmath.*;


public class Extrusion extends Geometry implements Ownable{

    SFBool beginCap;
    SFBool ccw;
    SFBool convex;
    SFFloat creaseAngle;
    MFVec2f crossSection;
    SFBool endCap;
    MFRotation orientation;
    MFVec2f scale;
    SFBool solid;
    MFVec3f spine;

    GeometryArray impl;
    BoundingBox bounds;
    GeometryInfo gi;
    Shape owner;

    /** Shape to be displayed */
  	Shape3D shape = new Shape3D();

    Point3f[] spines;
    Vector3f[] scales;
    AxisAngle4f[] orientations;
    Transform3D[] spineTransforms;
    Point3f[] crossSectionPts;
    // will contain the per spine
    // transform composed with orientation
    Matrix3f[] rotations;
    Transform3D[] transforms;

    // data -> gi
    Point3f[] coords;
    int[] coordIndex;
    int[] stripCounts;

    boolean collinear=false;
    boolean closed=false; // spines

    float[] a2 = new float[2];
    float[] a3 = new float[3];
    float[] a4 = new float[4];

    int numTris = 0;

    public static boolean hardDebug = false;



    public Extrusion(Loader loader) {
      super(loader);
      beginCap = new SFBool(true);
      endCap = new SFBool(true);
      ccw = new SFBool(true);
      convex = new SFBool(true);
      solid = new SFBool(true);
      if (loader.autoSmooth) {
          creaseAngle = new SFFloat(.9f);
      } else {
          creaseAngle = new SFFloat(0);
      }

      crossSection = new MFVec2f(5, new float[10]);
      crossSection.set1Value(0,1.0f,1.0f);
      crossSection.set1Value(1,1.0f,-1.0f);
      crossSection.set1Value(2,-1.0f,-1.0f);
      crossSection.set1Value(3,-1.0f,1.0f);
      crossSection.set1Value(4,1.0f,1.0f);
      spine = new MFVec3f(2, new float[6]);
      spine.set1Value(0,0.0f,0.0f,0.0f);
      spine.set1Value(1,0.0f,1.0f,0.0f);
      orientation = new MFRotation(1,new float[4]);
      orientation.set1Value(0,0.0f,0.0f,1.0f,0.0f);
      scale = new MFVec2f(new float[2]);
      scale.set1Value(0,1.0f,1.0f);
      initFields();
    }

    Extrusion(Loader loader, SFBool beginCap, SFBool ccw,
	SFBool convex, SFFloat creaseAngle, MFVec2f crossSection,
	SFBool endCap, MFRotation orientation, MFVec2f scale,
	SFBool solid, MFVec3f spine) {

      super(loader);
      this.beginCap = beginCap;
      this.ccw = ccw;
      this.convex = convex;
      this.creaseAngle = creaseAngle;
      this.crossSection = crossSection;
      this.endCap = endCap;
      this.orientation = orientation;
      this.scale = scale;
      this.solid = solid;
      this.spine = spine;
      initFields();
    }


	public Extrusion(Loader loader, boolean beginCap, boolean ccw,
		boolean convex, float creaseAngle, Tuple2d[] crossSection,
		boolean endCap, AxisAngle4d[] orientations, Vector2d[] scales,
		boolean solid, Tuple3d[] spine) {

		super(loader);
    this.beginCap = new SFBool(beginCap);
    this.ccw = new SFBool(ccw);
		this.convex = new SFBool(convex);
		this.creaseAngle = new SFFloat(creaseAngle);

    if (hardDebug)
    {
    	System.out.println("Crossection = ");
      for (int i = 0; i < crossSection.length; i++)
      {
        System.out.println(crossSection[i]);
      }
    	System.out.println("Spine = ");
      for (int i = 0; i < spine.length; i++)
      {
        System.out.println(spine[i]);
      }
    }

		float[] aCrossSection = new float[2*crossSection.length];
		for (int i = 0; i < crossSection.length; i++)
    {
      aCrossSection[i*2 + 0] = (float)crossSection[i].x;
      aCrossSection[i*2 + 1] = (float)crossSection[i].y;
    }
    this.crossSection = new MFVec2f(aCrossSection);


		this.endCap = new SFBool(endCap);

		float[][] aOrientations = new float[orientations.length][4];
    for (int i = 0; i < orientations.length; i++)
    {
      aOrientations[i][0] = (float)orientations[i].x;
      aOrientations[i][1] = (float)orientations[i].y;
      aOrientations[i][2] = (float)orientations[i].z;
      aOrientations[i][3] = (float)orientations[i].angle;
    }
		this.orientation = new MFRotation(aOrientations);

    float[] aScales = new float[2*scales.length];
		for (int i = 0; i < scales.length; i++)
    {
      aScales[i*2 + 0] = (float)scales[i].x;
      aScales[i*2 + 1] = (float)scales[i].y;
    }
		this.scale = new MFVec2f(aScales);

		this.solid = new SFBool(solid);

		float[] aSpine = new float[spine.length*3];
    for (int i = 0; i < spine.length; i++)
    {
    	aSpine[i*3 + 0] = (float)spine[i].x;
      aSpine[i*3 + 1] = (float)spine[i].y;
      aSpine[i*3 + 2] = (float)spine[i].z;
    }
    this.spine = new MFVec3f(aSpine);
    initImpl();
  }
  public boolean haveTexture() { return false; }

  public int getNumTris() { return numTris; }

  public Shape3D getShape()
  {
		shape.setGeometry(impl);
    return shape;
  }

  public javax.media.j3d.Geometry getImplGeom() {
		return impl;
  }

  BoundingBox getBoundingBox() {

        // create a tiny bounding box about a coordinate
        // to seed the placement
      Point3d epsilon = new Point3d(.000001,.000001,.000001);
      Point3d lower = new Point3d(coords[0]);
      Point3d upper = new Point3d(coords[0]);
      lower.sub(epsilon);
      upper.add(epsilon);

      bounds=new javax.media.j3d.BoundingBox(lower,upper);

      for ( int c = 1; c<coords.length; c++ ) {
          bounds.combine(new Point3d(coords[c]));
      }
      return bounds;

    }

    void initImpl() {

	// endcaps may need special handling
	gi = new GeometryInfo(GeometryInfo.POLYGON_ARRAY);

	// convert vrml data to intermediate form
	initSetup();

	// calculate per spine SCP transforms
	// results in transforms[] being filled withs SCP info
	// complete with scale, translation and orientation from
	// fields
	calculateSCP();

	// transform the crossSections to coordinates
	createExtrusion();

	// indexify, including endcaps if needed
	// leaves coordIndex with index and stripCounts with counts
	// per facet.
	createIndices();
	if ( hardDebug ) {
	    System.out.println("coords");
	    for ( int i = 0; i < coords.length; i ++ ) System.out.println(coords[i]);
	    System.out.println("coordIndex");
	    for ( int i = 0; i < coordIndex.length; i ++ ) System.out.println(coordIndex[i]);
	    System.out.println("stripCounts");
	    for ( int i = 0; i < stripCounts.length; i ++ ) System.out.println(stripCounts[i]);
	}
	gi.setCoordinates(coords);
	gi.setCoordinateIndices(coordIndex);
	gi.setStripCounts(stripCounts);

	//Stripifier st = new Stripifier();
	//st.stripify(gi);

	float ca = creaseAngle.getValue();
	if ( ca < 0.0f ) {
	    ca = 0.0f;
	}
	if ( ca > (float)Math.PI ) {
	    ca -= (float)Math.PI;
	}

	NormalGenerator ng = new NormalGenerator(ca);
	ng.generateNormals(gi);
	
	impl = gi.getGeometryArray();


    }

    void initSetup() {
	// load the crossSectionPts data
	crossSectionPts = new Point3f[ crossSection.getSize() ];

	if ( hardDebug ) System.out.println(crossSection.getSize());
	for ( int i = 0; i < crossSectionPts.length; i++ ) {
	    crossSection.get1Value(i,a2);
    crossSectionPts[i] = new Point3f(a2[0],0.0f,a2[1]);
	}

	// load the scales
	// scales size may not match spine size, if so
	// use previously set scale
	scales = new Vector3f[ spine.getSize() ];
	for ( int i = 0; i < scales.length; i++ ) {
	    if ( i < scale.getSize() )
	        scale.get1Value(i,a2);
	    scales[i] = new Vector3f(a2[0],1.0f,a2[1]);
	}

	// load the spines
	spines = new Point3f[ spine.getSize() ];
	for ( int i = 0; i < spines.length; i++ ) {
	    spine.get1Value(i,a3);
	    spines[i] = new Point3f(a3);
	}

	// load the per spine orientation modifiers
	orientations = new AxisAngle4f[ spine.getSize() ];
	for ( int i = 0; i < orientations.length; i++ ) {
	    if ( i < orientation.getSize() )
	        orientation.get1Value(i,a4);
	    orientations[i] = new AxisAngle4f(a4);
	}

	rotations = new Matrix3f[ spines.length ];

	// if the tail meets the head
	if (spines[0].equals(spines[spines.length - 1])) {
	    closed = true;
	}

        // if entirely collinear
        Vector3d v2 = new Vector3d();
        Vector3d v1 = new Vector3d();
        Vector3d v0 = new Vector3d();
        double d=0.0;
        for ( int i = 1; i < spines.length - 1; i++ ) {
            v2.set(spines[i+1]);        
            v1.set(spines[i]);
            v0.set(spines[i-1]);  
            v2.sub(v1);
            v1.sub(v0);
            v0.cross(v2,v1);
            d += v0.dot(v0);
        }
        collinear=(d==0.0);
	if ( hardDebug && collinear ) System.out.println("spine is straight");

    }

    void calculateSCP() {
	// find an orthonormal basis and construct rotation matrix
	// for each spine. handle special cases in second pass
	Vector3f[] x,y,z;
	Vector3f u,v;
	Vector3f zero = new Vector3f(0.0f,0.0f,0.0f);
	int last = spines.length-1;
	
	x = new Vector3f[ spines.length ];
	y = new Vector3f[ spines.length ];
	z = new Vector3f[ spines.length ];
	
	if ( collinear ) {
	    if (closed) { 
		throw new vrml.InvalidVRMLSyntaxException(
		    "invalid Extrusion data; looks like a solid of revolution"
		);
	    }
    // Direction is the first spine point that does not equal to
    // spines[0]
    Vector3f direction = null;
    for (int i = 0; i < spines.length; i++)
    {
    	if (!spines[0].equals(spines[i]))
      {
      	direction = new Vector3f(spines[i]);
      }
    }

		y[0] = new Vector3f();
		y[0].sub( direction, spines[0] );
		try {
		    norm(y[0]);
		} catch ( ArithmeticException ae ) {
    	ae.printStackTrace();
		}

		// Create an initial x[0]
		if (y[0].x == 1.0f)
    {
    	x[0] = new Vector3f(0.0f,-1.0f,0.0f);
    }
		else if (y[0].x == -1.0f)
    {
    	x[0] = new Vector3f(0.0f,1.0f,0.0f);
    }
    else
    {
    	x[0] = new Vector3f(1.0f,0.0f,0.0f);
    }

		// Create z[0]
		z[0] = new Vector3f();
    z[0].cross(x[0],y[0]);

    // Create final x[0]
    x[0].cross(y[0],z[0]);

    for ( int i = 1; i < spines.length; i++ ) {
      // redo, this should take the direction of y
      // redone by Pasi Paasiala <<check this>>
      x[i] = new Vector3f(x[0]);
      y[i] = new Vector3f(y[0]);
      z[i] = new Vector3f(z[0]);
    }
	} else {
	    // find y[i] for all but first and last
	    // most times the exception cases are bad data and hopefully
	    // wont happen. It is free to try catch you later, so hopes
	    // 99% cases will be one if faster by not checking the if
	    for ( int i = 1; i < last; i++ ) {
		y[i] = new Vector3f();
		y[i].sub( spines[i+1], spines[i-1] );
		try {
		    norm(y[i]);
		} catch ( ArithmeticException ae ) {
		    if ( hardDebug ) System.out.println(ae+" "+y[i]);
		    // spines[i+1] equals spines[i-1]
		    try {
			y[i].sub( spines[i+1], spines[i] );
			norm(y[i]);
		    } catch ( ArithmeticException ae1 ) {
		        if ( hardDebug ) System.out.println(ae1+" "+y[i]);
		        // spines[i+1] equaled spines[i]
			try {
			    y[i].sub( spines[i], spines[i-1] );
			    norm(y[i]);
			} catch ( ArithmeticException ae2 ) {
		            if ( hardDebug ) System.out.println(ae2+" "+y[i]);
			    // spines[i] equaled spines[i-1]
			    // real bad case, do something
			    int w=i+2;
			    while (( w < last+1 ) && (spines[i-1].equals(spines[w]))) 
				w++;
			    if ( w < last+1 ) {
				y[i].sub(spines[w],spines[i-1]);
		                if ( hardDebug ) System.out.println("did something "+y[i]);
				norm(y[i]); // should never divide by zero here
			    } else { // worst worst case
		                if ( hardDebug ) System.out.println("worst worst y "+y[i]);
				y[i] = new Vector3f(0.0f,1.0f,0.0f);
			    }
			}
		    }
		}
	    }
	    // y for ends
	    if ( closed ) {
		// closed and not collinear -> not all one point
		y[0] = new Vector3f();
		y[0].sub(spines[1],spines[last-1]);
		try {
		    norm(y[0]);
		} catch ( ArithmeticException ae ) {
		    // bad case that the spine[n-2] == spine[1]
		    int w=last-2; 
		    while((w > 1) && (spines[1].equals(spines[w]))) 
			w--;
		    if (w > 1) {
			y[0].sub(spines[1],spines[w]); 
			norm(y[0]); // should never divide by zero here
		    } else
			// how did this happen?
			y[0].set(0.0f,0.0f,1.0f);
		}
		y[last] = new Vector3f(y[0]);
	    } else {
		y[0] = new Vector3f();
		y[last] = new Vector3f();
		y[0].sub(spines[1],spines[0]);
		try {
		    norm(y[0]);
		} catch ( ArithmeticException ae ) {
		    int w=2;
		    while ((w < last) && (spines[0].equals(spines[w]))) 
			w++;
		    if (w < last) {
			y[0].sub(spines[w],spines[0]);
			norm(y[0]); // should not divide by zero here
		    } else 
			y[0].set(0.0f,0.0f,1.0f);
		}
		y[last] = new Vector3f();
		y[last].sub(spines[last],spines[last-1]);
		try {
		    norm(y[last]);
		} catch ( ArithmeticException ae ) {
		    int w=last-2;
		    while ((w > -1) && (spines[last].equals(spines[w]))) 
			w--;
		    if (w > -1)  {
			y[last].sub(spines[last],spines[w]);
			norm(y[last]);
		    } else
			y[last].set(0.0f,0.0f,1.0f);
		}
	    }
	    // now z axis for each spine
	    // first all except first and last	
		
	    boolean recheck = false;
	    for ( int i = 1; i < last; i++ ) {
		u = new Vector3f();
		v = new Vector3f();
		z[i] = new Vector3f();
		u.sub(spines[i-1],spines[i]);
		v.sub(spines[i+1],spines[i]);
		// spec seems backwards on u and v
		// shouldn't it be z[i].cross(u,v)???
		//z[i].cross(v,u);
    //--> z[i].cross(u,v); is correct <<check this>>
    // Modified by Pasi Paasiala
		z[i].cross(u,v);
		try {
		    norm(z[i]);
		} catch ( ArithmeticException ae ) { 	
		    recheck=true;
		}
	    }
	    if ( closed ) {
		z[0] = z[last] = new Vector3f();
		u = new Vector3f();
		v = new Vector3f();
		u.sub(spines[last-1],spines[0]);
		v.sub(spines[1],spines[0]);
		try {
		    z[0].cross(u,v);
		} catch ( ArithmeticException ae ) {
		    recheck=true;
		}
	    } else { // not closed
		z[0] = new Vector3f(z[1]);
		z[last] = new Vector3f(z[last-1]);
	    }
	    if ( recheck ) { // found adjacent collinear spines 
		// first z has no length ?
		if ( hardDebug ) 
		    System.out.println("rechecking, found adjacent collinear spines");
		if ( z[0].dot(z[0]) == 0.0f ) {
		    for ( int i = 1; i < spines.length; i++ ) {
			if ( z[i].dot(z[i]) > 0.0f ) 
			    z[0] = new Vector3f(z[i]);
		    } 
		    // test again could be most degenerate of cases
		    if ( z[0].dot(z[0]) == 0.0f ) 
			z[0] = new Vector3f(0.0f,0.0f,1.0f);
		}

		// check rest of z's
		for ( int i = 1; i < last+1; i++ ) {
		    if ( z[i].dot(z[i]) == 0.0f )
			z[i] = new Vector3f(z[i-1]);
		}
	    }
	    // finally, do a neighbor comparison
	    // and evaluate the x's
	    for ( int i = 0; i < spines.length; i++ ) {
		if ( i > 0 ) 
		    if ( z[i].dot(z[i-1]) < 0.0f ) 
		       z[i].negate();

	    	// at this point, y and z should be nice
		x[i] = new Vector3f();
    //Original was: x[i].cross(z[i],y[i]); <<check this>>
		//but it doesn't result in right handed coordinates
    // Modified by Pasi Paasiala
		x[i].cross(y[i],z[i]);
		try {
		    norm(x[i]);
		} catch ( ArithmeticException ae ) {
		    // this should not happen
		    ae.printStackTrace();
		}
		if( hardDebug ) System.out.println("x["+i+"] "+x[i]);
	    }
	}


	// should now have orthonormal vectors for each
 	// spine. create the rotation matrix with scale for
	// each spine. spec is unclear whether a twist imparted
	// at one of the spines is inherited by its "children"
	// so assume not.

	// also, the order looks like SxTxRscpxRo , ie ,
	// the spec doc looks suspect, double check

	Matrix3f m = new Matrix3f();
	transforms = new Transform3D[spines.length];

	for ( int i = 0; i < spines.length; i++ ) {
	    rotations[i] = new Matrix3f();
	    if ( hardDebug )
      {
				Vector3f xd = new Vector3f(spines[i]);
        xd.add(x[i]);
				Vector3f yd = new Vector3f(spines[i]);
        yd.add(y[i]);
				Vector3f zd = new Vector3f(spines[i]);
        zd.add(z[i]);
      	System.out.println("\northos (ABS) "+
		i+" "+xd+" "+yd+" "+zd+" "+orientations[i]);
      	System.out.println("orthos "+
		i+" "+x[i]+" "+y[i]+" "+z[i]+" "+orientations[i]);
    	}
			// Original had setRow. This is correct <<check this>>
      // Modified by Pasi Paasiala
	    rotations[i].setColumn(0,x[i]);
	    rotations[i].setColumn(1,y[i]);
	    rotations[i].setColumn(2,z[i]);
  }

	Matrix3f[] correctionRotations = createCorrectionRotations(z);

	// Create the transforms
	for ( int i = 0; i < spines.length; i++ ) {
    	rotations[i].mul(correctionRotations[i]);
	    m.set(orientations[i]);
	    rotations[i].mul(m);
	    transforms[i]=new Transform3D();
	    transforms[i].setScale(new Vector3d(scales[i]));
	    transforms[i].setTranslation(new Vector3d(spines[i]));
	    transforms[i].setRotation(rotations[i]);
	}

    }

  /**
  * Creates a rotation for each spine point to avoid twisting of the profile
  * when the orientation of SCP changes.
  * @author Pasi Paasiala
  * @param z the vector containing the z unit vectors for each spine point
  */
	private Matrix3f[] createCorrectionRotations(Vector3f[] z)
  {
    Matrix3f[] correctionRotations = new Matrix3f[spines.length];
    correctionRotations[0] = new Matrix3f();
    correctionRotations[0].setIdentity();
    AxisAngle4f checkAngle = new AxisAngle4f();
    // testPoint is used to find the angle that gives the smallest distance
    // between the previous and current rotation. Find a point that is not
    // in the origin.
    Point3f testPoint = crossSectionPts[0];
    for (int i = 0; i < crossSectionPts.length; i++)
    {
      if (crossSectionPts[i].x != 0 || crossSectionPts[i].z != 0)
      {
        testPoint = crossSectionPts[i];
        break;
      }
    }

    // Fix the orientations by using the angle between previous z and current z
    for (int i = 1; i < spines.length; i++)
    {
      float angle = z[i].angle(z[i-1]);
      correctionRotations[i] = correctionRotations[i-1];
      if (angle != 0)
      {
      	correctionRotations[i] = new Matrix3f(correctionRotations[i-1]);
        Point3f previous = new Point3f();
  //			Point3f previous = testPoint;
        // Test with negative angle:
        Matrix3f previousRotation = new Matrix3f(rotations[i-1]);
        previousRotation.mul(correctionRotations[i-1]);
        previousRotation.transform(testPoint, previous);
        Matrix3f delta = new Matrix3f();
        delta.setIdentity();
        delta.rotY(-angle);
        correctionRotations[i].mul(delta);
        Matrix3f negativeRotation = new Matrix3f(rotations[i]);
        negativeRotation.mul(correctionRotations[i]);
        Point3f pointNegative = new Point3f();
        negativeRotation.transform(testPoint,pointNegative);
        float distNegative = pointNegative.distance(previous);

        // Test with positive angle
        delta.rotY(angle*2);
        correctionRotations[i].mul(delta);
        Matrix3f positiveRotation = new Matrix3f(rotations[i]);
        positiveRotation.mul(correctionRotations[i]);
        Point3f pointPositive = new Point3f();
        positiveRotation.transform(pointPositive);
        float distPositive = pointPositive.distance(previous);

        if (distPositive > distNegative)
        {
          // Reset correctionRotations to negative angle
          delta.rotY(-angle*2);
          correctionRotations[i].mul(delta);
        }

        if (hardDebug)
        {
          System.out.println("i = " + i + " Angle is " +
          (distPositive > distNegative ? "negative " : "positive ") +
          "\n previous = " + previous +
          "\npointNegative =" + pointNegative + "\npointPositive =" + pointPositive +
          angle + " dist+ = " + distPositive + " dist- = " + distNegative + "\n");
        }

        // Check that the angle is not more than PI.
        // If it is subtract PI from angle
        checkAngle.set(correctionRotations[i]);
        if (((float)Math.PI - checkAngle.angle) < 0.001)
        {
          correctionRotations[i].rotY((float)(checkAngle.angle - Math.PI));
        }
      }
    }
    return correctionRotations;
  }

    // create a list of unique coords ( of Point3f )
    // by applying the transforms to the crossSectionPts
    void createExtrusion() {

	coords = new Point3f[ spines.length * crossSectionPts.length ];
  if (hardDebug)
  {
		System.out.println("Transformations");
  	for (int i = 0; i < transforms.length; i++)
    {
			Matrix3d rotation = new Matrix3d();
      Vector3d location = new Vector3d();
    	transforms[i].get(rotation, location);
      System.out.println(rotation.toString() + "\n" + location.toString() + "\n");
    }
  }

	for ( int i = 0; i < spines.length; i++ ) {
	    for ( int j = 0; j < crossSectionPts.length; j++ ) {
		int ind = i*(crossSectionPts.length) + j;
		coords[ind] = new Point3f(crossSectionPts[j]);
    if (hardDebug)
    {
    	System.out.print("Transforming " + j +" "+ crossSectionPts[j] + " i =" + i);
    }
		transforms[i].transform(coords[ind]);
    if (hardDebug)
    {
    	System.out.println("Result = " + coords[ind]);
    }
	    }
	}
    }

    // wind the coords with indexed connectivity and create
    // stripCounts see page 47 of small bluebook
    void createIndices() {
	int m = 0; // coordIndex length
	int k = crossSectionPts.length;
	int l = coords.length;
	int s = 0;
	int n = 0; // coordIndex count
	if ( endCap.getValue() ) {
	   m += k-1;
	   s++;
	}
	if ( beginCap.getValue() ) {
	   m += k-1;
	   s++;
	}
	m += (spines.length-1)*(4*(k-1));
	coordIndex = new int[m];
	if ( hardDebug ) System.out.println("coordIndexSize"+m);
	stripCounts = new int[ s+(spines.length-1)*(k-1) ];
	s=0;
	if ( hardDebug ) System.out.println("stripCounts.length"+stripCounts.length);
	if ( hardDebug ) System.out.println("spines.length"+spines.length);
	// start with extrusion body from bottom
	for ( int i = 0; i < spines.length-1; i++ ) {
	    if ( hardDebug ) System.out.println(" i " + i);
	    for ( int j = 0; j < k-1; j++ ) {
		if ( hardDebug ) System.out.println(" j " + j);
		// create a quad
		if ( ccw.getValue() ) {
		    if ( hardDebug ) System.out.println("i "+i+" j "+j+" k "+k);
		    coordIndex[n++] = (i*k) + j;
		    if ( hardDebug ) System.out.println((n-1)+" "+((i*k)+(j)));
		    coordIndex[n++] = (i*k) + j + 1;
		    if ( hardDebug ) System.out.println((n-1)+" "+((i*k)+(j+1)));
		    coordIndex[n++] = ((i+1)*k) + j + 1;
		    if ( hardDebug ) System.out.println((n-1)+" "+(((i+1)*k)+(j+1)));
		    coordIndex[n++] = ((i+1)*k) + j;
		    if ( hardDebug ) System.out.println((n-1)+" "+(((i+1)*k)+(j)));
	        } else {
		    coordIndex[n++] = (i*k) + j;
		    coordIndex[n++] = ((i+1)*k) + j;
		    coordIndex[n++] = ((i+1)*k) + j + 1;
		    coordIndex[n++] = (i*k) + j + 1;
		}
	        stripCounts[s++]=4;
		numTris+=2;
	    }
	}
	// add top and bottom
	// note: when switching cw from ccw notice that 
	// the index is off by one, this is ok since there
	// is one extra point in the cross-section, each
	// cap has 2 ways to be drawn
	// also note top and bottom caps are reverse oriented to 
	// each other
	if ( beginCap.getValue() && endCap.getValue() ) {
	    int indB = m-(2*(k-1));
	    int indE = m-(k-1);
	    if ( !ccw.getValue() ) {
	        for ( int i = 0; i<k-1; i++ ) 
		    coordIndex[indB++] = i;

		for ( int i = l-1; i>l-k; i-- ) 
		    coordIndex[indE++] = i;
		
	    } else {
		for ( int i = k-1; i>0; i-- )
		    coordIndex[indB++] = i;
		for ( int i = 0; i<k-1; i++ )
		    coordIndex[indE++] = l-(k-1)+i;
	    }
	    stripCounts[s++]=k-1;
	    stripCounts[s++]=k-1;
	    numTris += k-1; // best guess what gi did?
	} else if ( beginCap.getValue() ) {
	    int ind = m-(k-1);
	    if ( !ccw.getValue() ) {
	        for ( int i = 0; i < k-1; i++ ) 
		    coordIndex[ind++] = i;
	    } else { // this is ok since extra x-sectpt give off by one
		for ( int i = k-1; i > 0; i-- ) 
		    coordIndex[ind++] = i;
	    }
	    stripCounts[s++]=k-1;
	    numTris += k-1;
	} else if ( endCap.getValue() ) {
	    int ind = m-(k-1);
	    if ( ccw.getValue() ) {
	        for ( int i = l-(k-1); i<l; i++ )
		    coordIndex[ind++] = i;
	    } else {
		for ( int i = l-1; i>l-k; i-- )
		    coordIndex[ind++] = i;
	    }
	    stripCounts[s++]=k-1;
	    numTris += k-1;
	}	
    }

    // the vecmath package was not throwing ArithmeticExceptions as
    // expected from the normalize() method.
    void norm(Vector3f n) {
			float norml = (float)Math.sqrt(n.x*n.x + n.y*n.y + n.z*n.z);
			if ( norml == 0.0f ) throw new ArithmeticException();

			n.x /= norml;
			n.y /= norml;
			n.z /= norml;
    }

    public void notifyMethod(String eventInName, double time) {
	if (!eventInName.startsWith("route_")) {
	    initImpl(); 
	    ((Shape3D)(owner.implNode)).setGeometry(impl);
	}
	else { 
	    ((Shape3D)(owner.implNode)).setCapability(Shape3D.ALLOW_GEOMETRY_WRITE);
	}
    }	

    void initFields() {

	beginCap.init( this, FieldSpec, Field.FIELD, "beginCap");
	ccw.init( this, FieldSpec, Field.FIELD, "ccw");
	convex.init( this, FieldSpec, Field.FIELD, "convex");
	creaseAngle.init( this, FieldSpec, Field.FIELD, "creaseAngle");
	crossSection.init( this, FieldSpec, Field.EVENT_IN, "crossSection");
	endCap.init( this, FieldSpec, Field.FIELD, "endCap");
	orientation.init( this, FieldSpec, Field.EVENT_IN, "orientation");
	scale.init( this, FieldSpec, Field.EVENT_IN, "scale");
	solid.init( this, FieldSpec, Field.FIELD, "solid");
	spine.init( this, FieldSpec, Field.EVENT_IN, "spine");
    }

    public Object clone() {
	return new Extrusion( loader, (SFBool) beginCap.clone(), (SFBool) ccw.clone(),
	    (SFBool)convex.clone(), (SFFloat)creaseAngle.clone(), (MFVec2f)crossSection.clone(),
	    (SFBool)endCap.clone(), (MFRotation)orientation.clone(), (MFVec2f)scale.clone(),
	    (SFBool)solid.clone(), (MFVec3f)spine.clone() );
    }

    public String getType() {
	return "Extrusion";
    }

    public boolean getSolid() { return solid.getValue(); }
    public void setOwner(Shape owner) { this.owner = owner; }
}