gov.nasa.worldwind.drag

Class DraggableSupport

java.lang.Object

gov.nasa.worldwind.drag.DraggableSupport

public class DraggableSupport
extends java.lang.Object

Utility functions which support dragging operations on objects implementing the Movable or Movable2 interface.

Field Summary

Fields

Modifier and Type	Field and Description
protected int	altitudeMode The altitude mode of the object to be dragged.
protected double	convergenceThreshold This instances convergence threshold for the solver used to determine the position of objects using the WorldWind.RELATIVE_TO_GROUND altitude mode.
static double	DEFAULT_CONVERGENCE_THRESHOLD The computeRelativePoint(Line, Globe, SceneController, double) method uses a numeric search method to determine the coordinates of the desired position.
static int	DEFAULT_STEP_LIMIT The computeRelativePoint(Line, Globe, SceneController, double) method uses a numeric search method to determine the coordinates of the desired position.
protected java.lang.Object	dragObject The object that will be subject to the drag operations.
protected Vec4	initialEllipsoidalReferencePoint Initial drag operation cartesian coordinates of the objects reference position.
protected Vec4	initialEllipsoidalScreenPoint Initial drag operation cartesian coordinates of the initial screen point.
protected Vec4	initialScreenPointOffset Initial drag operation offset in x and y screen coordinates, between the object reference position and the screen point.
protected int	stepLimit This instances step limit when using the solver to determine the position of objects using the WorldWind.RELATIVE_TO_GROUND altitude mode.

Constructor Summary

Constructors

Constructor and Description
DraggableSupport(java.lang.Object dragObject, int altitudeMode) Provides persistence of initial values of a drag operation to increase dragging precision and provide better dragging behavior.

Method Summary

