Picking question.

Question

I have been beating my head on this for days and can't see what the problem is. All I want to do is to pick a point on a sphere and then at that point project a cylinder into the sphere.
I can get the thing to place the pont in the sphere, but not at the point I pick. If I keep picking other points, the cylinder will move slightly one way or the other, but not to the extent it needs to.
Any help is REALLY appreciated.
Here is the code:
import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.media.j3d.AmbientLight;
import javax.media.j3d.Appearance;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.ColoringAttributes;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.GeometryArray;
import javax.media.j3d.HiResCoord;
import javax.media.j3d.Locale;
import javax.media.j3d.PhysicalBody;
import javax.media.j3d.PhysicalEnvironment;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.View;
import javax.media.j3d.ViewPlatform;
import javax.media.j3d.VirtualUniverse;
import javax.swing.JFrame;
import javax.vecmath.AxisAngle4d;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;
import com.sun.j3d.utils.behaviors.mouse.MouseRotate;
import com.sun.j3d.utils.behaviors.mouse.MouseTranslate;
import com.sun.j3d.utils.geometry.Cylinder;
import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.universe.SimpleUniverse;
//import com.tornadolabs.j3dtree.Java3dTree;
public class DisplayFrame extends JFrame implements PointSelectedReceiver
    private Transform3D     pointT3D = new Transform3D();
    private TransformGroup  pointTG;
    private VirtualUniverse universe;
    //private Java3dTree      j3dTree;
    private Canvas3D        canvas3D;
    private Vector3d        pointCurrTrans = new Vector3d();
    private Transform3D     pointRotT3D    = new Transform3D();
    private static final Vector3d ORIGIN = new Vector3d(0, 0, 0);
     * @param args
    public static void main(String[] args)
        DisplayFrame mainframe = new DisplayFrame();
        mainframe.init();
        mainframe.setPreferredSize(new Dimension(1280, 1024));
        mainframe.setMinimumSize(new Dimension(1024, 768));
        mainframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainframe.pack();
        mainframe.setVisible(true);
    private void init()
         universe = new VirtualUniverse();
         canvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
         int[] xPos = {0,0,0,0,0,0,0,0};
         int[] yPos = {0,0,0,0,0,0,0,0};
         int[] zPos = {0,0,1,5,0,0,0,0};
         HiResCoord hiResCoord = new HiResCoord(xPos, yPos, zPos);
         //j3dTree  = new Java3dTree();
         Locale locale = new Locale(universe, hiResCoord);
         BranchGroup scene = createSceneGraph();
         //j3dTree.recursiveApplyCapability(scene);
         scene.compile();
         locale.addBranchGraph(scene);
         BranchGroup vpBranchGroup = new BranchGroup();
         TransformGroup tg = new TransformGroup();
         ViewPlatform vp = new ViewPlatform();
         vp.setViewAttachPolicy(View.RELATIVE_TO_FIELD_OF_VIEW);
         tg.addChild(vp);
         vpBranchGroup.addChild(tg);
         locale.addBranchGraph(vpBranchGroup);
         View view = new View();
         view.setProjectionPolicy(View.PARALLEL_PROJECTION);
         PhysicalBody        pb = new PhysicalBody();
         PhysicalEnvironment pe = new PhysicalEnvironment();
         view.setPhysicalEnvironment(pe);
         view.setPhysicalBody(pb);
         view.attachViewPlatform(vp);
         view.setBackClipDistance(110);
         view.setFrontClipPolicy(View.VIRTUAL_EYE);
         view.addCanvas3D(canvas3D);
         this.setLayout( new BorderLayout() );
         this.setSize(new Dimension(1024,768));
         this.setMinimumSize(new Dimension(1024, 768));
         this.add("Center", canvas3D);  
         //j3dTree.updateNodes(universe);
    private BranchGroup createSceneGraph()
        BranchGroup objRoot = new BranchGroup();
        double scale = 0.02d;
        Transform3D myTransform3D = new Transform3D();
        myTransform3D.setScale(scale);
        TransformGroup mainTG = new TransformGroup(myTransform3D);
        mainTG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        mainTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        mainTG.setCapability(TransformGroup.ALLOW_CHILDREN_EXTEND);
        mainTG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);
        //Test a color cube
        Sphere sphere = new Sphere(10.0f);
        sphere.setPickable(true);
        sphere.getShape().setCapability(Shape3D.ENABLE_PICK_REPORTING);
        sphere.getShape().setCapability(Shape3D.ALLOW_GEOMETRY_READ);
        sphere.getShape().getGeometry().setCapability(GeometryArray.ALLOW_COUNT_READ);
        sphere.getShape().getGeometry().setCapability(GeometryArray.ALLOW_FORMAT_READ);
        sphere.getShape().getGeometry().setCapability(GeometryArray.ALLOW_COORDINATE_READ);
        sphere.getShape().getGeometry().setCapability(GeometryArray.ALLOW_REF_DATA_READ);
        sphere.setCapability(Sphere.ALLOW_PICKABLE_READ);
        Transform3D sphereT3D = new Transform3D();
        sphereT3D.setTranslation(new Vector3d(0.0f, 0.0f, 0.0f));
        TransformGroup sphereTG = new TransformGroup(sphereT3D);
        sphereTG.addChild(sphere);
        mainTG.addChild(sphereTG);
        //Add lighting
        BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
        Color3f ambientColor          = new Color3f(0.9f, 0.9f, 0.9f);
        Color3f directionalLightColor = new Color3f(0.6f, 0.6f, 0.6f);
        AmbientLight ambientLightNode = new AmbientLight(ambientColor);
        ambientLightNode.setInfluencingBounds(bounds);
        mainTG.addChild(ambientLightNode);
        DirectionalLight directionalLight = new DirectionalLight(directionalLightColor, new Vector3f(+0.0f, +0.10f, +0.00f) );
        directionalLight.setInfluencingBounds(bounds);
        mainTG.addChild(directionalLight);
        //Add an object to indicate the point picked
        pointTG = new TransformGroup();
        pointTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        pointTG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        pointT3D.setTranslation(new Vector3d(-20.0f, 0.0f, 0.0f));
        pointTG.setTransform(pointT3D);
        Appearance         pickAp    = new Appearance();
        ColoringAttributes colorAtt  = new ColoringAttributes();
        Color3f            pickColor = new Color3f(0.0f, 0.5f, 0.8f);
        colorAtt.setColor( pickColor );
        pickAp.setColoringAttributes( colorAtt );
        Cylinder pointIndicator = new Cylinder(0.25f, 25.0f, pickAp); 
        pointIndicator.setPickable(false);
        pointTG.addChild(pointIndicator);
        mainTG.addChild(pointTG);  
        //Add the picking behavior next
        PointPickBehaviour picking = new PointPickBehaviour(canvas3D,
                                                            objRoot,
                                                            bounds,
                                                            DisplayFrame.this);
        mainTG.addChild(picking);
        MouseRotate behavior = new MouseRotate();
        behavior.setTransformGroup(mainTG);
        mainTG.addChild(behavior);
        behavior.setSchedulingBounds(bounds);
        MouseTranslate behavior2 = new MouseTranslate();
        behavior2.setTransformGroup(mainTG);
        mainTG.addChild(behavior2);
        behavior2.setSchedulingBounds(bounds);
        objRoot.addChild(mainTG);
        objRoot.setCapability(BranchGroup.ENABLE_PICK_REPORTING);
        return objRoot;
    public void receiveSelectedPoint(Point3d point)
        pointT3D.setTranslation(new Vector3d(point.x, point.y, point.z));
        pointTG.setTransform(pointT3D);
    public void receivePickRotation(AxisAngle4d rotAxis)
        pointTG.getTransform( pointT3D );
        pointT3D.get( pointCurrTrans ); 
        pointT3D.setTranslation( ORIGIN );
        pointT3D.setRotation( rotAxis ); 
        pointT3D.mul(pointRotT3D);
        pointT3D.setTranslation( pointCurrTrans );
        pointTG.setTransform( pointT3D );
}Now the code to the pick itself:
import javax.vecmath.*;
import javax.media.j3d.*;
import com.sun.j3d.utils.picking.*;
import com.sun.j3d.utils.picking.behaviors.PickMouseBehavior;
public class PointPickBehaviour extends PickMouseBehavior
  private PointSelectedReceiver receiver;
  private boolean               firstRotation;
  private AxisAngle4d           rotAxisAngle   = new AxisAngle4d();
  private Vector3d              clickVec       = new Vector3d();
  private Vector3d              axisVec        = new Vector3d();
  private double                pickAngle;
  private Point3d               startPt;
  // initial orientation of pick pointer: straight up
  private static final Vector3d UPVEC = new Vector3d(0.0, 1.0, 0.0);
  // for repeated calculations
  public PointPickBehaviour(Canvas3D    canvas,
                            BranchGroup root,
                            Bounds      bounds,
                            PointSelectedReceiver receiver)
    super(canvas, root, bounds);
    setSchedulingBounds(bounds);
    pickCanvas.setMode(PickCanvas.GEOMETRY_INTERSECT_INFO);
    this.receiver = receiver;
  public void updateScene(int xpos, int ypos)
  /* This method is called when something is picked.
       pickCanvas.setShapeLocation(xpos, ypos);
       Point3d eyePos = pickCanvas.getStartPosition();
      startPt = eyePos;
       PickResult pickResult = null;
       pickResult = pickCanvas.pickClosest();
       if (pickResult != null)
           PickIntersection pi = pickResult.getClosestIntersection(eyePos); 
          System.out.println("Picked coordinates: " + pi.getClosestVertexCoordinates());
          Point3d intercept = pi.getPointCoordinatesVW();
          rotateToPoint(intercept);
          receiver.receiveSelectedPoint(intercept);
  } // end of updateScene()
  private void rotateToPoint(Point3d intercept)
  /* Turn the picked point to point at the point where the
     mouse was clicked.
        if (!firstRotation)
        {   // undo previous rotations to gun and beam
            axisVec.negate();
            rotAxisAngle.set( axisVec, pickAngle );
            receiver.receivePickRotation(rotAxisAngle);
        clickVec.set( intercept.x - startPt.x,
                      intercept.y - startPt.y,
                      intercept.z - startPt.z);
        clickVec.normalize();
        axisVec.cross( UPVEC, clickVec);
        pickAngle = UPVEC.angle(clickVec);
        rotAxisAngle.set(axisVec, pickAngle);     // build rotation
        receiver.receivePickRotation(rotAxisAngle);
        firstRotation = false;
  } // end of rotateToPoint()
} Fianlly the interface to tie the two:
import javax.vecmath.AxisAngle4d;
import javax.vecmath.Point3d;
public interface PointSelectedReceiver
    public void receiveSelectedPoint(Point3d point);
    public void receivePickRotation(AxisAngle4d rotation);
}

Answer 1

Well I have it sort of working (the pick indicator cylinder gets placed at the right point, but if you rotate the sphere and then select another point the cylinder isn't drawn toward the user).
The fix was to change getPointCoordinatesVW to getClosestVertexCoordinates.