[Java] Zoom Centrato in Java3D

[som]

Ciao a tutti,

vorrei realizzare uno Zoom Centrato al punto al quale si trova il mouse e azionato dal movimento della rotellina.

Finora sono riuscito a realizzarlo implementando il MouseWheelListener e se non richiedo anche la "centratura" funziona.
Il problema ce l'ho quando provo a centrarlo. Lo ZoomIn non funziona proprio male, mentre lo ZoomOut fa dei movimenti assurdi!

Qualcuno saprebbe indicarmi degli algoritmi o dei metodi che potrebbero aiutarmi?

Attualmente io prima scalo l'immagine e poi procedo alla traslazione. Per quest'ultima operazione calcolo il vettore ( Vector3f ) di traslazione considerando il punto in cui si trova il mouse rispetto alle dimensioni del pannello ( valuto la differenza rispetto w/2 e h/2 e ne valuto il segno ) ma sicuramente non è una procedura che va bene.

Grazie per qualsiasi aiuto.

[som]

con il java3d sono già comprese le classi per l'interazione del mouse, così sto cercando di utilizzare la classe astratta MouseBehavior per creare il MouseWheelZoomche fa al caso mio.

Partendo dal codice della classe standard già implementata ( funziona, ma dopo 4-5 livelli di ingrandimento l'immagine scompare .. chissà perchè :master: )
vorrei aggiungere la funzione di "centratura" dell'immagine rispetto al punto in cui è posizionato il mouse.

public class MouseWheelZoom extends MouseBehavior {
     
     double z_factor = .1;
     Vector3d translation = new Vector3d();
     
     private MouseBehaviorCallback callback = null;
     
     /**
      * Creates a zoom behavior given the transform group.
      * @param transformGroup The transformGroup to operate on.
      */
     public MouseWheelZoom(TransformGroup transformGroup) {
         super(transformGroup);
     }
     
     /**
      * Creates a default mouse zoom behavior.
      **/
     public MouseWheelZoom() {
         super(0);
     }
     
     /**
      * Creates a zoom behavior.
      * Note that this behavior still needs a transform
      * group to work on (use setTransformGroup(tg)) and
      * the transform group must add this behavior.
      * @param flags
      */
     public MouseWheelZoom(int flags) {
         super(flags);
     }
     
     /**
      * Creates a zoom behavior that uses AWT listeners and behavior
      * posts rather than WakeupOnAWTEvent.  The behavior is added to the
      * specified Component.  A null component can be passed to specify
      * the behavior should use listeners.  Components can then be added
      * to the behavior with the addListener(Component c) method.
      * @param c The Component to add the MouseListener
      * and MouseMotionListener to.
      * @since Java 3D 1.3.2
      */
     public MouseWheelZoom(Component c) {
         super(c, 0);
     }
     
     /**
      * Creates a zoom behavior that uses AWT listeners and behavior
      * posts rather than WakeupOnAWTEvent.  The behaviors is added to
      * the specified Component and works on the given TransformGroup.
      * @param c The Component to add the MouseListener and
      * MouseMotionListener to.  A null component can be passed to specify
      * the behavior should use listeners.  Components can then be added
      * to the behavior with the addListener(Component c) method.
      * @param transformGroup The TransformGroup to operate on.
      * @since Java 3D 1.3.2
      */
     public MouseWheelZoom(Component c, TransformGroup transformGroup) {
         super(c, transformGroup);
     }
     
     /**
      * Creates a zoom behavior that uses AWT listeners and behavior
      * posts rather than WakeupOnAWTEvent.  The behavior is added to the
      * specified Component.  A null component can be passed to specify
      * the behavior should use listeners.  Components can then be added
      * to the behavior with the addListener(Component c) method.
      * Note that this behavior still needs a transform
      * group to work on (use setTransformGroup(tg)) and the transform
      * group must add this behavior.
      * @param flags interesting flags (wakeup conditions).
      * @since Java 3D 1.3.2
      */
     public MouseWheelZoom(Component c, int flags) {
         super(c, flags);
     }
     
     public void initialize() {
         super.initialize();
         if ((flags & INVERT_INPUT) == INVERT_INPUT) {
         z_factor *= -1;
         invert = true;
         }
     }
     
     /**
      * Return the y-axis movement multipler.
      **/
     public double getFactor() {
        return z_factor;
     }
     
     /**
      * Set the wheel units movement multipler with factor.
      **/
     public void setFactor( double factor) {
        z_factor = factor;
     }
     
     
     public void processStimulus(Enumeration criteria) {
         WakeupCriterion wakeup;
         AWTEvent[] events;
         MouseEvent evt;

         while (criteria.hasMoreElements()) {
             wakeup = (WakeupCriterion) criteria.nextElement();
             if (wakeup instanceof WakeupOnAWTEvent) {
             events = ((WakeupOnAWTEvent)wakeup).getAWTEvent();
             if (events.length > 0) {
                 evt = (MouseEvent) events[events.length-1];
                 doProcess(evt);
             }
             }

             else if (wakeup instanceof WakeupOnBehaviorPost) {
             while (true) {
                 synchronized (mouseq) {
                 if (mouseq.isEmpty()) break;
                 evt = (MouseEvent)mouseq.remove(0);
                 // consolidate MOUSE_WHEEL events
                 while((evt.getID() == MouseEvent.MOUSE_WHEEL) &&
                       !mouseq.isEmpty() &&
                       (((MouseEvent)mouseq.get(0)).getID() ==
                        MouseEvent.MOUSE_WHEEL)) {
                     evt = (MouseEvent)mouseq.remove(0);
                 }
                 }
                 doProcess(evt);
             }
             }

         }
         wakeupOn(mouseCriterion);
     }
     
     void doProcess(MouseEvent evt) {
         int units = 0;

         processMouseEvent(evt);

         if ((evt.getID() == MouseEvent.MOUSE_WHEEL)) {
             MouseWheelEvent wheelEvent = (MouseWheelEvent)evt;
             if (wheelEvent.getScrollType() == wheelEvent.WHEEL_UNIT_SCROLL ) {
             units = wheelEvent.getUnitsToScroll();
             }

             if (!reset) {
             transformGroup.getTransform(currXform);

             translation.z  = units*z_factor;
                          
             transformX.set(translation);

             if (invert) {
                 currXform.mul(currXform, transformX);
             } else {
                 currXform.mul(transformX, currXform);
             }

             transformGroup.setTransform(currXform);

             transformChanged( currXform );

             if (callback!=null)
                 callback.transformChanged( MouseBehaviorCallback.ZOOM,
                                currXform );

             }
             else {
             reset = false;
             }        
         }
     }
     
     
     /**
      * Users can overload this method  which is called every time
      * the Behavior updates the transform
      *
      * Default implementation does nothing
      */
     public void transformChanged( Transform3D transform ) {
     }
     
     /**
      * The transformChanged method in the callback class will
      * be called every time the transform is updated
      */
     public void setupCallback( MouseBehaviorCallback callback ){
        this.callback = callback;
    }
 }

Qualcuno ha un'idea di come potrei fare?
Grazie cmq!