pickresult.java

JAVA3D矩陈的相关类

	    break;
	}
	if (intersect) {
	    PickIntersection newpi = new PickIntersection(this, pi.geom);
	    newpi.iGeom = pi.iGeom;
	    newpi.setDistance(pi.distance);
	    newpi.setPointCoordinatesVW(pi.getPointCoordinatesVW());
	    
	    // Set PickIntersection parameters
	    newpi.setGeomIndex(geomIndex);
	    newpi.setVertexIndices (vertidx);
	    newpi.setPrimitiveCoordinatesVW(point);
	    intersections.add (newpi);
	    return true;
	}
	return false;
    } 

    boolean intersectLine(int[] vertidx, int[] coordidx, int geomIndex, 
			  Point3d[] pnts, PickIntersection pi) {
	
	Point3d[] linePts = new Point3d[2];
	linePts[0] = pnts[coordidx[0]];
	linePts[1] = pnts[coordidx[1]];
	
	boolean intersect = false;
	switch(pickShapeType) {
	case PICK_SHAPE_RAY:
	    intersect = intersectLineAndRay(linePts[0], linePts[1], 
					    pickShapeStart, pickShapeDir, pi);
	    break;
	case PICK_SHAPE_SEGMENT:
	    if (intersectLineAndRay(linePts[0], linePts[1], pickShapeStart, 
				    pickShapeDir, pi)) {
		if (pi.getDistance() <= 1.0) {
		    intersect = true;
		}
	    }
	    break;
	    /* case PICK_SHAPE_POINT:
	       dir.x = linePts[1].x - linePts[0].x;       
	       dir.y = linePts[1].y - linePts[0].y;       
	       dir.z = linePts[1].z - linePts[0].z;       
	       if (intersectPntAndRay(((PickPoint)pickShape).location, 
	       pnts[0], dir, dist)) {
	       if(dist[0] <= 1.0) {
	       intersect = true;
	       }
	       }
	       break;
	       */
	case PICK_SHAPE_BOUNDING_BOX:
	    intersect = intersectBoundingBox(linePts,
					     (BoundingBox)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_BOUNDING_SPHERE:
	    intersect = intersectBoundingSphere(linePts, 
						(BoundingSphere)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_BOUNDING_POLYTOPE:
	    intersect = intersectBoundingPolytope(linePts,
						  (BoundingPolytope)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;    
	case PICK_SHAPE_CYLINDER:
	    intersect = intersectCylinder (linePts, (PickCylinder)pickShape,pi);
	    break;
	case PICK_SHAPE_CONE:
	    intersect = intersectCone (linePts, (PickCone) pickShape, pi);
	    break;
	}
	if (intersect) {
	    PickIntersection newpi = new PickIntersection(this, pi.geom);
	    newpi.iGeom = pi.iGeom;
	    newpi.setDistance(pi.distance);
	    newpi.setPointCoordinatesVW(pi.getPointCoordinatesVW());

	    // Set PickIntersection parameters
	    newpi.setGeomIndex(geomIndex);
	    newpi.setVertexIndices (vertidx);
	    newpi.setPrimitiveCoordinatesVW(linePts);
	    intersections.add (newpi);
	    return true;
	}
	return false;
    }

    boolean intersectTri(int[] vertidx, int[] coordidx, int geomIndex, 
			 Point3d[] pnts, PickIntersection pi) {

	Point3d[] triPts = new Point3d[3];
	
	triPts[0] = pnts[coordidx[0]];
	triPts[1] = pnts[coordidx[1]];
	triPts[2] = pnts[coordidx[2]];
	

	boolean intersect = false;
	switch(pickShapeType) {
	case PICK_SHAPE_RAY:
	    intersect = intersectRay(triPts, (PickRay) pickShape, pi);
	    break;
	case PICK_SHAPE_SEGMENT:
	    intersect = intersectSegment(triPts, (PickSegment) pickShape, pi);
	    break;
	    /* case PICK_SHAPE_POINT:
	       if(inside(triPts, (PickPoint) pickShape, ccw)==false)
	       return false;  
	       break;
	       */
	case PICK_SHAPE_BOUNDING_BOX:
	    intersect = intersectBoundingBox (triPts, 
					      (BoundingBox)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_BOUNDING_SPHERE:
	    intersect = intersectBoundingSphere (triPts, 
						 (BoundingSphere)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_BOUNDING_POLYTOPE:
	    intersect = intersectBoundingPolytope (triPts, 
						   (BoundingPolytope)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_CYLINDER:
	    intersect = intersectCylinder (triPts, (PickCylinder) pickShape,pi);
	    break;
	case PICK_SHAPE_CONE:
	    intersect = intersectCone (triPts, (PickCone)pickShape, pi);
	    break;
	}
	if (intersect) {
	    PickIntersection newpi = new PickIntersection(this, pi.geom);
	    newpi.iGeom = pi.iGeom;
	    newpi.setDistance(pi.distance);
	    newpi.setPointCoordinatesVW(pi.getPointCoordinatesVW());

	    // Set PickIntersection parameters
	    newpi.setGeomIndex(geomIndex);
	    newpi.setVertexIndices (vertidx);

	    newpi.setPrimitiveCoordinatesVW(triPts);
	    intersections.add (newpi);
	    return true;
	}
	return false;
    }

    boolean intersectQuad(int[] vertidx, int[] coordidx, int geomIndex, 
			  Point3d[] pnts, PickIntersection pi) {

	Point3d[] quadPts = new Point3d[4];
	
	quadPts[0] = pnts[coordidx[0]];
	quadPts[1] = pnts[coordidx[1]];
	quadPts[2] = pnts[coordidx[2]];
	quadPts[3] = pnts[coordidx[3]];

	// PickIntersection pi = new PickIntersection(this);

	boolean intersect = false;
	switch(pickShapeType) {
	case PICK_SHAPE_RAY:
	    intersect = intersectRay(quadPts, (PickRay) pickShape, pi);
	    break;
	case PICK_SHAPE_SEGMENT:
	    intersect = intersectSegment(quadPts, (PickSegment) pickShape, pi);
	    break;
	    /* case PICK_SHAPE_POINT:
	       if(inside(quadPts, (PickPoint) pickShape, ccw)==false)
	       return false;  
	       break;
	       */
	case PICK_SHAPE_BOUNDING_BOX:
	    intersect = intersectBoundingBox (quadPts, 
					      (BoundingBox)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_BOUNDING_SPHERE:
	    intersect = intersectBoundingSphere (quadPts, 
						 (BoundingSphere)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_BOUNDING_POLYTOPE:
	    intersect = intersectBoundingPolytope (quadPts, 
						   (BoundingPolytope)pickShapeBounds);
	    pi.setPointCoordinatesVW(zeroPnt);
	    break;
	case PICK_SHAPE_CYLINDER:
	    intersect = intersectCylinder (quadPts, (PickCylinder)pickShape,pi);
	    break;
	case PICK_SHAPE_CONE:
	    intersect = intersectCone (quadPts, (PickCone)pickShape, pi);
	    break;
	}
	if (intersect) {	    
	    PickIntersection newpi = new PickIntersection(this, pi.geom);
	    newpi.iGeom = pi.iGeom;
	    newpi.setDistance(pi.distance);
	    newpi.setPointCoordinatesVW(pi.getPointCoordinatesVW());
	    
	    // Set PickIntersection parameters
	    newpi.setGeomIndex(geomIndex);
	    newpi.setVertexIndices (vertidx);
	    newpi.setPrimitiveCoordinatesVW(quadPts);
	    intersections.add (newpi);
	    return true;
	}
	return false;
    }

    /* ==================================================================== */
    /*                 INTERSECT METHODS BY GEOMETRY TYPE                   */
    /* ==================================================================== */

    /** 
      Intersect method for PointArray 
      */
    boolean intersectPA (PointArray geom, int geomIndex, Point3d[] pnts, 
			 boolean firstpick, PickIntersection pi) {

	if (debug) System.out.println ("intersect: PointArray");

	int[] pntVertIdx = new int[1];
	int numint = 0;

	for (int i = 0; i < pnts.length; i++) {
	    pntVertIdx[0] = i;
	    if (intersectPoint(pntVertIdx, pntVertIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	}
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedPointArray 
      */
    boolean intersectIPA (IndexedPointArray geom, int geomIndex, Point3d[] pnts,
			  boolean firstpick, PickIntersection pi) {

	if (debug) System.out.println ("intersect: IndexedPointArray");

	int[] pntVertIdx = new int[1];
	int[] pntCoordIdx = new int[1];

	int numint = 0;
	int indexCount = geom.getIndexCount();
	
	for (int i=0; i< indexCount; i++) {
	    pntVertIdx[0] = i;
	    pntCoordIdx[0] = geom.getCoordinateIndex(i);
	    if (intersectPoint(pntVertIdx, pntCoordIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	}
	if (numint > 0) return true;
	return false;
    }


    /** 
      Intersect method for LineArray 
      */
    /** 
      Intersect method for LineArray 
      */
    boolean intersectLA (LineArray geom, int geomIndex, Point3d[] pnts,
			 boolean firstpick, PickIntersection pi) {

	if (debug) System.out.println ("intersect: LineArray");

	int[] lineVertIdx = new int[2];

	int numint = 0;

	for (int i=0; i< pnts.length;) {
	    /* set up the parameters for the current line */
	    lineVertIdx[0] = i++;
	    lineVertIdx[1] = i++;
	    if (intersectLine(lineVertIdx, lineVertIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	} 
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for LineStripArray 
      */
    boolean intersectLSA (LineStripArray geom, int geomIndex, Point3d[] pnts,
			  boolean firstpick, PickIntersection pi) {
	int numint = 0;

	int[] stripVertexCounts = new int [geom.getNumStrips()];
	geom.getStripVertexCounts (stripVertexCounts);
	int stripStart = 0;
	
	if (debug) System.out.println ("intersect: LineStripArray");

	int[] lineVertIdx = new int[2];

	for (int i=0; i < stripVertexCounts.length; i++) {  
	    lineVertIdx[0] = stripStart;
	    int end = stripStart + stripVertexCounts[i];
	    
	    for (int j=stripStart+1; j<end; j++) {
		lineVertIdx[1] = j;
		if (intersectLine(lineVertIdx, lineVertIdx, geomIndex, pnts, pi)) {
		    numint++;
		    if (firstpick) return true;
		}
		lineVertIdx[0] = lineVertIdx[1];
	    }
	    stripStart += stripVertexCounts[i];
	}
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedLineArray 
      */
    boolean intersectILA (IndexedLineArray geom, int geomIndex, Point3d[] pnts,
			  boolean firstpick, PickIntersection pi) {

	int numint = 0;
	int indexCount = geom.getIndexCount();
	if (debug) System.out.println ("intersect: IndexedLineArray");

	int[] lineVertIdx = new int[2];
	int[] lineCoordIdx = new int[2];

	for (int i=0; i<indexCount;) {
	    lineVertIdx[0] = i;
	    lineCoordIdx[0] = geom.getCoordinateIndex(i++);
	    lineVertIdx[1] = i;
	    lineCoordIdx[1] = geom.getCoordinateIndex(i++);
	    if (intersectLine(lineVertIdx, lineCoordIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	}
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedLineStripArray 
      */
    boolean intersectILSA (IndexedLineStripArray geom, int geomIndex, 
			   Point3d[] pnts, boolean firstpick, PickIntersection pi) {
	if (debug) System.out.println ("intersect: IndexedLineStripArray");

	int[] lineVertIdx = new int[2];
	int[] lineCoordIdx = new int[2];

	int numint = 0;
	int[] stripVertexCounts = new int [geom.getNumStrips()];
	geom.getStripIndexCounts (stripVertexCounts);
	int stripStart = 0;
	
	for (int i=0; i < stripVertexCounts.length; i++) {  

	    lineVertIdx[0] = stripStart;
	    lineCoordIdx[0] = geom.getCoordinateIndex(stripStart);
	    int end = stripStart + stripVertexCounts[i];
	    for (int j=stripStart+1; j<end; j++) {
		lineVertIdx[1] = j;
		lineCoordIdx[1] = geom.getCoordinateIndex(j);
		if (intersectLine(lineVertIdx, lineCoordIdx, geomIndex, pnts, pi)) {
		    numint++;
		    if (firstpick) return true;
		}
		lineVertIdx[0] = lineVertIdx[1];
		lineCoordIdx[0] = lineCoordIdx[1];
	    }
	    stripStart += stripVertexCounts[i];
	}
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for TriangleArray 
      */
    boolean intersectTA (TriangleArray geom, int geomIndex, Point3d[] pnts,
			 boolean firstpick, PickIntersection pi) {

	if (debug) 
	    System.out.println ("intersect: TriangleArray");

	int[] triVertIdx = new int[3];

	int numint = 0;
	for (int i=0; i<pnts.length;) {
	    triVertIdx[0] = i++;
	    triVertIdx[1] = i++;
	    triVertIdx[2] = i++;
	    if (intersectTri(triVertIdx, triVertIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	} 

	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedTriangleArray 
      */
    boolean intersectITA (IndexedTriangleArray geom, int geomIndex, 
			  Point3d[] pnts, boolean firstpick, PickIntersection pi) {
	
	if (debug)
	    System.out.println ("intersect: IndexedTriangleArray");

	int[] triVertIdx = new int[3];
	int[] triCoordIdx = new int[3];