Implemented PickIntersection class

git-svn-id: https://svn.java.net/svn/j3d-core-utils~svn/trunk@85 9497e636-51bd-65ba-982d-a4982e1767a5

1 files changed, 1179 insertions, 217 deletions

diff --git a/src/classes/share/com/sun/j3d/utils/pickfast/PickIntersection.java b/src/classes/share/com/sun/j3d/utils/pickfast/PickIntersection.java
index 6403f89..5987ca8 100644
--- a/src/classes/share/com/sun/j3d/utils/pickfast/PickIntersection.java
+++ b/src/classes/share/com/sun/j3d/utils/pickfast/PickIntersection.java
@@ -105,313 +105,1275 @@ import com.sun.j3d.utils.geometry.Primitive;
 public class PickIntersection {
 
     
-    /* ===================   METHODS  ======================= */
-
-    /** Constructor 
-	@param intersectionInfo The IntersectionInfo this intersection is part of.
-    */
-    //PickIntersection (PickResult pr, GeometryArray geomArr) {
-    public PickIntersection (PickInfo.IntersectionInfo intersectionInfo) {
-	
-    }
+    /* The intersection point */
+    // Point3d getIntersectionPoint()
+    
+    /* Distance between start point of pickShape and intersection point */
+    // double getDistance()
     
-    /** Returns true if the geometry is indexed 
-     
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+    /* The vertex indices of the intersected primitive in the geometry */   
+    // int[] getVertexIndices()
 
-    */
-    public boolean geometryIsIndexed() {
-	throw new UnsupportedOperationException();
-    }
+    /*************************/
 
-    /** Get coordinates of closest vertex (local) 
-	@return the coordinates of the vertex closest to the intersection point
+    /** Weight factors for interpolation, values correspond to vertex indices,
+     * sum == 1
+     */
+    private double[] interpWeights;
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+    private static final boolean debug = false;
 
-    */
-    public Point3d getClosestVertexCoordinates () {
-	throw new UnsupportedOperationException();
-    }
+    // Axis constants
+    private static final int X_AXIS = 1;
+    private static final int Y_AXIS = 2;
+    private static final int Z_AXIS = 3;
 
-    /** Get coordinates of closest vertex (world) 
-	@return the coordinates of the vertex closest to the intersection point
+    // Tolerance for numerical stability
+    static final double TOL = 1.0e-5;
 
-	* This method is currently not supported.
-	* @exception UnsupportedOperationException this method is not supported
+    /* The references to the intersectionInfo object */
+    private PickInfo.IntersectionInfo iInfo = null;
+    private Transform3D l2vw = null;
+    private Geometry geometry = null;
+    private boolean geometryIsIndexed = false;
+    private double distance;
 
-    */
-    public Point3d getClosestVertexCoordinatesVW () {
-	throw new UnsupportedOperationException();
-    }
+    private boolean hasColors;
+    private boolean hasNormals;
+    private boolean hasTexCoords;
 
-    /** Get index of closest vertex 
-	@return the index of the closest vertex
+    // Primitive
+    /* indices for the different data types */
+    private int[] primitiveCoordinateIndices;
+    private int[] primitiveNormalIndices;
+    private int[] primitiveColorIndices;
+    private int[] primitiveTexCoordIndices;
+ 
+    /** Indices of the intersected primitive */
+    private int[] primitiveVertexIndices = null;
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+   /* Local coordinates of the intersected primitive */
+    private Point3d[] primitiveCoordinates = null;
 
-    */
-    public int getClosestVertexIndex () { 
-	throw new UnsupportedOperationException();
-    }
+    /** VWorld coordinates of intersected primitive */
+    private Point3d[] 	primitiveCoordinatesVW = null;
 
-    /** 
-	Get the distance from the PickShape start point to the intersection point
-	@return the distance to the intersection point, if available.
+    /* Normals of the intersected primitive */
+    private Vector3f[] primitiveNormals = null;
+
+    /* Colors of the intersected primitive */
+    private Color4f[] primitiveColors = null;
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+    /* TextureCoordinates of the intersected primitive */
+    private TexCoord3f[] primitiveTexCoords = null;
 
-    */
-    public double getDistance () {
-	throw new UnsupportedOperationException();
+    // Intersection point
+    /** VWorld Coordinates of the intersection point */
+    private Point3d pointCoordinatesVW = null;
+
+    /** Local Coordinates of the intersection point */
+    private Point3d pointCoordinates = null;
+
+    /** Normal at the intersection point */
+    private Vector3f pointNormal = null;
+
+    /** Color at the intersection point */
+    private Color4f pointColor = null;
+
+    /** TexCoord at the intersection point */
+    private TexCoord3f pointTexCoord = null;
+
+    // Closest Vertex
+    /** Index of the closest vertex */
+    private int closestVertexIndex = -1;
+
+    /** Coordinates of the closest vertex */
+    private Point3d closestVertexCoordinates = null;
+
+    /** Coordinates of the closest vertex (World coordinates) */  
+    private Point3d closestVertexCoordinatesVW = null;    
+
+    /* ===================   METHODS  ======================= */
+
+    /** 
+     * Constructor 
+     * @param intersectionInfo The IntersectionInfo this intersection is part of.
+     */
+    public PickIntersection (Transform3D localToVWorld,
+			     PickInfo.IntersectionInfo intersectionInfo) {
+
+	// Should check and throw NPE if the following is null. 
+	// localToVWorld can't be null.
+	l2vw = localToVWorld;
+	// intersectionInfo can't be null.
+	iInfo = intersectionInfo;
+	// geometry can't be null.
+	geometry = iInfo.getGeometry();
+
+	pointCoordinates = iInfo.getIntersectionPoint();
+	distance = iInfo.getDistance();
+	primitiveVertexIndices = iInfo.getVertexIndices();
+
+	if (geometry instanceof GeometryArray) {
+	    
+	    int vertexFormat = ((GeometryArray)geometry).getVertexFormat();
+	    hasColors = (0 != (vertexFormat &
+			       (GeometryArray.COLOR_3 | GeometryArray.COLOR_4)));
+	    hasNormals = (0 != (vertexFormat & GeometryArray.NORMALS));
+	    hasTexCoords = (0 != (vertexFormat &
+				  (GeometryArray.TEXTURE_COORDINATE_2 |
+				   GeometryArray.TEXTURE_COORDINATE_3)));
+	   
+	    if (geometry instanceof IndexedGeometryArray) {
+		geometryIsIndexed = true;
+	    }
+	}
+    }
+    
+    /** 
+     * Returns true if the geometry is indexed 
+     *
+     */
+    public boolean geometryIsIndexed() {
+	return geometryIsIndexed;
     }
 
+    /** 
+     * Get coordinates of closest vertex (local) 
+     * @return the coordinates of the vertex closest to the intersection point
+     *
+     */
+    public Point3d getClosestVertexCoordinates() {
+	// System.out.println("PI.closestVertexCoordinates " + closestVertexCoordinates);
+	GeometryArray geom = (GeometryArray) geometry;
+
+	if (closestVertexCoordinates == null) {
+	    int vertexIndex = getClosestVertexIndex();
+	    int vformat = geom.getVertexFormat();
+	    int val;
+	    
+	    int[] indices = getPrimitiveCoordinateIndices();
+	    if ((vformat & GeometryArray.BY_REFERENCE) == 0) {
+		closestVertexCoordinates = new Point3d();
+		geom.getCoordinate(indices[vertexIndex], closestVertexCoordinates);
+		// System.out.println("PI.closestVertexCoordinates " +
+// 				   closestVertexCoordinates + " vertexIndex " +
+// 				   vertexIndex);
+	    }
+	    else {
+		if ((vformat & GeometryArray.INTERLEAVED) == 0) {
+		    double[] doubleData = geom.getCoordRefDouble();
+		    // If data was set as float then ..
+		    if (doubleData == null) {
+			float[] floatData = geom.getCoordRefFloat();
+ 			if (floatData == null) {
+			    throw new UnsupportedOperationException("Deprecated : BY_REF - p3f and p3d");
+			}
+			else {
+			    val = indices[vertexIndex] * 3; // for x,y,z
+			    closestVertexCoordinates = new Point3d(floatData[val], 
+								   floatData[val+1], 
+								   floatData[val+2]);
+			}
+		    }
+		    else {
+			val = indices[vertexIndex] * 3; // for x,y,z
+			closestVertexCoordinates = new Point3d(doubleData[val], 
+							       doubleData[val+1], 
+							       doubleData[val+2]);
+		    }
+		}
+		else {
+		    float[] floatData = geom.getInterleavedVertices();
+		    int offset = getInterleavedVertexOffset(geom);
+		    int stride = offset + 3; // for the vertices .
+		    val = stride * indices[vertexIndex]+offset;
+		    closestVertexCoordinates = new Point3d(floatData[val], 
+							   floatData[val+1], 
+							   floatData[val+2]);
+		}
+	    }
+	}
+	
+	return closestVertexCoordinates;
+    }
 
     /**
-       Returns the color of the intersection point. Returns null if the geometry
-       does not contain colors.  If the geometry was defined with
-       GeometryArray.COLOR_3, the 'w' component of the color will initialized to 
-       1.0
-       @return color at the intersection point.  
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+     * Get coordinates of closest vertex (world) 
+     * @return the coordinates of the vertex closest to the intersection point
+     *
+     */
+    public Point3d getClosestVertexCoordinatesVW() {
+	if (closestVertexCoordinatesVW == null) {
+	    int vertexIndex = getClosestVertexIndex();
+	    Point3d[] coordinatesVW = getPrimitiveCoordinatesVW();
+	    closestVertexCoordinatesVW = coordinatesVW[vertexIndex];
+	}
+	return closestVertexCoordinatesVW;
+    }
 
-    */
-    public Color4f getPointColor() {
-	throw new UnsupportedOperationException();
+    /** 
+     * Get index of closest vertex 
+     * @return the index of the closest vertex
+     */
+    public int getClosestVertexIndex() { 
+	if (closestVertexIndex == -1) {
+	    double maxDist = Double.MAX_VALUE;
+	    double curDist = Double.MAX_VALUE;
+	    int closestIndex = -1;
+	    primitiveCoordinates = getPrimitiveCoordinates();
+
+	    assert(primitiveCoordinates != null);
+
+// 	    System.out.println("PI.getClosestVertexIndex : primitiveCoordinates.length " +
+// 			       primitiveCoordinates.length);
+	    
+	    for (int i=0;i<primitiveCoordinates.length;i++) {
+		curDist = pointCoordinates.distance (primitiveCoordinates[i]);
+		
+// 		System.out.println("pointCoordinates " + pointCoordinates);
+// 		System.out.println("primitiveCoordinates[" + i + "] " +
+// 				   primitiveCoordinates[i]);
+// 		System.out.println("curDist " + curDist);
+		
+		if (curDist < maxDist) {
+		    closestIndex = i;
+		    maxDist = curDist;
+		}
+	    }
+	    closestVertexIndex = closestIndex;
+	}
+	return closestVertexIndex;
+    }
+    
+    /** 
+     * Get the distance from the PickShape start point to the intersection point
+     * @return the distance to the intersection point, if available.
+     */
+    public double getDistance() {
+	return distance;
     }
 
 
     /**
-       Returns the coordinates of the intersection point (local coordinates),
-       if available.
-       @return coordinates of the intersection point
+     * Returns the color of the intersection point. Returns null if the geometry
+     * does not contain colors.  If the geometry was defined with
+     * GeometryArray.COLOR_3, the 'w' component of the color will initialized to 
+     * 1.0
+     * @return color at the intersection point.  
+     */
+    public Color4f getPointColor() {
+	if (hasColors && (pointColor == null)) {
+	    double[] weights = getInterpWeights();
+	    Color4f[] colors = getPrimitiveColors();
+	    pointColor = new Color4f();
+	    for (int i = 0; i < weights.length; i++) {
+		pointColor.x += (float) weights[i] * colors[i].x;
+		pointColor.y += (float) weights[i] * colors[i].y;
+		pointColor.z += (float) weights[i] * colors[i].z;
+		pointColor.w += (float) weights[i] * colors[i].w;
+	    }
+	}
+	return pointColor;
+    }
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
 
-    */
+    /**
+     * Returns the coordinates of the intersection point (local coordinates),
+     * if available.
+     * @return coordinates of the intersection point
+     */
     public Point3d getPointCoordinates() {
-	throw new UnsupportedOperationException();
+	return pointCoordinates;
     }
-
+    
     /**
-       Returns the coordinates of the intersection point (world coordinates), 
-       if available.
-       @return coordinates of the point
+     * Returns the coordinates of the intersection point (world coordinates), 
+     * if available.
+     * @return coordinates of the point
+     */
+    public Point3d getPointCoordinatesVW() {
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+	if (pointCoordinatesVW != null) {
+	    return pointCoordinatesVW;
+	}
 
-    */
-    public Point3d getPointCoordinatesVW() {
-	throw new UnsupportedOperationException();
+	pointCoordinatesVW = new Point3d();
+	
+	pointCoordinatesVW.x = pointCoordinates.x;
+	pointCoordinatesVW.y = pointCoordinates.y;
+	pointCoordinatesVW.z = pointCoordinates.z;
+
+	l2vw.transform(pointCoordinatesVW);
+	return pointCoordinatesVW;
     }
 
     /**
-       Returns the normal of the intersection point. Returns null if the geometry
-       does not contain normals.
-       @return normal at the intersection point.  
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
+     * Returns the normal of the intersection point. Returns null if the geometry
+     * does not contain normals.
+     * @return normal at the intersection point.
+     */
     public Vector3f getPointNormal() {
-	throw new UnsupportedOperationException();
+	if (hasNormals && (pointNormal == null)) {
+	    double[] weights = getInterpWeights();
+	    Vector3f[] normals = getPrimitiveNormals();
+	    pointNormal = new Vector3f();
+	    for (int i = 0; i < weights.length; i++) {
+		pointNormal.x += (float) weights[i] * normals[i].x;
+		pointNormal.y += (float) weights[i] * normals[i].y;
+		pointNormal.z += (float) weights[i] * normals[i].z;
+	    }
+	}
+	return pointNormal;
     }
 
     /**
-       Returns the texture coordinate of the intersection point at the specifed 
-       index in the specified texture coordinate set.
-       Returns null if the geometry
-       does not contain texture coordinates.  If the geometry was defined with
-       GeometryArray.TEXTURE_COORDINATE_3, the 'z' component of the texture
-       coordinate will initialized to 0.0
-       @return texture coordinate at the intersection point.  
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
+     * Returns the texture coordinate of the intersection point at the specifed 
+     * index in the specified texture coordinate set.
+     * Returns null if the geometry
+     * does not contain texture coordinates.  If the geometry was defined with
+     * GeometryArray.TEXTURE_COORDINATE_3, the 'z' component of the texture
+     * coordinate will initialized to 0.0
+     * @return texture coordinate at the intersection point.  
+     */
     public TexCoord3f getPointTextureCoordinate(int index) {
-	throw new UnsupportedOperationException();
+	if (hasTexCoords && (pointTexCoord == null)) {
+	    double[] weights = getInterpWeights();
+	    TexCoord3f[] texCoords = getPrimitiveTexCoords(index);
+	    pointTexCoord = new TexCoord3f();
+	    for (int i = 0; i < weights.length; i++) {
+		pointTexCoord.x += (float) weights[i] * texCoords[i].x;
+		pointTexCoord.y += (float) weights[i] * texCoords[i].y;
+		pointTexCoord.z += (float) weights[i] * texCoords[i].z;
+	    }
+	}
+	return pointTexCoord;
     }
 
     /** 
-	Get the color indices for the intersected primitive.  For a non-indexed
-	primitive, this will be the same as the primitive vertex indices
-	If the geometry array does not contain colors this will return null.
-	@return an array indices
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public int[] getPrimitiveColorIndices () {
-	throw new UnsupportedOperationException();
+     * Get the color indices for the intersected primitive.  For a non-indexed
+     * primitive, this will be the same as the primitive vertex indices
+     * If the geometry array does not contain colors this will return null.
+     * @return an array indices
+     */
+    public int[] getPrimitiveColorIndices() {
+	if (hasColors && (primitiveColorIndices == null)) {
+	    if (geometryIsIndexed()) {
+		primitiveColorIndices = 
+		    new int[primitiveVertexIndices.length];
+		for (int i = 0; i < primitiveVertexIndices.length; i++) {
+		    primitiveColorIndices[i] =  
+			((IndexedGeometryArray)(geometry)).getColorIndex(primitiveVertexIndices[i]);
+		}
+	    } else {
+		primitiveColorIndices = primitiveVertexIndices;
+	    }
+	}
+	return primitiveColorIndices;
     }
 
     /** 
-	Get the colors of the intersected primitive.  This will return null if
-	the primitive does not contain colors.  If the geometry was defined
-	using GeometryArray.COLOR_3, the 'w' value of the color will be set to 1.0.
-	@return an array of Point3d's for the primitive that was intersected
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public Color4f[] getPrimitiveColors () {
-	throw new UnsupportedOperationException();
+     * Get the colors of the intersected primitive.  This will return null if
+     * the primitive does not contain colors.  If the geometry was defined
+     * using GeometryArray.COLOR_3, the 'w' value of the color will be set to 1.0.
+     * @return an array of Point3d's for the primitive that was intersected
+     */
+    public Color4f[] getPrimitiveColors() {
+// 	System.out.println("PI.getPrimitiveColors " + primitiveColors);	
+	GeometryArray geom = (GeometryArray) geometry;
+
+	if (hasColors && (primitiveColors == null)) {
+	    primitiveColors = new Color4f[primitiveVertexIndices.length];
+	    int[] indices = getPrimitiveColorIndices();
+	    int vformat = geom.getVertexFormat();
+	    if ((vformat & GeometryArray.BY_REFERENCE) == 0) {
+		if ((vformat & GeometryArray.COLOR_4) == 
+		    GeometryArray.COLOR_4) {
+		    for (int i = 0; i < indices.length; i++) {
+			primitiveColors[i] = new Color4f();
+			geom.getColor(indices[i], primitiveColors[i]);
+		    }
+		} else {
+		    Color3f color = new Color3f();
+		    for (int i = 0; i < indices.length; i++) {
+			primitiveColors[i] = new Color4f();
+			geom.getColor(indices[i], color);
+			primitiveColors[i].x = color.x;
+			primitiveColors[i].y = color.y;
+			primitiveColors[i].z = color.z;
+			primitiveColors[i].w = 1.0f;
+		    }
+		}
+	    }
+	    else {
+		if ((vformat & GeometryArray.INTERLEAVED) == 0) {
+		    float[] floatData = geom.getColorRefFloat();
+		    // If data was set as float then ..
+		    if (floatData == null) {
+			byte[] byteData = geom.getColorRefByte();
+			if (byteData == null) {
+			    throw new UnsupportedOperationException("Deprecated : BY_REF - c3b and c3f");
+			}
+			else {
+			    // Could be color3 or color4
+			    int val;
+			    if ((vformat & GeometryArray.COLOR_4) == 
+				GeometryArray.COLOR_4) {
+				for (int i = 0; i < indices.length; i++) {
+				    val = indices[i] << 2; // for color4f
+				    primitiveColors[i] = new Color4f(byteData[val],
+								     byteData[val+1],
+								     byteData[val+2],
+								     byteData[val+3]);
+
+				}
+			    }
+			    else {
+				for (int i = 0; i < indices.length; i++) {
+				    val = indices[i] * 3; // for color3f
+				    primitiveColors[i] = new Color4f(byteData[val],
+								     byteData[val+1],
+								     byteData[val+2], 
+								     1.0f);
+
+				}
+			    }
+			}
+		    }
+		    else {
+			// Could be color3 or color4
+			int val;
+			if ((vformat & GeometryArray.COLOR_4) == 
+			    GeometryArray.COLOR_4) {
+			    for (int i = 0; i < indices.length; i++) {
+				val = indices[i] << 2; // for color4f
+				primitiveColors[i] = new Color4f(floatData[val],
+								 floatData[val+1],
+								 floatData[val+2],
+								 floatData[val+3]);
+			    }
+			}
+			else {
+			    for (int i = 0; i < indices.length; i++) {
+				val = indices[i] * 3; // for color3f
+				primitiveColors[i] = new Color4f(floatData[val],
+								 floatData[val+1],
+								 floatData[val+2],
+								 1.0f);
+
+			    }
+			}
+		    }
+
+		}
+		else {
+		    float[] floatData = geom.getInterleavedVertices();
+		    int offset = getInterleavedColorOffset(geom);
+		    int stride = getInterleavedStride(geom); 
+		    for (int i = 0; i < indices.length; i++) {
+			int val = stride * indices[i]+offset;
+			if ((vformat & GeometryArray.COLOR_4) == 
+			    GeometryArray.COLOR_4) {
+			    primitiveColors[i] = new Color4f(floatData[val],
+							     floatData[val+1],
+							     floatData[val+2],
+							     floatData[val+3]);
+			}
+			else {
+			    primitiveColors[i] = new Color4f(floatData[val],
+							     floatData[val+1],
+							     floatData[val+2],
+							     1.0f);
+			}
+		    }
+		}
+	    }
+	}
+	return primitiveColors;
     }
 
     /** 
-	Get the coordinates indices for the intersected primitive.  For a non-indexed
-	primitive, this will be the same as the primitive vertex indices
-	@return an array indices
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public int[] getPrimitiveCoordinateIndices () {
-	throw new UnsupportedOperationException();
+     * Get the coordinates indices for the intersected primitive.  For a non-indexed
+     * primitive, this will be the same as the primitive vertex indices
+     * @return an array indices
+     */
+    public int[] getPrimitiveCoordinateIndices() {
+	if (primitiveCoordinateIndices == null) {
+	    if (geometryIsIndexed()) {
+		primitiveCoordinateIndices = 
+		    new int[primitiveVertexIndices.length];
+		for (int i = 0; i < primitiveVertexIndices.length; i++) {
+		    primitiveCoordinateIndices[i] =  
+			((IndexedGeometryArray)(geometry)).getCoordinateIndex(primitiveVertexIndices[i]);
+		}
+	    } else {
+		primitiveCoordinateIndices = primitiveVertexIndices;
+	    }
+	}
+	return primitiveCoordinateIndices;
     }
 
     /** 
-	Get the local coordinates intersected primitive 
-	@return an array of Point3d's for the primitive that was intersected
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public Point3d[] getPrimitiveCoordinates () {
-	throw new UnsupportedOperationException();    
+     * Get the local coordinates intersected primitive 
+     * @return an array of Point3d's for the primitive that was intersected
+     */
+    public Point3d[] getPrimitiveCoordinates() {
+// 	System.out.println("PI.getPrimitiveCoordinates " + primitiveCoordinates);	
+	GeometryArray geom = (GeometryArray) geometry;
+
+	if (primitiveCoordinates == null) {
+	    primitiveCoordinates = new Point3d[primitiveVertexIndices.length];
+	    int[] indices = getPrimitiveCoordinateIndices();
+	    int vformat = geom.getVertexFormat();
+	    int val;
+	    
+// 	    System.out.println("---- indices.length - " + indices.length);
+	    if ((vformat & GeometryArray.BY_REFERENCE) == 0) {
+		for (int i = 0; i < indices.length; i++) {
+		    primitiveCoordinates[i] = new Point3d();
+		    // System.out.println("PickIntersection : indices["+i+"] = " + indices[i]);
+		    geom.getCoordinate(indices[i], primitiveCoordinates[i]);
+		}
+	    }
+	    else {
+		if ((vformat & GeometryArray.INTERLEAVED) == 0) {
+		    double[] doubleData = geom.getCoordRefDouble();
+		    // If data was set as float then ..
+		    if (doubleData == null) {
+			float[] floatData = geom.getCoordRefFloat();
+			if (floatData == null) {
+			    throw new UnsupportedOperationException("Deprecated : BY_REF - c3f and c3d");		
+			}
+			else {
+			    for (int i = 0; i < indices.length; i++) {
+				val = indices[i] * 3;
+				primitiveCoordinates[i] = new Point3d(floatData[val], 
+								      floatData[val+1], 
+								      floatData[val+2]);
+			    }
+			}
+		    }
+		    else {
+			for (int i = 0; i < indices.length; i++) {
+			    val = indices[i] * 3;
+			    primitiveCoordinates[i] = new Point3d(doubleData[val], 
+								  doubleData[val+1], 
+								  doubleData[val+2]);
+			}			
+		    }
+		}
+		else {
+		    float[] floatData = geom.getInterleavedVertices();
+		    int offset = getInterleavedVertexOffset(geom);
+		    int stride = offset + 3; // for the vertices .
+		    for (int i = 0; i < indices.length; i++) {
+			val = stride * indices[i]+offset;
+			primitiveCoordinates[i] = new Point3d(floatData[val], 
+							      floatData[val+1], 
+							      floatData[val+2]);
+		    }
+		}
+	    }
+
+	}
+	return primitiveCoordinates;
     }    
 
     /** 
-	Get VWorld coordinates of the intersected primitive 
-	@return an array of Point3d's for the primitive that was picked
+     * Get VWorld coordinates of the intersected primitive 
+     * @return an array of Point3d's for the primitive that was picked
+     */
+    public Point3d[] getPrimitiveCoordinatesVW() {
+
+// 	System.out.println("PI.getPrimitiveCoordinatesVW " + primitiveCoordinatesVW);	
+
+	if (primitiveCoordinatesVW == null) {
+	    // We need to call getPrimitiveCoordinates first.
+	    Point3d[] coords = getPrimitiveCoordinates();
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+	    primitiveCoordinatesVW = new Point3d[coords.length];
+	    for (int i = 0; i < coords.length; i++) {
+		primitiveCoordinatesVW[i] = new Point3d();
 
-    */
-    public Point3d[] getPrimitiveCoordinatesVW () {
-	throw new UnsupportedOperationException();
+		primitiveCoordinatesVW[i].x = coords[i].x;
+		primitiveCoordinatesVW[i].y = coords[i].y;
+		primitiveCoordinatesVW[i].z = coords[i].z;
+
+		l2vw.transform(primitiveCoordinatesVW[i]);
+	    }
+	}
+	return primitiveCoordinatesVW;
     }
     
     /** 
-	Get the normal indices for the intersected primitive.  For a non-indexed
-	primitive, this will be the same as the primitive vertex indices
-	If the geometry array does not contain normals this will return null
-	@return an array indices
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public int[] getPrimitiveNormalIndices () {
-	throw new UnsupportedOperationException();
+     * Get the normal indices for the intersected primitive.  For a non-indexed
+     * primitive, this will be the same as the primitive vertex indices
+     * If the geometry array does not contain normals this will return null
+     *	@return an array indices
+     */
+    public int[] getPrimitiveNormalIndices() {
+	if (hasNormals && (primitiveNormalIndices == null)) {
+	    if (geometryIsIndexed()) {
+		primitiveNormalIndices = 
+		    new int[primitiveVertexIndices.length];
+		for (int i = 0; i < primitiveVertexIndices.length; i++) {
+		    primitiveNormalIndices[i] = 
+			((IndexedGeometryArray)(geometry)).getNormalIndex(primitiveVertexIndices[i]);
+		}
+	    } else {
+		primitiveNormalIndices = primitiveVertexIndices;
+	    }
+	}
+	return primitiveNormalIndices;
     }
 
     /** 
-	Get the normals of the intersected primitive.  This will return null if
-	the primitive does not contain normals.
-	@return an array of Point3d's for the primitive that was intersected
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public Vector3f[] getPrimitiveNormals () {
-	throw new UnsupportedOperationException();
+     * Get the normals of the intersected primitive.  This will return null if
+     * the primitive does not contain normals.
+     * @return an array of Point3d's for the primitive that was intersected
+     */
+    public Vector3f[] getPrimitiveNormals() {
+// 	System.out.println("PI.getPrimitiveNormals " + primitiveNormals);	
+	GeometryArray geom = (GeometryArray) geometry;
+
+	if (hasNormals && (primitiveNormals == null)) {
+	    primitiveNormals = new Vector3f[primitiveVertexIndices.length];
+	    int[] indices = getPrimitiveNormalIndices();
+	    int vformat = geom.getVertexFormat();
+	    int val;
+
+	    if ((vformat & GeometryArray.BY_REFERENCE) == 0) {
+		for (int i = 0; i < indices.length; i++) {
+		    primitiveNormals[i] = new Vector3f();
+		    geom.getNormal(indices[i], primitiveNormals[i]);
+		}
+	    }
+	    else {
+		if ((vformat & GeometryArray.INTERLEAVED) == 0) {
+		    float[] floatNormals = geom.getNormalRefFloat();
+		    if (floatNormals != null) {
+			for (int i = 0; i < indices.length; i++) {
+			    val = indices[i] * 3;
+			    primitiveNormals[i] = new Vector3f(floatNormals[val],
+							       floatNormals[val+1],
+							       floatNormals[val+2]);
+			}
+		    }
+		    else {
+			throw new UnsupportedOperationException("Deprecated : BY_REF - n3f");
+		    }
+		}
+		else {
+		    float[] floatData = geom.getInterleavedVertices();
+		    int offset = getInterleavedColorOffset(geom);
+		    int stride = getInterleavedStride(geom);
+		    for (int i = 0; i < indices.length; i++) {
+			val = stride * indices[i]+offset;
+			primitiveNormals[i] = new Vector3f(floatData[val],floatData[val+1],floatData[val+2]);
+
+		    }
+		}
+	    }
+	}
+	return primitiveNormals;
     }
 
 
     /** 
-	Get the texture coordinate indices for the intersected primitive at the specifed 
-	index in the specified texture coordinate set.  For a   non-indexed
-	primitive, this will be the same as the primitive vertex indices
-	If the geometry array does not contain texture coordinates, this will 
-	return null.
-	@return an array indices
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
-    public int[] getPrimitiveTexCoordIndices (int index) {
-	throw new UnsupportedOperationException();
+     * Get the texture coordinate indices for the intersected primitive at the specifed 
+     * index in the specified texture coordinate set.  For a   non-indexed
+     * primitive, this will be the same as the primitive vertex indices
+     * If the geometry array does not contain texture coordinates, this will 
+     * return null.
+     * @return an array indices
+     */
+    public int[] getPrimitiveTexCoordIndices(int index) {
+	if (hasTexCoords && (primitiveTexCoordIndices == null)) {
+	    if (geometryIsIndexed()) {
+		primitiveTexCoordIndices = 
+		    new int[primitiveVertexIndices.length];
+		for (int i = 0; i < primitiveVertexIndices.length; i++) {
+		    primitiveTexCoordIndices[i] =  
+			((IndexedGeometryArray)(geometry)).getTextureCoordinateIndex(index, primitiveVertexIndices[i]);
+		}
+	    } else {
+		primitiveTexCoordIndices = primitiveVertexIndices;
+	    }
+	}
+	return primitiveTexCoordIndices;
     }
 
     /** 
-	Get the texture coordinates of the intersected primitive at the specifed 
-	index in the specified texture coordinate set.
-	null if the primitive does not contain texture coordinates.  
-	If the geometry was defined
-	using GeometryArray.TEXTURE_COORDINATE_2, the 'z' value of the texture
-	coordinate will be set to 0.0.
-	@return an array of TexCoord3f's for the primitive that was intersected
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
-
-    */
+     * Get the texture coordinates of the intersected primitive at the specifed 
+     * index in the specified texture coordinate set.
+     * null if the primitive does not contain texture coordinates.  
+     * If the geometry was defined
+     * using GeometryArray.TEXTURE_COORDINATE_2, the 'z' value of the texture
+     * coordinate will be set to 0.0.
+     * @return an array of TexCoord3f's for the primitive that was intersected
+     */
     public TexCoord3f[] getPrimitiveTexCoords (int index) {
-	throw new UnsupportedOperationException();
+// 	System.out.println("PI.getPrimitiveTexCoords " + primitiveTexCoords);	
+	GeometryArray geom = (GeometryArray) geometry;
+
+	if (primitiveTexCoords == null) {
+	    primitiveTexCoords = new TexCoord3f[primitiveVertexIndices.length];
+	    int[] indices = getPrimitiveTexCoordIndices(index);
+	    int vformat = geom.getVertexFormat();
+	    if ((vformat & GeometryArray.BY_REFERENCE) == 0) {
+		for (int i = 0; i < indices.length; i++) {
+		    primitiveTexCoords[i] = new TexCoord3f();
+		    geom.getTextureCoordinate(index, indices[i], primitiveTexCoords[i]);
+		}
+	    }
+	    else {
+		if ((vformat & GeometryArray.INTERLEAVED) == 0) {
+		    int val;
+		    float[] floatTexCoords = geom.getTexCoordRefFloat(index);
+		    if (floatTexCoords != null) {
+			if ((vformat & GeometryArray.TEXTURE_COORDINATE_2) == GeometryArray.TEXTURE_COORDINATE_2) {
+			    for (int i = 0; i < indices.length; i++) {
+				val = indices[i] << 1; // t2f
+				primitiveTexCoords[i] = new TexCoord3f(floatTexCoords[val],
+								       floatTexCoords[val+1],
+								       0.0f);
+			    }
+			}
+			else {
+			    for (int i = 0; i < indices.length; i++) {
+				val = indices[i] * 3; // t3f
+				primitiveTexCoords[i] = new TexCoord3f(floatTexCoords[val],
+								       floatTexCoords[val+1],
+								       floatTexCoords[val+2]);
+			    }
+			}
+		    }
+		    else {
+			throw new UnsupportedOperationException("Deprecated : BY_REF - t2f and t3f");
+		    }
+		}
+		else {
+		    float[] floatData = geom.getInterleavedVertices();
+		    int stride = getInterleavedStride(geom);
+		    int offset;
+		    // Get the correct tex coord set
+		    if ((vformat & GeometryArray.TEXTURE_COORDINATE_2) ==
+			GeometryArray.TEXTURE_COORDINATE_2) {
+			offset = index << 1;
+		    }
+		    else {
+			offset = index * 3;
+		    }
+		    for (int i = 0; i < indices.length; i++) {
+			int val = stride * indices[i];
+			if ((vformat & GeometryArray.TEXTURE_COORDINATE_2) == 
+			    GeometryArray.TEXTURE_COORDINATE_2) {
+			    primitiveTexCoords[i] = 
+				new TexCoord3f(floatData[val+offset],
+					       floatData[val+1+offset],
+					       0.0f);
+			}
+			else {
+			    primitiveTexCoords[i] = 
+				new TexCoord3f(floatData[val+offset],
+					       floatData[val+1+offset],
+					       floatData[val+2+offset]);
+			}
+		    }
+		}
+	    }
+	}
+	return primitiveTexCoords;
     }
 
     /** 
-	Get vertex indices of the intersected primitive
-	@return an array which contains the list of indices
-
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+     * Get vertex indices of the intersected primitive
+     * @return an array which contains the list of indices
+     */
+    public int [] getPrimitiveVertexIndices() {
+	return primitiveVertexIndices;
+    }
 
-    */
-    public int [] getPrimitiveVertexIndices () {
-	throw new UnsupportedOperationException();
+    /**
+     * Gets the IntersectionInfo this intersection is part of.
+     */
+    public PickInfo.IntersectionInfo getIntersectionInfo() {
+	return iInfo;
     }
 
     /**
-       String representation of this object
+     * String representation of this object
+     */ 
+    public String toString() {
+	String rt = new String ("PickIntersection: ");
+	rt += " IntersectionInfo = "+ iInfo + "\n";
+	rt += " geometry = "+ geometry + "\n";
+	if (distance != -1) rt += " dist:"+distance + "\n";
+	if (pointCoordinates != null) rt += " pt:" + pointCoordinates + "\n";
+	if (pointCoordinatesVW != null) rt += " ptVW:" + pointCoordinatesVW + "\n";
+
+	if (primitiveCoordinateIndices != null) {
+	    rt += " prim coordinate ind:" + "\n";
+	    for (int i=0;i<primitiveCoordinateIndices.length;i++) {
+		rt += " "+primitiveCoordinateIndices[i] + "\n";
+	    }
+	}
+
+	if (primitiveColorIndices != null) {
+	    rt += " prim color ind:" + "\n";
+	    for (int i=0;i<primitiveColorIndices.length;i++) {
+		rt += " "+primitiveColorIndices[i] + "\n";
+	    }
+	}
+
+	if (primitiveNormalIndices != null) {
+	    rt += " prim normal ind:" + "\n";
+	    for (int i=0;i<primitiveNormalIndices.length;i++) {
+		rt += " "+primitiveNormalIndices[i] + "\n";
+	    }
+	}
+
+	if (primitiveTexCoordIndices != null) {
+	    rt += " prim texture ind:" + "\n";
+	    for (int i=0;i<primitiveTexCoordIndices.length;i++) {
+		rt += " "+primitiveTexCoordIndices[i] + "\n";
+	    }
+	}
+    
+	if (closestVertexCoordinates != null) {
+	    rt += " clos. vert:" + closestVertexCoordinates + "\n";
+	}
+
+	if (closestVertexCoordinatesVW != null) {
+	    rt += " clos. vert:" + closestVertexCoordinatesVW + "\n";
+	}
+
+	if (closestVertexIndex != -1) {
+	    rt += " clos. vert. ind.:" + closestVertexIndex + "\n";
+	}
+	return rt;
+    }
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
 
-    */
-    public String toString () {
-	throw new UnsupportedOperationException();
-    }
 
+    /******************** Helper methods ***************************************/
 
-    /**
-       Gets the IntersectionInfo this intersection is part of.
+    int getInterleavedVertexOffset(GeometryArray geo) {
+	int offset = 0;
+	int vformat = geo.getVertexFormat();
+	if ((vformat & GeometryArray.COLOR_3) == GeometryArray.COLOR_3) {
+	    offset += 3;
+	} else if ((vformat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4){
+	    offset += 4;
+	}
+	if ((vformat & GeometryArray.NORMALS) != 0)
+	    offset += 3;
+	if ((vformat & GeometryArray.TEXTURE_COORDINATE_2) == GeometryArray.TEXTURE_COORDINATE_2) {
+	    offset += 2 *  geo.getTexCoordSetCount();
+	}
+	else if ((vformat & GeometryArray.TEXTURE_COORDINATE_3) == GeometryArray.TEXTURE_COORDINATE_3) {
+	    offset += 3 * geo.getTexCoordSetCount();
+	}
 
-    * This method is currently not supported.
-    * @exception UnsupportedOperationException this method is not supported
+	return offset;
+    }
 
-    */
-    public PickInfo.IntersectionInfo getIntersectionInfo() {
-	throw new UnsupportedOperationException();
+    int getInterleavedStride(GeometryArray geo) {
+	int offset = 3; // Add 3 for vertices
+	int vformat = geo.getVertexFormat();
+	if ((vformat & GeometryArray.COLOR_3) == GeometryArray.COLOR_3) {
+	    offset += 3;
+	} else if ((vformat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4){
+	    offset += 4;
+	}
+	if ((vformat & GeometryArray.NORMALS) != 0)
+	    offset += 3;
+	if ((vformat & GeometryArray.TEXTURE_COORDINATE_2) == GeometryArray.TEXTURE_COORDINATE_2) {
+	    offset += 2 * geo.getTexCoordSetCount();
+	}
+	else if ((vformat & GeometryArray.TEXTURE_COORDINATE_3) == GeometryArray.TEXTURE_COORDINATE_3) {
+	    offset += 3 * geo.getTexCoordSetCount();
+	}
+	
+	return offset;
     }
 
-    
-} // PickIntersection
+    int getInterleavedColorOffset(GeometryArray geo) {
+	int offset = 0;
+	int vformat = geo.getVertexFormat();
+	if ((vformat & GeometryArray.TEXTURE_COORDINATE_2) == GeometryArray.TEXTURE_COORDINATE_2) {
+	    offset += 2 * geo.getTexCoordSetCount();
+	}
+	else if ((vformat & GeometryArray.TEXTURE_COORDINATE_3) == GeometryArray.TEXTURE_COORDINATE_3) {
+	    offset += 3 * geo.getTexCoordSetCount();
+	}
+
+	return offset;
+    }
 
 
+    /* ================================================================== */
+    /*      Utility code for interpolating intersection point data        */
+    /* ================================================================== */
 
+    /* absolute value */
+    double 
+    abs(double value) {
+	if (value < 0.0) {
+	    return -value;
+	} else {
+	    return value;
+	}
+    }
+
+    /* return the axis corresponding to the largest component of delta */
+    int 
+    maxAxis(Vector3d delta) {
+	int axis = X_AXIS;
+	double max = abs(delta.x);
+	if (abs(delta.y) > max) {
+	    axis = Y_AXIS;
+	    max = abs(delta.y);
+	}
+	if (abs(delta.z) > max) {
+	    axis = Z_AXIS;
+	}
+	return axis;
+    }
 
+    /* Triangle interpolation. Basic idea:  
+     * Map the verticies of the triangle to the form:
+     *
+     * L--------R
+     *  \      /
+     * IL+--P-+IR
+     *    \  /
+     *    Base
+     *
+       where P is the intersection point Base, L and R and the triangle
+       points.  IL and IR are the projections if P along the Base-L and Base-R
+       edges using an axis:
+
+       IL =  leftFactor * L + (1- leftFactor) * Base
+       IR = rightFactor * R + (1-rightFactor) * Base
+
+       then find the interp factor, midFactor, for P between IL and IR.  If 
+       this is outside the range 0->1 then we have the wrong triangle of a 
+       quad and we return false.  
+    
+       Else, the weighting is:
+
+       IP = midFactor * IL + (1 - midFactor) * IR;
+
+       Solving for weights for the formula:
+       IP = BaseWeight * Base + LeftWeight * L + RightWeight * R;
+       We get:
+       BaseWeight = 1 - midFactor * leftFactor 
+       - rightFactor + midFactor * rightFactor;
+       LeftWeight = midFactor * leftFactor;
+       RightWeight = righFactor - midFactor * rightFactor;
+       As a check, note that the sum of the weights is 1.0.
+       */
+
+    boolean
+    interpTriangle(int index0, int index1, int index2, Point3d[] coords, 
+		   Point3d intPt) {
+
+	// find the longest edge, we'll use that to pick the axis */
+	Vector3d delta0 = new Vector3d();
+	Vector3d delta1 = new Vector3d();
+	Vector3d delta2 = new Vector3d();
+	delta0.sub(coords[index1], coords[index0]);
+	delta1.sub(coords[index2], coords[index0]);
+	delta2.sub(coords[index2], coords[index1]);
+	double len0 = delta0.lengthSquared();
+	double len1 = delta1.lengthSquared();
+	double len2 = delta2.lengthSquared();
+	Vector3d longest = delta0;
+	double maxLen = len0;
+	if (len1 > maxLen) {
+	    longest = delta1;
+	    maxLen = len1;
+	}
+	if (len2 > maxLen) {
+	    longest = delta2;
+	}
+	int mainAxis = maxAxis(longest);
+
+	/*
+	  System.out.println("index0 = " + index0 + " index1 = " + index1 +
+	  " index2 = " + index2);
+	  
+	  System.out.println("coords[index0] = " + coords[index0]);
+	  System.out.println("coords[index1] = " + coords[index1]);
+	  System.out.println("coords[index2] = " + coords[index2]);
+	  System.out.println("intPt = " + intPt);
+	  
+	  System.out.println("delta0 = " + delta0 + " len0 " + len0);
+	  System.out.println("delta1 = " + delta1 + " len1 " + len1);
+	  System.out.println("delta2 = " + delta2 + " len2 " + len2);
+	  */
+	
+	/* now project the intersection point along the axis onto the edges */
+	double[] factor = new double[3]; 
+	/* the factor is for the projection opposide the vertex 0 = 1->2, etc*/
+	factor[0] = 
+	    getInterpFactorForBase(intPt, coords[index1], coords[index2], mainAxis);
+	factor[1] = 
+	    getInterpFactorForBase(intPt, coords[index2], coords[index0], mainAxis);
+	factor[2] = 
+	    getInterpFactorForBase(intPt, coords[index0], coords[index1], mainAxis);
+	
+	if (debug) {
+	    System.out.println("intPt  = " + intPt);
+	    switch(mainAxis) {
+	    case X_AXIS:
+		System.out.println("mainAxis = X_AXIS");
+		break;
+	    case Y_AXIS:
+		System.out.println("mainAxis = Y_AXIS");
+		break;
+	    case Z_AXIS:
+		System.out.println("mainAxis = Z_AXIS");
+		break;
+	    }
+	    System.out.println("factor[0] =  " + factor[0]);
+	    System.out.println("factor[1] =  " + factor[1]);
+	    System.out.println("factor[2] =  " + factor[2]);
+	}
+
+	/* Find the factor that is out of range, it will tell us which
+	 * vertex to use for base
+	 */
+	int base, left, right;
+	double leftFactor, rightFactor;
+	if ((factor[0] < 0.0) || (factor[0] > 1.0)) {
+	    base  = index0;
+	    right = index1;
+	    left  = index2;
+	    rightFactor = factor[2];
+	    leftFactor  = 1.0 - factor[1];
+	    if (debug) {
+		System.out.println("base 0, rightFactor = " + rightFactor +
+				   " leftFactor = " + leftFactor);
+	    }
+	} else if ((factor[1] < 0.0) || (factor[1] > 1.0)) {
+	    base  = index1;
+	    right = index2;
+	    left  = index0;
+	    rightFactor = factor[0];
+	    leftFactor  = 1.0 - factor[2];
+	    if (debug) {
+		System.out.println("base 1, rightFactor = " + rightFactor +
+				   " leftFactor = " + leftFactor);
+	    }
+	} else {
+	    base  = index2;
+	    right = index0;
+	    left  = index1;
+	    rightFactor = factor[1];
+	    leftFactor  = 1.0 - factor[0];
+	    if (debug) {
+		System.out.println("base 2, rightFactor = " + rightFactor +
+				   " leftFactor = " + leftFactor);
+	    }
+	}
+	if (debug) {
+	    System.out.println("base  = " + coords[base]);
+	    System.out.println("left  = " + coords[left]);
+	    System.out.println("right = " + coords[right]);
+	}
+	/* find iLeft and iRight */
+	Point3d iLeft = new Point3d(leftFactor * coords[left].x +
+				    (1.0-leftFactor)*coords[base].x,
+				    leftFactor * coords[left].y +
+				    (1.0-leftFactor)*coords[base].y,
+				    leftFactor * coords[left].z +
+				    (1.0-leftFactor)*coords[base].z);
+
+	Point3d iRight = new Point3d(rightFactor * coords[right].x +
+				     (1.0-rightFactor)*coords[base].x,
+				     rightFactor * coords[right].y +
+				     (1.0-rightFactor)*coords[base].y,
+				     rightFactor * coords[right].z +
+				     (1.0-rightFactor)*coords[base].z);
+
+	if (debug) {
+	    System.out.println("iLeft  = " + iLeft);
+	    System.out.println("iRight  = " + iRight);
+	}
+
+	/* now find an axis and solve for midFactor */
+	delta0.sub(iLeft, iRight);
+	int midAxis = maxAxis(delta0);
+	double midFactor = getInterpFactor(intPt, iRight, iLeft, midAxis);
+
+	if (debug) {
+	    switch(midAxis) {
+	    case X_AXIS:
+		System.out.println("midAxis = X_AXIS");
+		break;
+	    case Y_AXIS:
+		System.out.println("midAxis = Y_AXIS");
+		break;
+	    case Z_AXIS:
+		System.out.println("midAxis = Z_AXIS");
+		break;
+	    }
+	    System.out.println("midFactor = " + midFactor);
+	}
+
+	if (midFactor < 0.0) {
+	    // System.out.println("midFactor = " + midFactor);
+	    if ((midFactor + TOL) >= 0.0) {
+		// System.out.println("In Tol case : midFactor = " + midFactor);
+		midFactor = 0.0;
+	    }
+	    else {
+		/* int point is outside triangle */
+		return false;
+	    }
+	}
+	else if (midFactor > 1.0) {
+	    // System.out.println("midFactor = " + midFactor);
+	    if ((midFactor-TOL) <= 1.0) {
+		// System.out.println("In Tol case : midFactor = " + midFactor);
+		midFactor = 1.0;
+	    }
+	    else {
+		/* int point is outside triangle */
+		return false;
+	    }
+	}
+
+	// Assign the weights
+	interpWeights[base]  = 1.0 - midFactor * leftFactor -
+	    rightFactor + midFactor * rightFactor;
+	interpWeights[left]  = midFactor * leftFactor;
+	interpWeights[right] = rightFactor - midFactor * rightFactor;
+	return true;
 
+    }
 
+    /* Get the interpolation weights for each of the verticies of the 
+     * primitive.
+     */
+    double[] getInterpWeights() {
+
+	Point3d 	pt = getPointCoordinates();
+	Point3d[] 	coordinates = getPrimitiveCoordinates();
+	double 		factor;
+	int		axis;
+
+	if (interpWeights != null) {
+	    return interpWeights;
+	}
+
+	interpWeights = new double[coordinates.length];
+
+	// Interpolate
+	switch (coordinates.length) {
+	case 1:
+	    // Nothing to interpolate
+	    interpWeights[0] = 1.0;
+	    break;
+	case 2: // edge
+	    Vector3d delta = new Vector3d();
+	    delta.sub (coordinates[1], coordinates[0]);
+	    axis = maxAxis(delta);
+	    factor = getInterpFactor (pt, coordinates[1], coordinates[0], axis);
+	    interpWeights[0] = factor;
+	    interpWeights[1] = 1.0 - factor;
+	    break;
+	case 3: // triangle
+	    if (!interpTriangle(0, 1, 2, coordinates, pt)) {
+		throw new RuntimeException ("Interp point outside triangle");
+	    } 
+	    break;
+	case 4: // quad
+	    if (!interpTriangle(0, 1, 2, coordinates, pt)) {
+		if (!interpTriangle(0, 2, 3, coordinates, pt)) {
+		    throw new RuntimeException ("Interp point outside quad");
+		}
+	    }
+	    break;
+	default:
+	    throw new RuntimeException ("Unexpected number of points.");
+	}
+	return interpWeights;
+    }
 
+    /** 
+      Calculate the interpolation factor for point p by projecting it along
+      an axis (x,y,z) onto the edge between p1 and p2.  If the result is 
+      in the 0->1 range, point is between p1 and p2 (0 = point is at p1, 
+      1 => point is at p2).
+      */
+    private static float getInterpFactor (Point3d p, Point3d p1, Point3d p2,
+					  int axis) {
+	float t;
+	switch (axis) {
+	case X_AXIS:
+	    if (p1.x == p2.x)
+		//t = Float.MAX_VALUE; // TODO: should be 0?
+		t = 0.0f;
+	    else
+		t = (float) ((p1.x - p.x) / (p1.x - p2.x));
+	    break;
+	case Y_AXIS:
+	    if (p1.y == p2.y)
+		// t = Float.MAX_VALUE;
+		t = 0.0f;
+	    else
+		t = (float) ((p1.y - p.y) / (p1.y - p2.y));
+	    break;
+	case Z_AXIS:
+	    if (p1.z == p2.z)
+		// t = Float.MAX_VALUE;
+		t = 0.0f;
+	    else
+		t = (float)((p1.z - p.z) / (p1.z - p2.z));
+	    break;
+	default:
+	    throw new RuntimeException ("invalid axis parameter "+axis+" (must be 0-2)"); 
+	}
+	return t;
+    }
 
+    /** 
+      Calculate the interpolation factor for point p by projecting it along
+      an axis (x,y,z) onto the edge between p1 and p2.  If the result is 
+      in the 0->1 range, point is between p1 and p2 (0 = point is at p1, 
+      1 => point is at p2).
+      return MAX_VALUE if component of vertices are the same.
+      */
+    private static float getInterpFactorForBase (Point3d p, Point3d p1, Point3d p2,
+						 int axis) {
+	float t;
+	switch (axis) {
+	case X_AXIS:
+	    if (p1.x == p2.x)
+		t = Float.MAX_VALUE;
+	    else
+		t = (float) ((p1.x - p.x) / (p1.x - p2.x));
+	    break;
+	case Y_AXIS:
+	    if (p1.y == p2.y)
+		t = Float.MAX_VALUE;
+	    else
+		t = (float) ((p1.y - p.y) / (p1.y - p2.y));
+	    break;
+	case Z_AXIS:
+	    if (p1.z == p2.z)
+		t = Float.MAX_VALUE;
+	    else
+		t = (float)((p1.z - p.z) / (p1.z - p2.z));
+	    break;
+	default:
+	    throw new RuntimeException ("invalid axis parameter "+axis+" (must be 0-2)"); 
+	}
+	return t;
+    }
 
+    
+} // PickIntersection