PrivateconstructorThis class should not be instantiated by users of LuciadRIA.
Returns the current constraints applied on the Map
Sets constraints on the map
An object describing the default values used in this MapNavigator.
Manipulate this object to change the default animation durations (or easing functions) for the different MapNavigator operations.
You can assign individual properties, like so: mapNavigator.defaults.pan.duration = 5000; //change the default pan duration to 5000ms
A property describing the currently enabled operations. Valid values are MapNavigator.ALL and MapNavigator.NONE. Set to MapNavigator.ALL by default.
mapNavigator.enabledOperations has been deprecated.
This property will only be respected by the deprecated MapNavigator methods.
The new methods (pan, rotate, zoom and fit),
will ignore enabledOperations.
As a replacement, you can use constraints to configure bounds and scale limits to completely 'freeze' the map.
If you only want to disable user interaction, you also set a 'no-op' controller on the map. This is a controller that consumes all gesture events, without doing anything.
Fits a specified area into a view using an animation. The map will be modified so that the area specified by the bounds-parameters is in the center.
It is both possible to either maintain the map's current scale ratio, or have it adapt in order to obtain a perfect fit. The scale ratio is the ratio between the scale for the x-axis and the scale ratio of the y-axis.
Note that this method will only have an effect if enabledOperations is set to ALL.
The area to show. It is interpreted as a 2D bounds (i.e. the depth will not be taken into account).
OptionalallowWarpXYAxis: booleanIndicates whether the scale ratio will be adapted to
be able to obtain a perfect fit. The default value is false.
Perfect fit means the existing aspect ratio between the horizontal and
vertical scale of the map will be adjusted independently.
Consider a map which is shown in a wide
rectangular screenport (e.g. 16:9) but on which you perform a perfect fit
with a square bounds. Doing so would cause a warping effect, compressing
the y-axis to ensure it is in the view. However, when the data on the
map is specified in a coordinates system in which x and y do not represent
the same kind of quantity, setting allowWarpXYAxis to
true is a convenient way to show all data on the map in that
bounds, without any extra padding and the associated loss of screen
real-estate. In such a case, a stretch or compression along an axis may be
a desired effect.
This can only be set to
true if the Map is used to visualize data
that is not spatial in nature. For example,
when the Map's reference axes represent units of measure like
speed, distance, or volume.
See ReferenceProvider.createCartesianReference
for more information on how to create such a reference.
A promise which represents the completion of the fit operation. The promise will be resolved when the fit operation has completed. The promise will be rejected when the (animated) fit operation is interrupted.
mapNavigator.fit(bounds, allowWarpXYAxis) has been deprecated. Use the new MapNavigator.fit(fitOptions instead). You can replace this call with the new equivalent fit:
map.mapNavigator.fit({bounds: bounds, allowWarpXYAxis: allowWarpXYAxis, animate: true});
Performs a fit operation.
Use this operation to ensure that the map covers a certain area.Note: For backwards compatibility, when a Bounds is passed instead of an options literal, the deprecated version of fit will be used.
After the fit operation, the view extents will fit the extents of fitOptions.target. The map's rotation might be affected by the fit operation. It is not guaranteed that rotation will be preserved.
The options for the fit operation.
A promise that will be resolved after the fit operation has finished. You have to wait for the promise to resolve, even for non-animated fits.
For animated fits, the returned Promise will be resolved when the fit animation has completely finished. If the fit animation is interrupted (for example, by another animation), the promise is rejected.
Positions the viewer at a given eye point. This method can be used to look around freely from a fixed position.
This method will only perform an operation if the Map's reference (Map.reference) is a geocentric 3D reference (e.g. EPSG:4978). If the map is not a 3D map, this method will throw an error.
the point at which to put the eye point. The point can have any spatial reference.
the desired yaw angle from the eye point to the reference point (in degrees). This is similar to turning your head left to right. 0 means looking north, and the degrees count clockwise.
the desired pitch angle from the eye point to the reference point (in degrees). This value must be between -89 and 89 degrees. This is similar to nodding your head up and down. -89 means looking straight down, 0 is looking straight ahead to the horizon, and 89 is degrees is looking straight up.
the desired roll angle of the viewer around its line-of-sight axis (in degrees). This is similar to turning your entire head upside down (if you could). The rotation is clockwise.
Optionaloptions: MapNavigatorLookFromOptionsthe options for the lookFrom operation
A promise that will be resolved after the lookFrom operation has finished. You have to wait for the promise to resolve, even for non-animated lookFrom operations.
For animated lookFrom operations, the returned Promise will be resolved when the lookFrom animation has completely finished. If the lookFrom animation is interrupted (for example, by another animation), the promise is rejected.
Performs a pan operation.
Use this operation to:
After the pan operation, targetLocation will be at toViewLocation.
The options for the pan operation
A promise that will be resolved after the pan operation has finished. You have to wait for the promise to resolve, even for non-animated pan operations.
For animated panning, the returned Promise will be resolved when the pan animation has completely finished. If the pan animation is interrupted (for example, by another animation), the promise is rejected.
Scroll or pan the view by the given amount in pixel coordinates. This method has an immediate effect and will interrupt ongoing animations.
Note that this method will only have an effect if enabledOperations is set to ALL.
the horizontal distance (in pixels).
the vertical distance (in pixels).
mapNavigator.panBy(deltaX, deltaY) has been deprecated. Use the new MapNavigator.pan(panOptions) instead. You can replace this call with a pan call that pans the center of the view to an offsetted location:
var centerOfView = createPoint(null, [map.viewSize[0] / 2, map.viewSize[1] / 2]);
var offsetFromCenterOfView = centerOfView.copy();
offsetFromCenterOfView.translate(deltaX, deltaY);
map.mapNavigator.pan({targetLocation: centerOfView, toViewLocation: offsetFromCenterOfView});
Perform an animated pan to the of the given bounded defined in the given geographic reference.
This method differs from setCenter in the fact that panning is performed through a smooth animation, while the setCenter method immediately updates the map.Note that this method will only have an effect if enabledOperations is set to ALL.
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.panTo(bounded) has been deprecated. Use the new MapNavigator.pan(panOptions) instead. You can replace this call with the new equivalent pan:
map.mapNavigator.pan({targetLocation: bounded.bounds.focusPoint, animate: true});
Performs a rotate operation. Use this operation to:
If you rotate to a target angle, you cannot rotate with a delta and vice-versa.
2D only options will be ignored in 3D (and vice-versa).
Note that map rotation will be disabled (fixed to 0) in the following cases:
The options for the rotate operation
A promise that will be resolved after the rotate operation has finished. You have to wait for the promise to resolve, even for non-animated rotate operations.
For animated rotations, the returned Promise will be resolved when the rotate animation has completely finished. If the rotate animation is interrupted (for example, by another animation), the promise is rejected.
Position the map so that the given view point (in pixels) maps onto the given spatial coordinate. This method has an immediate effect and will interrupt ongoing animations.
Note that this method will only have an effect if enabledOperations is set to ALL.
mapNavigator.setCenter() has been deprecated. Use the new MapNavigator.pan(panOptions) instead. You can replace this call with the new equivalent pan:
map.mapNavigator.pan({targetLocation: spatialPoint, toViewLocation: viewPoint}));
Sets the scale of the map. This method has an immediate effect and will interrupt ongoing animations. Note that this method will only have an effect if enabledOperations is set to ALL.
the desired scale
mapNavigator.setScale() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({targetScale: scale});
Sets the scale of the map in a non uniform way. Non uniform: the scale to be applied on the X-axis can differ from the scale applied on the Y axis. Scale factors for each axis must be passed in the scale array.
An array containing scale factors for each axis; First element in the array contains the scale factor for the X-axis, the second element the scale factor for the Y axis.
mapNavigator.setScale() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({targetScale: {x: scale[0], y: scale[1]}});
Sets the scale on the map, while fixing to the given point in pixel coordinates. Note that this method will only have an effect if enabledOperations is set to ALL.
the desired scale
the x-coordinate to fix on
the y-coordinate to fix on
mapNavigator.setScaleFixing() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({targetScale: scale, location: createPoint(null, [x,y]});
Sets a non-uniform scale on the map, while fixing to the given point in pixel coordinates. Non uniform: the scale to be applied on the X-axis can differ from the scale applied on the Y axis. Scale factors for each axis must be applied in the scale array. Note that this method will only have an effect if enabledOperations is set to ALL.
the desired scale factors in an array, one scale factor for each axis
the x-coordinate to fix on
the y-coordinate to fix on
mapNavigator.setScaleFixing() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({targetScale: {x: scale[0], y: scale[1]}, location: createPoint(null, [x,y]});
Performs a zoom operation.
Use this operation to:You must specify either a factor or a target scale, but you can not use both in the same zoom operation.
Can be used for both uniform zooming (same x- and y-scale, commonly used on georeferenced maps) and non-uniform zooming (different x- and y-scale, commonly used for non-georeferenced maps).
The options for the zoom operation
A promise that will be resolved after the zoom operation has finished. You have to wait for the promise to resolve, even for non-animated zoom operations.
For animated zooming, the returned Promise will be resolved when the pan animation has completely finished. If the zoom animation is interrupted (for example, by another animation), the promise is rejected.
Perform an animated zoom in (by a fixed amount).
Note that this method will only have an effect if enabledOperations is set to ALL.
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomIn() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({factor: 2.0, animate: true});
Perform an animation zoom-in, fixing on the given view position (passed as x and y coordinates)
Note that this method will only have an effect if enabledOperations is set to ALL.
view x-coordinate
view y-coordinate
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomInFixing() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({factor: 2.0, location: createPoint(null, [x, y]), animate: true});
Zoom in on the given view position, with the desired scale factors. Note that this method will only have an effect if enabledOperations is set to ALL.
view x-coordinate
view y-coordinate
the scale factor over the X axis to apply (for example, a value of 2 doubles the scale)
the scale factor over the Y axis to apply (for example, a value of 2 doubles the scale)
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomInFixingWithScaleFactor() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({factor: {x: xScaleFactor, y: yScaleFactor}, location: createPoint(null, [x, y]), animate: true});
Perform an animated zoom out (by a fixed amount).
Note that this method will only have an effect if enabledOperations is set to ALL.
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomOut() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({factor: 0.5, animate: true});
Perform an animated zoom-out, fixing on the given view position (passed as x and y coordinates)
Note that this method will only have an effect if enabledOperations is set to ALL.
view x-coordinate
view y-coordinate
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomOutFixing() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({factor: 0.5, location: createPoint(null, [x, y]), animate: true});
Zoom out on the given view position, with the desired scale factors.
Note that this method will only have an effect if enabledOperations is set to ALL.
view x-coordinate
view y-coordinate
the scale factor over the X axis to apply (for example, a value of 2 halves the scale)
the scale factor over the Y axis to apply (for example, a value of 2 halves the scale)
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomOutFixingWithScaleFactor() has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({factor: {x: 1 / xScaleFactor, y: 1 / yScaleFactor}, location: createPoint(null, [x, y]), animate: true});
Perform an animated zoom so that the map has the desired scale.
Note that this method will only have an effect if enabledOperations is set to ALL.
the desired scale.
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomTo(scale) has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({targetScale: scale, animate: true});
Perform an animated zoom so that the map has the desired, non-uniform scale. Non uniform: the scale to be applied on the X-axis can differ from the scale applied on the Y axis. Scale factors for each axis must be passed in the scale array.
Note that this method will only have an effect if enabledOperations is set to ALL.
The desired scales for each view axis.
A promise which represents the completion of the animation. The promise will be resolved when the animation has completed. The promise will be rejected when the animation is interrupted.
mapNavigator.zoomTo(scale) has been deprecated. Use the new MapNavigator.zoom(zoomOptions) instead. You can replace this call with the new equivalent zoom:
map.mapNavigator.zoom({targetScale: scale, animate: true});
MapNavigatorprovides utility functions to navigate the map.A
MapNavigatorinstance can be obtained through the map.mapNavigator property.All operations are supported in both 2D and 3D. All operations also work on non-georeferenced views (e.g. vertical views or timelines).
All operations can be immediate or animated. The following operations are supported:
Most parameters take a point in either view (
point.reference === null), model (point.reference !== null) or map coordinates (point.reference === map.reference). See the JSdoc to check in which reference a point argument can be.Note that the Map can have navigation restrictions by using constraints. Constraints can be set on the
MapNavigatorvia mapNavigator.constraints. A detailed description of the available constraints and their behavior can be found in the documentation of MapNavigatorConstraintsWhen these constraints are set, it is not possible to violate these constraints by using the
MapNavigator. However, if you use the map's underlying camera directly, the constraints are not applied.