776 lines
23 KiB
JavaScript
776 lines
23 KiB
JavaScript
goog.provide('ol.View2D');
|
|
goog.provide('ol.View2DProperty');
|
|
goog.provide('ol.ViewHint');
|
|
|
|
goog.require('goog.array');
|
|
goog.require('goog.asserts');
|
|
goog.require('ol');
|
|
goog.require('ol.CenterConstraint');
|
|
goog.require('ol.Constraints');
|
|
goog.require('ol.Object');
|
|
goog.require('ol.ResolutionConstraint');
|
|
goog.require('ol.RotationConstraint');
|
|
goog.require('ol.RotationConstraintType');
|
|
goog.require('ol.Size');
|
|
goog.require('ol.coordinate');
|
|
goog.require('ol.extent');
|
|
goog.require('ol.proj');
|
|
goog.require('ol.proj.METERS_PER_UNIT');
|
|
goog.require('ol.proj.Projection');
|
|
goog.require('ol.proj.Units');
|
|
|
|
|
|
/**
|
|
* @enum {string}
|
|
*/
|
|
ol.View2DProperty = {
|
|
CENTER: 'center',
|
|
PROJECTION: 'projection',
|
|
RESOLUTION: 'resolution',
|
|
ROTATION: 'rotation'
|
|
};
|
|
|
|
|
|
/**
|
|
* @enum {number}
|
|
*/
|
|
ol.ViewHint = {
|
|
ANIMATING: 0,
|
|
INTERACTING: 1
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* @classdesc
|
|
* An ol.View2D object represents a simple 2D view of the map.
|
|
*
|
|
* This is the object to act upon to change the center, resolution,
|
|
* and rotation of the map.
|
|
*
|
|
* ### The view states
|
|
*
|
|
* An `ol.View2D` is determined by three states: `center`, `resolution`,
|
|
* and `rotation`. To each state corresponds a getter and a setter. E.g.
|
|
* `getCenter` and `setCenter` for the `center` state.
|
|
*
|
|
* An `ol.View2D` has a `projection`. The projection determines the
|
|
* coordinate system of the center, and its units determine the units of the
|
|
* resolution (projection units per pixel). The default projection is
|
|
* Spherical Mercator (EPSG:3857).
|
|
*
|
|
* ### The constraints
|
|
*
|
|
* `setCenter`, `setResolution` and `setRotation` can be used to change the
|
|
* states of the view. Any value can be passed to the setters. And the value
|
|
* that is passed to a setter will effectively be the value set in the view,
|
|
* and returned by the corresponding getter.
|
|
*
|
|
* But an `ol.View2D` object also has a *resolution constraint*, a
|
|
* *rotation constraint* and a *center constraint*.
|
|
*
|
|
* As said above no constraints are applied when the setters are used to set
|
|
* new states for the view. Applying constraints is done explicitly through
|
|
* the use of the `constrain*` functions (`constrainResolution` and
|
|
* `constrainRotation` and `constrainCenter`).
|
|
*
|
|
* The main users of the constraints are the interactions and the
|
|
* controls. For example, double-clicking on the map changes the view to
|
|
* the "next" resolution. And releasing the fingers after pinch-zooming
|
|
* snaps to the closest resolution (with an animation).
|
|
*
|
|
* So the *resolution constraint* snaps to specific resolutions. It is
|
|
* determined by the following options: `resolutions`, `maxResolution`,
|
|
* `maxZoom`, and `zoomFactor`. If `resolutions` is set, the other three
|
|
* options are ignored. See {@link ol.View2DOptions} for more information.
|
|
*
|
|
* The *rotation constaint* is currently not configurable. It snaps the
|
|
* rotation value to zero when approaching the horizontal.
|
|
*
|
|
* @constructor
|
|
* @extends {ol.Object}
|
|
* @param {olx.View2DOptions=} opt_options View2D options.
|
|
* @todo api
|
|
*/
|
|
ol.View2D = function(opt_options) {
|
|
goog.base(this);
|
|
var options = goog.isDef(opt_options) ? opt_options : {};
|
|
|
|
/**
|
|
* @private
|
|
* @type {Array.<number>}
|
|
*/
|
|
this.hints_ = [0, 0];
|
|
|
|
/**
|
|
* @type {Object.<string, *>}
|
|
*/
|
|
var values = {};
|
|
values[ol.View2DProperty.CENTER] = goog.isDef(options.center) ?
|
|
options.center : null;
|
|
values[ol.View2DProperty.PROJECTION] = ol.proj.createProjection(
|
|
options.projection, 'EPSG:3857');
|
|
|
|
var resolutionConstraintInfo = ol.View2D.createResolutionConstraint_(
|
|
options);
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.maxResolution_ = resolutionConstraintInfo.maxResolution;
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.minResolution_ = resolutionConstraintInfo.minResolution;
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.minZoom_ = resolutionConstraintInfo.minZoom;
|
|
|
|
var centerConstraint = ol.View2D.createCenterConstraint_(options);
|
|
var resolutionConstraint = resolutionConstraintInfo.constraint;
|
|
var rotationConstraint = ol.View2D.createRotationConstraint_(options);
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.Constraints}
|
|
*/
|
|
this.constraints_ = new ol.Constraints(
|
|
centerConstraint, resolutionConstraint, rotationConstraint);
|
|
|
|
if (goog.isDef(options.resolution)) {
|
|
values[ol.View2DProperty.RESOLUTION] = options.resolution;
|
|
} else if (goog.isDef(options.zoom)) {
|
|
values[ol.View2DProperty.RESOLUTION] = this.constrainResolution(
|
|
this.maxResolution_, options.zoom - this.minZoom_);
|
|
}
|
|
values[ol.View2DProperty.ROTATION] =
|
|
goog.isDef(options.rotation) ? options.rotation : 0;
|
|
this.setValues(values);
|
|
};
|
|
goog.inherits(ol.View2D, ol.Object);
|
|
|
|
|
|
/**
|
|
* @param {number} rotation Target rotation.
|
|
* @param {ol.Coordinate} anchor Rotation anchor.
|
|
* @return {ol.Coordinate|undefined} Center for rotation and anchor.
|
|
*/
|
|
ol.View2D.prototype.calculateCenterRotate = function(rotation, anchor) {
|
|
var center;
|
|
var currentCenter = this.getCenter();
|
|
if (goog.isDef(currentCenter)) {
|
|
center = [currentCenter[0] - anchor[0], currentCenter[1] - anchor[1]];
|
|
ol.coordinate.rotate(center, rotation - this.getRotation());
|
|
ol.coordinate.add(center, anchor);
|
|
}
|
|
return center;
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {number} resolution Target resolution.
|
|
* @param {ol.Coordinate} anchor Zoom anchor.
|
|
* @return {ol.Coordinate|undefined} Center for resolution and anchor.
|
|
*/
|
|
ol.View2D.prototype.calculateCenterZoom = function(resolution, anchor) {
|
|
var center;
|
|
var currentCenter = this.getCenter();
|
|
var currentResolution = this.getResolution();
|
|
if (goog.isDef(currentCenter) && goog.isDef(currentResolution)) {
|
|
var x = anchor[0] -
|
|
resolution * (anchor[0] - currentCenter[0]) / currentResolution;
|
|
var y = anchor[1] -
|
|
resolution * (anchor[1] - currentCenter[1]) / currentResolution;
|
|
center = [x, y];
|
|
}
|
|
return center;
|
|
};
|
|
|
|
|
|
/**
|
|
* Get the constrained center of this view.
|
|
* @param {ol.Coordinate|undefined} center Center.
|
|
* @return {ol.Coordinate|undefined} Constrained center.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.constrainCenter = function(center) {
|
|
return this.constraints_.center(center);
|
|
};
|
|
|
|
|
|
/**
|
|
* Get the constrained resolution of this view.
|
|
* @param {number|undefined} resolution Resolution.
|
|
* @param {number=} opt_delta Delta. Default is `0`.
|
|
* @param {number=} opt_direction Direction. Default is `0`.
|
|
* @return {number|undefined} Constrained resolution.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.constrainResolution = function(
|
|
resolution, opt_delta, opt_direction) {
|
|
var delta = opt_delta || 0;
|
|
var direction = opt_direction || 0;
|
|
return this.constraints_.resolution(resolution, delta, direction);
|
|
};
|
|
|
|
|
|
/**
|
|
* Get the constrained rotation of this view.
|
|
* @param {number|undefined} rotation Rotation.
|
|
* @param {number=} opt_delta Delta. Default is `0`.
|
|
* @return {number|undefined} Constrained rotation.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.constrainRotation = function(rotation, opt_delta) {
|
|
var delta = opt_delta || 0;
|
|
return this.constraints_.rotation(rotation, delta);
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {ol.Coordinate|undefined} The center of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.getCenter = function() {
|
|
return /** @type {ol.Coordinate|undefined} */ (
|
|
this.get(ol.View2DProperty.CENTER));
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'getCenter',
|
|
ol.View2D.prototype.getCenter);
|
|
|
|
|
|
/**
|
|
* @return {Array.<number>} Hint.
|
|
*/
|
|
ol.View2D.prototype.getHints = function() {
|
|
return goog.array.clone(this.hints_);
|
|
};
|
|
|
|
|
|
/**
|
|
* Calculate the extent for the given size in pixels, based on the current
|
|
* resolution and the current center.
|
|
* @param {ol.Size} size Box pixel size.
|
|
* @return {ol.Extent} Extent.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.calculateExtent = function(size) {
|
|
goog.asserts.assert(this.isDef());
|
|
var center = this.getCenter();
|
|
var resolution = this.getResolution();
|
|
var minX = center[0] - resolution * size[0] / 2;
|
|
var maxX = center[0] + resolution * size[0] / 2;
|
|
var minY = center[1] - resolution * size[1] / 2;
|
|
var maxY = center[1] + resolution * size[1] / 2;
|
|
return [minX, minY, maxX, maxY];
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {ol.proj.Projection|undefined} The projection of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.getProjection = function() {
|
|
return /** @type {ol.proj.Projection|undefined} */ (
|
|
this.get(ol.View2DProperty.PROJECTION));
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'getProjection',
|
|
ol.View2D.prototype.getProjection);
|
|
|
|
|
|
/**
|
|
* @return {number|undefined} The resolution of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.getResolution = function() {
|
|
return /** @type {number|undefined} */ (
|
|
this.get(ol.View2DProperty.RESOLUTION));
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'getResolution',
|
|
ol.View2D.prototype.getResolution);
|
|
|
|
|
|
/**
|
|
* Get the resolution for a provided extent (in map units) and size (in pixels).
|
|
* @param {ol.Extent} extent Extent.
|
|
* @param {ol.Size} size Box pixel size.
|
|
* @return {number} The resolution at which the provided extent will render at
|
|
* the given size.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.getResolutionForExtent = function(extent, size) {
|
|
var xResolution = ol.extent.getWidth(extent) / size[0];
|
|
var yResolution = ol.extent.getHeight(extent) / size[1];
|
|
return Math.max(xResolution, yResolution);
|
|
};
|
|
|
|
|
|
/**
|
|
* Return a function that returns a value between 0 and 1 for a
|
|
* resolution. Exponential scaling is assumed.
|
|
* @param {number=} opt_power Power.
|
|
* @return {function(number): number} Resolution for value function.
|
|
*/
|
|
ol.View2D.prototype.getResolutionForValueFunction = function(opt_power) {
|
|
var power = opt_power || 2;
|
|
var maxResolution = this.maxResolution_;
|
|
var minResolution = this.minResolution_;
|
|
var max = Math.log(maxResolution / minResolution) / Math.log(power);
|
|
return (
|
|
/**
|
|
* @param {number} value Value.
|
|
* @return {number} Resolution.
|
|
*/
|
|
function(value) {
|
|
var resolution = maxResolution / Math.pow(power, value * max);
|
|
goog.asserts.assert(resolution >= minResolution &&
|
|
resolution <= maxResolution);
|
|
return resolution;
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {number|undefined} The rotation of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.getRotation = function() {
|
|
return /** @type {number|undefined} */ (this.get(ol.View2DProperty.ROTATION));
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'getRotation',
|
|
ol.View2D.prototype.getRotation);
|
|
|
|
|
|
/**
|
|
* Return a function that returns a resolution for a value between
|
|
* 0 and 1. Exponential scaling is assumed.
|
|
* @param {number=} opt_power Power.
|
|
* @return {function(number): number} Value for resolution function.
|
|
*/
|
|
ol.View2D.prototype.getValueForResolutionFunction = function(opt_power) {
|
|
var power = opt_power || 2;
|
|
var maxResolution = this.maxResolution_;
|
|
var minResolution = this.minResolution_;
|
|
var max = Math.log(maxResolution / minResolution) / Math.log(power);
|
|
return (
|
|
/**
|
|
* @param {number} resolution Resolution.
|
|
* @return {number} Value.
|
|
*/
|
|
function(resolution) {
|
|
var value =
|
|
(Math.log(maxResolution / resolution) / Math.log(power)) / max;
|
|
goog.asserts.assert(value >= 0 && value <= 1);
|
|
return value;
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {olx.View2DState} View2D state.
|
|
*/
|
|
ol.View2D.prototype.getState = function() {
|
|
goog.asserts.assert(this.isDef());
|
|
var center = /** @type {ol.Coordinate} */ (this.getCenter());
|
|
var projection = this.getProjection();
|
|
var resolution = /** @type {number} */ (this.getResolution());
|
|
var rotation = this.getRotation();
|
|
return /** @type {olx.View2DState} */ ({
|
|
center: center.slice(),
|
|
projection: goog.isDef(projection) ? projection : null,
|
|
resolution: resolution,
|
|
rotation: goog.isDef(rotation) ? rotation : 0
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* Get the current zoom level. Return undefined if the current
|
|
* resolution is undefined or not a "constrained resolution".
|
|
* @return {number|undefined} Zoom.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.getZoom = function() {
|
|
var offset;
|
|
var resolution = this.getResolution();
|
|
|
|
if (goog.isDef(resolution)) {
|
|
var res, z = 0;
|
|
do {
|
|
res = this.constrainResolution(this.maxResolution_, z);
|
|
if (res == resolution) {
|
|
offset = z;
|
|
break;
|
|
}
|
|
++z;
|
|
} while (res > this.minResolution_);
|
|
}
|
|
|
|
return goog.isDef(offset) ? this.minZoom_ + offset : offset;
|
|
};
|
|
|
|
|
|
/**
|
|
* Fit the given extent based on the given map size.
|
|
* @param {ol.Extent} extent Extent.
|
|
* @param {ol.Size} size Box pixel size.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.fitExtent = function(extent, size) {
|
|
if (!ol.extent.isEmpty(extent)) {
|
|
this.setCenter(ol.extent.getCenter(extent));
|
|
var resolution = this.getResolutionForExtent(extent, size);
|
|
var constrainedResolution = this.constrainResolution(resolution, 0, 0);
|
|
if (constrainedResolution < resolution) {
|
|
constrainedResolution =
|
|
this.constrainResolution(constrainedResolution, -1, 0);
|
|
}
|
|
this.setResolution(constrainedResolution);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Fit the given geometry based on the given map size and border.
|
|
* Take care on the map angle.
|
|
* @param {ol.geom.SimpleGeometry} geometry Geometry.
|
|
* @param {ol.Size} size Box pixel size.
|
|
* @param {olx.View2D.fitGeometryOptions=} opt_options Options.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.fitGeometry = function(geometry, size, opt_options) {
|
|
var options = goog.isDef(opt_options) ? opt_options : {};
|
|
|
|
var padding = goog.isDef(options.padding) ? options.padding : [0, 0, 0, 0];
|
|
var constrainResolution = goog.isDef(options.constrainResolution) ?
|
|
options.constrainResolution : true;
|
|
var nearest = goog.isDef(options.nearest) ? options.nearest : false;
|
|
var minResolution = goog.isDef(options.minResolution) ?
|
|
options.minResolution : 0;
|
|
var coords = geometry.getFlatCoordinates();
|
|
|
|
// calculate rotated extent
|
|
var rotation = this.getRotation();
|
|
goog.asserts.assert(goog.isDef(rotation));
|
|
var cosAngle = Math.cos(-rotation);
|
|
var sinAngle = Math.sin(-rotation);
|
|
var minRotX = +Infinity;
|
|
var minRotY = +Infinity;
|
|
var maxRotX = -Infinity;
|
|
var maxRotY = -Infinity;
|
|
var stride = geometry.getStride();
|
|
for (var i = 0, ii = coords.length; i < ii; i += stride) {
|
|
var rotX = coords[i] * cosAngle - coords[i + 1] * sinAngle;
|
|
var rotY = coords[i] * sinAngle + coords[i + 1] * cosAngle;
|
|
minRotX = Math.min(minRotX, rotX);
|
|
minRotY = Math.min(minRotY, rotY);
|
|
maxRotX = Math.max(maxRotX, rotX);
|
|
maxRotY = Math.max(maxRotY, rotY);
|
|
}
|
|
|
|
// calculate resolution
|
|
var resolution = this.getResolutionForExtent(
|
|
[minRotX, minRotY, maxRotX, maxRotY],
|
|
[size[0] - padding[1] - padding[3], size[1] - padding[0] - padding[2]]);
|
|
resolution = isNaN(resolution) ? minResolution :
|
|
Math.max(resolution, minResolution);
|
|
if (constrainResolution) {
|
|
var constrainedResolution = this.constrainResolution(resolution, 0, 0);
|
|
if (!nearest && constrainedResolution < resolution) {
|
|
constrainedResolution = this.constrainResolution(
|
|
constrainedResolution, -1, 0);
|
|
}
|
|
resolution = constrainedResolution;
|
|
}
|
|
this.setResolution(resolution);
|
|
|
|
// calculate center
|
|
sinAngle = -sinAngle; // go back to original rotation
|
|
var centerRotX = (minRotX + maxRotX) / 2;
|
|
var centerRotY = (minRotY + maxRotY) / 2;
|
|
centerRotX += (padding[1] - padding[3]) / 2 * resolution;
|
|
centerRotY += (padding[0] - padding[2]) / 2 * resolution;
|
|
var centerX = centerRotX * cosAngle - centerRotY * sinAngle;
|
|
var centerY = centerRotY * cosAngle + centerRotX * sinAngle;
|
|
|
|
this.setCenter([centerX, centerY]);
|
|
};
|
|
|
|
|
|
/**
|
|
* Center on coordinate and view position.
|
|
* Take care on the map angle.
|
|
* @param {ol.Coordinate} coordinate Coordinate.
|
|
* @param {ol.Size} size Box pixel size.
|
|
* @param {ol.Pixel} position Position on the view to center on.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.centerOn = function(coordinate, size, position) {
|
|
// calculate rotated position
|
|
var rotation = this.getRotation();
|
|
var cosAngle = Math.cos(-rotation);
|
|
var sinAngle = Math.sin(-rotation);
|
|
var rotX = coordinate[0] * cosAngle - coordinate[1] * sinAngle;
|
|
var rotY = coordinate[1] * cosAngle + coordinate[0] * sinAngle;
|
|
var resolution = this.getResolution();
|
|
rotX += (size[0] / 2 - position[0]) * resolution;
|
|
rotY += (position[1] - size[1] / 2) * resolution;
|
|
|
|
// go back to original angle
|
|
sinAngle = -sinAngle; // go back to original rotation
|
|
var centerX = rotX * cosAngle - rotY * sinAngle;
|
|
var centerY = rotY * cosAngle + rotX * sinAngle;
|
|
|
|
this.setCenter([centerX, centerY]);
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {boolean} Is defined.
|
|
*/
|
|
ol.View2D.prototype.isDef = function() {
|
|
return goog.isDefAndNotNull(this.getCenter()) &&
|
|
goog.isDef(this.getResolution());
|
|
};
|
|
|
|
|
|
/**
|
|
* Rotate the view around a given coordinate.
|
|
* @param {number} rotation New rotation value for the view.
|
|
* @param {ol.Coordinate=} opt_anchor The rotation center.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.rotate = function(rotation, opt_anchor) {
|
|
if (goog.isDef(opt_anchor)) {
|
|
var center = this.calculateCenterRotate(rotation, opt_anchor);
|
|
this.setCenter(center);
|
|
}
|
|
this.setRotation(rotation);
|
|
};
|
|
|
|
|
|
/**
|
|
* Set the center of the current view.
|
|
* @param {ol.Coordinate|undefined} center The center of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.setCenter = function(center) {
|
|
this.set(ol.View2DProperty.CENTER, center);
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'setCenter',
|
|
ol.View2D.prototype.setCenter);
|
|
|
|
|
|
/**
|
|
* @param {ol.ViewHint} hint Hint.
|
|
* @param {number} delta Delta.
|
|
* @return {number} New value.
|
|
*/
|
|
ol.View2D.prototype.setHint = function(hint, delta) {
|
|
goog.asserts.assert(0 <= hint && hint < this.hints_.length);
|
|
this.hints_[hint] += delta;
|
|
goog.asserts.assert(this.hints_[hint] >= 0);
|
|
return this.hints_[hint];
|
|
};
|
|
|
|
|
|
/**
|
|
* Set the projection of this view.
|
|
* Warning! This code is not yet implemented. Function should not be used.
|
|
* @param {ol.proj.Projection|undefined} projection The projection of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.setProjection = function(projection) {
|
|
this.set(ol.View2DProperty.PROJECTION, projection);
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'setProjection',
|
|
ol.View2D.prototype.setProjection);
|
|
|
|
|
|
/**
|
|
* Set the resolution for this view.
|
|
* @param {number|undefined} resolution The resolution of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.setResolution = function(resolution) {
|
|
this.set(ol.View2DProperty.RESOLUTION, resolution);
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'setResolution',
|
|
ol.View2D.prototype.setResolution);
|
|
|
|
|
|
/**
|
|
* Set the rotation for this view.
|
|
* @param {number|undefined} rotation The rotation of the view.
|
|
* @todo observable
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.setRotation = function(rotation) {
|
|
this.set(ol.View2DProperty.ROTATION, rotation);
|
|
};
|
|
goog.exportProperty(
|
|
ol.View2D.prototype,
|
|
'setRotation',
|
|
ol.View2D.prototype.setRotation);
|
|
|
|
|
|
/**
|
|
* Zoom to a specific zoom level.
|
|
* @param {number} zoom Zoom level.
|
|
* @todo api
|
|
*/
|
|
ol.View2D.prototype.setZoom = function(zoom) {
|
|
var resolution = this.constrainResolution(
|
|
this.maxResolution_, zoom - this.minZoom_, 0);
|
|
this.setResolution(resolution);
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {olx.View2DOptions} options View2D options.
|
|
* @private
|
|
* @return {ol.CenterConstraintType}
|
|
*/
|
|
ol.View2D.createCenterConstraint_ = function(options) {
|
|
if (goog.isDef(options.extent)) {
|
|
return ol.CenterConstraint.createExtent(options.extent);
|
|
} else {
|
|
return ol.CenterConstraint.none;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @private
|
|
* @param {olx.View2DOptions} options View2D options.
|
|
* @return {{constraint: ol.ResolutionConstraintType, maxResolution: number,
|
|
* minResolution: number}}
|
|
*/
|
|
ol.View2D.createResolutionConstraint_ = function(options) {
|
|
var resolutionConstraint;
|
|
var maxResolution;
|
|
var minResolution;
|
|
|
|
// TODO: move these to be ol constants
|
|
// see https://github.com/openlayers/ol3/issues/2076
|
|
var defaultMaxZoom = 28;
|
|
var defaultZoomFactor = 2;
|
|
|
|
var minZoom = goog.isDef(options.minZoom) ?
|
|
options.minZoom : ol.DEFAULT_MIN_ZOOM;
|
|
|
|
var maxZoom = goog.isDef(options.maxZoom) ?
|
|
options.maxZoom : defaultMaxZoom;
|
|
|
|
var zoomFactor = goog.isDef(options.zoomFactor) ?
|
|
options.zoomFactor : defaultZoomFactor;
|
|
|
|
if (goog.isDef(options.resolutions)) {
|
|
var resolutions = options.resolutions;
|
|
maxResolution = resolutions[0];
|
|
minResolution = resolutions[resolutions.length - 1];
|
|
resolutionConstraint = ol.ResolutionConstraint.createSnapToResolutions(
|
|
resolutions);
|
|
} else {
|
|
// calculate the default min and max resolution
|
|
var projection = options.projection;
|
|
var extent = ol.proj.createProjection(projection, 'EPSG:3857').getExtent();
|
|
var size = goog.isNull(extent) ?
|
|
// use an extent that can fit the whole world if need be
|
|
360 * ol.proj.METERS_PER_UNIT[ol.proj.Units.DEGREES] /
|
|
ol.proj.METERS_PER_UNIT[projection.getUnits()] :
|
|
Math.max(ol.extent.getWidth(extent), ol.extent.getHeight(extent));
|
|
|
|
var defaultMaxResolution = size / ol.DEFAULT_TILE_SIZE / Math.pow(
|
|
defaultZoomFactor, ol.DEFAULT_MIN_ZOOM);
|
|
|
|
var defaultMinResolution = defaultMaxResolution / Math.pow(
|
|
defaultZoomFactor, defaultMaxZoom - ol.DEFAULT_MIN_ZOOM);
|
|
|
|
// user provided maxResolution takes precedence
|
|
maxResolution = options.maxResolution;
|
|
if (goog.isDef(maxResolution)) {
|
|
minZoom = 0;
|
|
} else {
|
|
maxResolution = defaultMaxResolution / Math.pow(zoomFactor, minZoom);
|
|
}
|
|
|
|
// user provided minResolution takes precedence
|
|
minResolution = options.minResolution;
|
|
if (!goog.isDef(minResolution)) {
|
|
if (goog.isDef(options.maxZoom)) {
|
|
if (goog.isDef(options.maxResolution)) {
|
|
minResolution = maxResolution / Math.pow(zoomFactor, maxZoom);
|
|
} else {
|
|
minResolution = defaultMaxResolution / Math.pow(zoomFactor, maxZoom);
|
|
}
|
|
} else {
|
|
minResolution = defaultMinResolution;
|
|
}
|
|
}
|
|
|
|
// given discrete zoom levels, minResolution may be different than provided
|
|
maxZoom = minZoom + Math.floor(
|
|
Math.log(maxResolution / minResolution) / Math.log(zoomFactor));
|
|
minResolution = maxResolution / Math.pow(zoomFactor, maxZoom - minZoom);
|
|
|
|
resolutionConstraint = ol.ResolutionConstraint.createSnapToPower(
|
|
zoomFactor, maxResolution, maxZoom - minZoom);
|
|
}
|
|
return {constraint: resolutionConstraint, maxResolution: maxResolution,
|
|
minResolution: minResolution, minZoom: minZoom};
|
|
};
|
|
|
|
|
|
/**
|
|
* @private
|
|
* @param {olx.View2DOptions} options View2D options.
|
|
* @return {ol.RotationConstraintType} Rotation constraint.
|
|
*/
|
|
ol.View2D.createRotationConstraint_ = function(options) {
|
|
var enableRotation = goog.isDef(options.enableRotation) ?
|
|
options.enableRotation : true;
|
|
if (enableRotation) {
|
|
var constrainRotation = options.constrainRotation;
|
|
if (!goog.isDef(constrainRotation) || constrainRotation === true) {
|
|
return ol.RotationConstraint.createSnapToZero();
|
|
} else if (constrainRotation === false) {
|
|
return ol.RotationConstraint.none;
|
|
} else if (goog.isNumber(constrainRotation)) {
|
|
return ol.RotationConstraint.createSnapToN(constrainRotation);
|
|
} else {
|
|
goog.asserts.fail();
|
|
return ol.RotationConstraint.none;
|
|
}
|
|
} else {
|
|
return ol.RotationConstraint.disable;
|
|
}
|
|
};
|