# all files / ol/ resolutionconstraint.js

91.67% Statements 22/24
70% Branches 7/10
100% Functions 4/4
91.67% Lines 22/24

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    671×

    1×
    1×

    1×
    47×

    110×
    110×

    110×
    110×
    110×
    2×
    2×

    108×

    1×
    379×

    447×
    447×
    447×

    447×
    447×
    447×

    447×

     goog.provide('ol.ResolutionConstraint');

    goog.require('ol.array');
    goog.require('ol.math');

    /**
     * @param {Array.<number>} resolutions Resolutions.
     * @return {ol.ResolutionConstraintType} Zoom function.
     */
    ol.ResolutionConstraint.createSnapToResolutions = function(resolutions) {
      return (
        /**
         * @param {number|undefined} resolution Resolution.
         * @param {number} delta Delta.
         * @param {number} direction Direction.
         * @return {number|undefined} Resolution.
         */
        function(resolution, delta, direction) {
          Eif (resolution !== undefined) {
            var z =
                  ol.array.linearFindNearest(resolutions, resolution, direction);
            z = ol.math.clamp(z + delta, 0, resolutions.length - 1);
            var index = Math.floor(z);
            if (z != index && index < resolutions.length - 1) {
              var power = resolutions[index] / resolutions[index + 1];
              return resolutions[index] / Math.pow(power, z - index);
            } else {
              return resolutions[index];
            }
          } else {
            return undefined;
          }
        });
    };

    /**
     * @param {number} power Power.
     * @param {number} maxResolution Maximum resolution.
     * @param {number=} opt_maxLevel Maximum level.
     * @return {ol.ResolutionConstraintType} Zoom function.
     */
    ol.ResolutionConstraint.createSnapToPower = function(power, maxResolution, opt_maxLevel) {
      return (
        /**
         * @param {number|undefined} resolution Resolution.
         * @param {number} delta Delta.
         * @param {number} direction Direction.
         * @return {number|undefined} Resolution.
         */
        function(resolution, delta, direction) {
          Eif (resolution !== undefined) {
            var offset = -direction / 2 + 0.5;
            var oldLevel = Math.floor(
                Math.log(maxResolution / resolution) / Math.log(power) + offset);
            var newLevel = Math.max(oldLevel + delta, 0);
            Eif (opt_maxLevel !== undefined) {
              newLevel = Math.min(newLevel, opt_maxLevel);
            }
            return maxResolution / Math.pow(power, newLevel);
          } else {
            return undefined;
          }
        });
    };