ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

View / refactor how zoom and resolution are computed

Browse Source 
This commit aims to simplify the computation of zoom and resolution in the
View class.

Previously zoom levels and resolution computations were mixed in different places,
ie resolution constraints, initial values, etc.

Now the View class only has the `getZoomForResolution` and `getResolutionForZoom`
methods to convert from one system to another.

Other than that, most computations use the resolution system internally.

The `constrainResolution` method also does not exist anymore, and is replaced
by `getValidResolution` and `getValidZoomLevel` public methods.
This commit is contained in:
Olivier Guyot
2019-01-14 16:34:29 +01:00
parent 1f379a06a4
commit 1c5fd62e43
5 changed files with 252 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
src/ol/View.js
View File

@@ -665,28 +665,6 @@ class View extends BaseObject {
return size;
}
/**
* 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.
* @private
*/
constrainResolution(resolution, opt_delta, opt_direction) {
const delta = opt_delta || 0;
const direction = opt_direction || 0;
const size = this.getSizeFromViewport_();
const rotation = this.getRotation() || 0;
const rotatedSize = [
Math.abs(size[0] * Math.cos(rotation)) + Math.abs(size[1] * Math.sin(rotation)),
Math.abs(size[0] * Math.sin(rotation)) + Math.abs(size[1] * Math.cos(rotation))
];
return this.constraints_.resolution(resolution, delta, direction, rotatedSize);
}
/**
* Get the view center.
* @return {import("./coordinate.js").Coordinate|undefined} The center of the view.
@@ -964,8 +942,14 @@ class View extends BaseObject {
* @api
*/
getResolutionForZoom(zoom) {
return /** @type {number} */ (this.constrainResolution(
this.maxResolution_, zoom - this.minZoom_, 0));
if (this.resolutions_) {
const baseLevel = clamp(Math.floor(zoom), 0, this.resolutions_.length - 2);
const zoomFactor = this.resolutions_[baseLevel] / this.resolutions_[baseLevel + 1];
return this.resolutions_[baseLevel] / Math.pow(zoomFactor, clamp(zoom - baseLevel, 0, 1));
} else {
return clamp(this.maxResolution_ / Math.pow(this.zoomFactor_, zoom - this.minZoom_),
this.minResolution_, this.maxResolution_);
}
}
/**
@@ -1008,8 +992,7 @@ class View extends BaseObject {
if (options.minResolution !== undefined) {
minResolution = options.minResolution;
} else if (options.maxZoom !== undefined) {
minResolution = this.constrainResolution(
this.maxResolution_, options.maxZoom - this.minZoom_, 0);
minResolution = this.getResolutionForZoom(options.maxZoom);
} else {
minResolution = 0;
}
@@ -1040,12 +1023,7 @@ class View extends BaseObject {
resolution = isNaN(resolution) ? minResolution :
Math.max(resolution, minResolution);
if (constrainResolution) {
let constrainedResolution = this.constrainResolution(resolution, 0, 0);
if (!nearest && constrainedResolution < resolution) {
constrainedResolution = this.constrainResolution(
constrainedResolution, -1, 0);
}
resolution = constrainedResolution;
resolution = this.getValidResolution(resolution, nearest ? 0 : 1);
}
// calculate center
@@ -1196,7 +1174,7 @@ class View extends BaseObject {
Math.abs(size[0] * Math.sin(rotation)) + Math.abs(size[1] * Math.cos(rotation))
];
const newResolution = this.constraints_.resolution(this.targetResolution_, 0, 0, rotatedSize, isMoving);
const newResolution = this.constraints_.resolution(this.targetResolution_, 0, rotatedSize, isMoving);
const newCenter = this.constraints_.center(this.targetCenter_, newResolution, rotatedSize, isMoving);
this.set(ViewProperty.ROTATION, newRotation);
@@ -1226,7 +1204,7 @@ class View extends BaseObject {
/**
* Get a valid zoom level according to the current view constraints.
* @param {number|undefined} targetZoom Target resolution.
* @param {number|undefined} targetZoom Target zoom.
* @param {number=} opt_direction Direction. Default is `0`. Specify `-1` or `1` to return
* the available value respectively lower or greater than the target one. Leaving `0` will simply choose
* the nearest available value.
@@ -1234,10 +1212,21 @@ class View extends BaseObject {
* @api
*/
getValidZoomLevel(targetZoom, opt_direction) {
const direction = opt_direction || 0;
const currentRes = this.getResolution();
const currentZoom = this.getZoom();
const targetRes = this.getResolutionForZoom(targetZoom);
return this.getZoomForResolution(this.getValidResolution(targetRes));
}
/**
* Get a valid resolution according to the current view constraints.
* @param {number|undefined} targetResolution Target resolution.
* @param {number=} opt_direction Direction. Default is `0`. Specify `-1` or `1` to return
* the available value respectively lower or greater than the target one. Leaving `0` will simply choose
* the nearest available value.
* @return {number|undefined} Valid resolution.
* @api
*/
getValidResolution(targetResolution, opt_direction) {
const direction = opt_direction || 0;
const size = this.getSizeFromViewport_();
const rotation = this.getRotation() || 0;
const rotatedSize = [
@@ -1245,8 +1234,7 @@ class View extends BaseObject {
Math.abs(size[0] * Math.sin(rotation)) + Math.abs(size[1] * Math.cos(rotation))
];
return this.getZoomForResolution(
this.constraints_.resolution(currentRes, targetZoom - currentZoom, direction, rotatedSize));
return(this.constraints_.resolution(targetResolution, direction, rotatedSize));
}
}
@@ -1350,7 +1338,7 @@ export function createResolutionConstraint(options) {
minResolution = maxResolution / Math.pow(zoomFactor, maxZoom - minZoom);
resolutionConstraint = createSnapToPower(
zoomFactor, maxResolution, maxZoom - minZoom,
zoomFactor, maxResolution, minResolution,
!options.constrainOnlyCenter && options.extent);
}
return {constraint: resolutionConstraint, maxResolution: maxResolution,

47
src/ol/resolutionconstraint.js
View File

@@ -4,10 +4,11 @@
import {linearFindNearest} from './array.js';
import {clamp} from './math.js';
import {getHeight, getWidth} from './extent';
import {clamp} from './math';
/**
* @typedef {function((number|undefined), number, number, import("./size.js").Size, boolean=): (number|undefined)} Type
* @typedef {function((number|undefined), number, import("./size.js").Size, boolean=): (number|undefined)} Type
*/
@@ -20,13 +21,12 @@ export function createSnapToResolutions(resolutions, opt_maxExtent) {
return (
/**
* @param {number|undefined} resolution Resolution.
* @param {number} delta Delta.
* @param {number} direction Direction.
* @param {import("./size.js").Size} size Viewport size.
* @param {boolean=} opt_isMoving True if an interaction or animation is in progress.
* @return {number|undefined} Resolution.
*/
function(resolution, delta, direction, size, opt_isMoving) {
function(resolution, direction, size, opt_isMoving) {
if (resolution !== undefined) {
let cappedRes = resolution;
@@ -39,19 +39,13 @@ export function createSnapToResolutions(resolutions, opt_maxExtent) {
// during interacting or animating, allow intermediary values
if (opt_isMoving) {
// TODO: actually take delta and direction into account
return Math.min(resolution, cappedRes);
const maxResolution = resolutions[0];
const minResolution = resolutions[resolutions.length - 1];
return clamp(cappedRes, minResolution, maxResolution);
}
let z = linearFindNearest(resolutions, cappedRes, direction);
z = clamp(z + delta, 0, resolutions.length - 1);
const index = Math.floor(z);
if (z != index && index < resolutions.length - 1) {
const power = resolutions[index] / resolutions[index + 1];
return resolutions[index] / Math.pow(power, z - index);
} else {
return resolutions[index];
}
let z = Math.floor(linearFindNearest(resolutions, cappedRes, direction));
return resolutions[z];
} else {
return undefined;
}
@@ -63,23 +57,22 @@ export function createSnapToResolutions(resolutions, opt_maxExtent) {
/**
* @param {number} power Power.
* @param {number} maxResolution Maximum resolution.
* @param {number=} opt_maxLevel Maximum level.
* @param {number=} opt_minResolution Minimum resolution.
* @param {import("./extent.js").Extent=} opt_maxExtent Maximum allowed extent.
* @return {Type} Zoom function.
*/
export function createSnapToPower(power, maxResolution, opt_maxLevel, opt_maxExtent) {
export function createSnapToPower(power, maxResolution, opt_minResolution, opt_maxExtent) {
return (
/**
* @param {number|undefined} resolution Resolution.
* @param {number} delta Delta.
* @param {number} direction Direction.
* @param {import("./size.js").Size} size Viewport size.
* @param {boolean=} opt_isMoving True if an interaction or animation is in progress.
* @return {number|undefined} Resolution.
*/
function(resolution, delta, direction, size, opt_isMoving) {
function(resolution, direction, size, opt_isMoving) {
if (resolution !== undefined) {
let cappedRes = resolution;
let cappedRes = Math.min(resolution, maxResolution);
// apply constraint related to max extent
if (opt_maxExtent) {
@@ -90,18 +83,16 @@ export function createSnapToPower(power, maxResolution, opt_maxLevel, opt_maxExt
// during interacting or animating, allow intermediary values
if (opt_isMoving) {
// TODO: actually take delta and direction into account
return Math.min(resolution, cappedRes);
return opt_minResolution !== undefined ? Math.max(opt_minResolution, cappedRes) : cappedRes;
}
const offset = -direction / 2 + 0.5;
const oldLevel = Math.floor(
const offset = -direction * (0.5 - 1e-9) + 0.5;
const zoomLevel = Math.floor(
Math.log(maxResolution / cappedRes) / Math.log(power) + offset);
let newLevel = Math.max(oldLevel + delta, 0);
if (opt_maxLevel !== undefined) {
newLevel = Math.min(newLevel, opt_maxLevel);
}
return maxResolution / Math.pow(power, newLevel);
let newResolution = maxResolution / Math.pow(power, zoomLevel);
return opt_minResolution !== undefined ?
clamp(newResolution, opt_minResolution, maxResolution) :
Math.min(maxResolution, newResolution);
} else {
return undefined;
}