Modifier and Type	Method and Description
protected Vec4	computeEllipsoidalPointFromScreen(DragContext dragContext, java.awt.Point screenPoint, double altitude, boolean utilizeSearchMethod) Determines the cartesian coordinate of a screen point given the altitude mode.
protected Vec4	computeGlobeIntersection(Line ray, double altitude, boolean useSearchMethod, Globe globe, SceneController sceneController) Computes the intersection of the provided Line with the Globe while accounting for the altitude mode.
protected Vec4	computeRelativePoint(Line ray, Globe globe, SceneController sceneController, double altitude) Attempts to find a position with the altitude specified for objects which are WorldWind.RELATIVE_TO_GROUND.
protected Vec4	computeScreenOffsetFromReferencePosition(Position dragObjectReferencePosition, DragContext dragContext) Determines the offset in screen coordinates from the previous screen point (DragContext.getInitialPoint() and the objects Movable.getReferencePosition() or Movable2.getReferencePosition() methods.
protected void	doMove(Position movePosition, Globe globe) Executes the Movable2.moveTo(Globe, Position) or Movable.moveTo(Position) methods with the provided data.
void	dragGlobeSizeConstant(DragContext dragContext) Converts the screen position inputs to geographic movement information.
void	dragScreenSizeConstant(DragContext dragContext) Converts the screen position inputs to geographic movement information.
int	getAltitudeMode() Returns the current altitude mode being used by the dragging calculations.
double	getConvergenceThreshold() Returns the convergence threshold used by the solver when an a screen size constant object using a WorldWind.RELATIVE_TO_GROUND altitude mode needs to determine a position.
protected Position	getReferencePosition() Extracts the reference Position from objects implementing Movable or Movable2.
int	getStepLimit() Returns the step limit used by the position solver method for objects using a screen size constant drag approach and a WorldWind.RELATIVE_TO_GROUND altitude mode.
void	setAltitudeMode(int altitudeMode) Sets the altitude mode to be used during dragging calculations.
void	setConvergenceThreshold(double convergenceThreshold) Sets the convergence threshold for the screen size constant object using a WorldWind.RELATIVE_TO_GROUND altitude mode.
void	setStepLimit(int stepLimit) Sets the step limit to use for the position solver.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

altitudeMode

protected int altitudeMode

The altitude mode of the object to be dragged.

convergenceThreshold

protected double convergenceThreshold

This instances convergence threshold for the solver used to determine the position of objects using the WorldWind.RELATIVE_TO_GROUND altitude mode. Decreasing this value will increase solver runtime and may cause the event loop to hang. If the solver does not converge to the threshold specified here, it will fall back to using a position calculated by intersection with the ellipsoid.

DEFAULT_CONVERGENCE_THRESHOLD

public static final double DEFAULT_CONVERGENCE_THRESHOLD

The computeRelativePoint(Line, Globe, SceneController, double) method uses a numeric search method to determine the coordinates of the desired position. The numeric solver will stop at a defined threshold or step limit. The default threshold is provided here. This value is utilized when using the static drag functions provided by this class.

See Also:

Constant Field Values

DEFAULT_STEP_LIMIT

public static final int DEFAULT_STEP_LIMIT

The computeRelativePoint(Line, Globe, SceneController, double) method uses a numeric search method to determine the coordinates of the desired position. The numeric solver will stop at a defined threshold or step limit. The default step limit is provided here. This value is utilized when using the static drag functions provided by this class.

See Also:

Constant Field Values

dragObject

protected final java.lang.Object dragObject

The object that will be subject to the drag operations. This object should implement Movable or Movable2.

initialEllipsoidalReferencePoint

protected Vec4 initialEllipsoidalReferencePoint

Initial drag operation cartesian coordinates of the objects reference position. Used for globe size constant drag operations.

initialEllipsoidalScreenPoint

protected Vec4 initialEllipsoidalScreenPoint

Initial drag operation cartesian coordinates of the initial screen point.

initialScreenPointOffset

protected Vec4 initialScreenPointOffset

Initial drag operation offset in x and y screen coordinates, between the object reference position and the screen point. Used for screen size constant drag operations.

stepLimit

protected int stepLimit

This instances step limit when using the solver to determine the position of objects using the WorldWind.RELATIVE_TO_GROUND altitude mode. Increasing this value will increase solver runtime and may cause the event loop to hang. If the solver exceeds the number of steps specified here, it will fall back to using a position calculated by intersection with the ellipsoid.

Constructor Detail

DraggableSupport

public DraggableSupport(java.lang.Object dragObject,
                        int altitudeMode)

Provides persistence of initial values of a drag operation to increase dragging precision and provide better dragging behavior.

Parameters:

dragObject - the object to be dragged.

altitudeMode - the altitude mode.

Throws:

java.lang.IllegalArgumentException - if the object is null.

Method Detail

computeEllipsoidalPointFromScreen

protected Vec4 computeEllipsoidalPointFromScreen(DragContext dragContext,
                                                 java.awt.Point screenPoint,
                                                 double altitude,
                                                 boolean utilizeSearchMethod)

Determines the cartesian coordinate of a screen point given the altitude mode.

Parameters:

dragContext - the current DragContext of the dragging event.

screenPoint - the Point of the screen to determine the position.

altitude - the altitude in meters.

utilizeSearchMethod - if the altitude mode is WorldWind.RELATIVE_TO_GROUND, this determines if the search method will be used to determine the position, please see the computeRelativePoint(Line, Globe, SceneController, double) for more information.

Returns:

the cartesian coordinates using an ellipsoidal globe, or null if a position could not be determined.

computeGlobeIntersection

protected Vec4 computeGlobeIntersection(Line ray,
                                        double altitude,
                                        boolean useSearchMethod,
                                        Globe globe,
                                        SceneController sceneController)

Computes the intersection of the provided Line with the Globe while accounting for the altitude mode. If a Globe2D is specified, then the intersection is calculated using the globe objects method.

Parameters:

ray - the Line to calculate the intersection of the Globe.

altitude - the altitude mode for the intersection calculation.

useSearchMethod - if the altitude mode is WorldWind.RELATIVE_TO_GROUND, this determines if the search method will be used to determine the position, please see the computeRelativePoint(Line, Globe, SceneController, double) for more information.

globe - the Globe to intersect.

sceneController - if an altitude mode other than WorldWind.ABSOLUTE is specified, the SceneController which will provide terrain information.

Returns:

the cartesian coordinates of the intersection based on the Globes coordinate system or null if the intersection couldn't be calculated.

computeRelativePoint

protected Vec4 computeRelativePoint(Line ray,
                                    Globe globe,
                                    SceneController sceneController,
                                    double altitude)

Attempts to find a position with the altitude specified for objects which are WorldWind.RELATIVE_TO_GROUND. Using the provided Line, conducts a bisectional search along the Line for a Position which is within the convergenceThreshold of the requested altitude provided. The stepLimit limits the number of bisections the function will attempt. If the search does not find a position within the stepLimit or within the convergenceThreshold it will provide an intersection with the ellipsoid at the provided altitude.

Parameters:

ray - the Line from the eye point and direction in globe coordinates.

globe - the current Globe.

sceneController - the current SceneController.

altitude - the target altitude.

Returns:

a Vec4 of the point in globe coordinates.

computeScreenOffsetFromReferencePosition

protected Vec4 computeScreenOffsetFromReferencePosition(Position dragObjectReferencePosition,
                                                        DragContext dragContext)

Determines the offset in screen coordinates from the previous screen point (DragContext.getInitialPoint() and the objects Movable.getReferencePosition() or Movable2.getReferencePosition() methods. If the object doesn't implement either of the interfaces, or there is an error determining the offset, this function will return null.

Parameters:

dragObjectReferencePosition - the Movable or Movable2 reference position Position.

dragContext - the current DragContext of this drag event.

Returns:

a Vec4 containing the x and y offsets in screen coordinates from the reference position and the previous screen point.

doMove

protected void doMove(Position movePosition,
                      Globe globe)

Executes the Movable2.moveTo(Globe, Position) or Movable.moveTo(Position) methods with the provided data. If the object implements both interfaces, the Movable2 is used. If the object doesn't implement either, it is ignored.

Parameters:

movePosition - the Position to provide to the Movable2.moveTo(gov.nasa.worldwind.globes.Globe, gov.nasa.worldwind.geom.Position) method.

globe - the globe reference, may be null if the object only implements the Movable interface.

dragGlobeSizeConstant

public void dragGlobeSizeConstant(DragContext dragContext)

Converts the screen position inputs to geographic movement information. Uses the information provided by the DragContext object and attempts to move the object using the Movable2 or Movable interface. This method maintains a constant geographic distance between the cursor and the reference point of the object being dragged. It is suited for objects which maintain a constant model space or geographic size.

Parameters:

dragContext - the current DragContext for this object.

Throws:

java.lang.IllegalArgumentException - if the DragContext is null.

dragScreenSizeConstant

public void dragScreenSizeConstant(DragContext dragContext)

Converts the screen position inputs to geographic movement information. Uses the information provided by the DragContext object and attempts to move the object using the Movable2 or Movable interface. This method maintains a constant screen offset from the cursor to the reference point of the object being dragged. It is suited for objects maintaining a constant screen size presentation like, TacticalSymbols or PointPlacemark.

Parameters:

dragContext - the current DragContext for this object.

Throws:

java.lang.IllegalArgumentException - if the DragContext is null.

getAltitudeMode

public int getAltitudeMode()

Returns the current altitude mode being used by the dragging calculations.

Returns:

the altitude mode.

getConvergenceThreshold

public double getConvergenceThreshold()

Returns the convergence threshold used by the solver when an a screen size constant object using a WorldWind.RELATIVE_TO_GROUND altitude mode needs to determine a position. When the solver finds an altitude within the convergence threshold to the desired altitude, the solver will stop and return the cartesian position.

Returns:

the convergence threshold.

getReferencePosition

protected Position getReferencePosition()

Extracts the reference Position from objects implementing Movable or Movable2. For objects implementing both, it utilizes the Movable2 interface method. If the object does not implement the interfaces, null is returned.

Returns:

the reference Movable.getReferencePosition() or Movable2.getReferencePosition(), or null if the object didn't implement either interface.

getStepLimit

public int getStepLimit()

Returns the step limit used by the position solver method for objects using a screen size constant drag approach and a WorldWind.RELATIVE_TO_GROUND altitude mode. If the solver exceeds this value it will utilize an intersection with the ellipsoid at the specified altitude.

Returns:

the step limit.

setAltitudeMode

public void setAltitudeMode(int altitudeMode)

Sets the altitude mode to be used during dragging calculations.

Parameters:

altitudeMode - the altitude mode to use for dragging calculations.

setConvergenceThreshold

public void setConvergenceThreshold(double convergenceThreshold)

Sets the convergence threshold for the screen size constant object using a WorldWind.RELATIVE_TO_GROUND altitude mode. The solver will test each iterations solution altitude with the desired altitude and if it is found to be within the convergence threshold, the cartesian solution will be returned. Set this value in coordination with the step limit.

Parameters:

convergenceThreshold - the convergence threshold to use for the solver.

setStepLimit

public void setStepLimit(int stepLimit)

Sets the step limit to use for the position solver. The position solver is only used for screen size constant objects with a WorldWind.RELATIVE_TO_GROUND altitude mode. The step limit is the maximum steps the solver will attempt before using an intersection with the ellipsoid at the specified altitude. Set this value in coordination with the convergence threshold.

Parameters:

stepLimit - the step limit to set for the solver method.