@mapgis/mapbox-gl 1.9.10 → 16.0.0

package/src/source/worker.js

@@ -0,0 +1,237 @@
+// @flow
+
+import Actor from '../util/actor';
+
+import StyleLayerIndex from '../style/style_layer_index';
+import VectorTileWorkerSource from './vector_tile_worker_source';
+import RasterDEMTileWorkerSource from './raster_dem_tile_worker_source';
+import RasterTileSourceOffline from './raster_tile_offline_source';
+import GeoJSONWorkerSource from './geojson_worker_source';
+import assert from 'assert';
+import {plugin as globalRTLTextPlugin} from './rtl_text_plugin';
+import {enforceCacheSizeLimit} from '../util/tile_request_cache';
+
+import type {
+    WorkerSource,
+    WorkerTileParameters,
+    WorkerDEMTileParameters,
+    WorkerTileCallback,
+    WorkerDEMTileCallback,
+    TileParameters
+} from '../source/worker_source';
+
+import type {WorkerGlobalScopeInterface} from '../util/web_worker';
+import type {Callback} from '../types/callback';
+import type {LayerSpecification} from '../style-spec/types';
+import type {PluginState} from './rtl_text_plugin';
+
+/**
+ * @private
+ */
+export default class Worker {
+    self: WorkerGlobalScopeInterface;
+    actor: Actor;
+    layerIndexes: {[_: string]: StyleLayerIndex };
+    availableImages: {[_: string]: Array<string> };
+    workerSourceTypes: {[_: string]: Class<WorkerSource> };
+    workerSources: {[_: string]: {[_: string]: {[_: string]: WorkerSource } } };
+    demWorkerSources: {[_: string]: {[_: string]: RasterDEMTileWorkerSource } };
+    referrer: ?string;
+
+    constructor(self: WorkerGlobalScopeInterface) {
+        this.self = self;
+        this.actor = new Actor(self, this);
+
+        this.layerIndexes = {};
+        this.availableImages = {};
+
+        this.workerSourceTypes = {
+            vector: VectorTileWorkerSource,
+            mbtiles: VectorTileWorkerSource,
+            geojson: GeoJSONWorkerSource,
+            rasteroffline: RasterTileSourceOffline
+        };
+
+        // [mapId][sourceType][sourceName] => worker source instance
+        this.workerSources = {};
+        this.demWorkerSources = {};
+
+        this.self.registerWorkerSource = (name: string, WorkerSource: Class<WorkerSource>) => {
+            if (this.workerSourceTypes[name]) {
+                throw new Error(`Worker source with name "${name}" already registered.`);
+            }
+            this.workerSourceTypes[name] = WorkerSource;
+        };
+
+        // This is invoked by the RTL text plugin when the download via the `importScripts` call has finished, and the code has been parsed.
+        this.self.registerRTLTextPlugin = (rtlTextPlugin: {applyArabicShaping: Function, processBidirectionalText: Function, processStyledBidirectionalText?: Function}) => {
+            if (globalRTLTextPlugin.isParsed()) {
+                throw new Error('RTL text plugin already registered.');
+            }
+            globalRTLTextPlugin['applyArabicShaping'] = rtlTextPlugin.applyArabicShaping;
+            globalRTLTextPlugin['processBidirectionalText'] = rtlTextPlugin.processBidirectionalText;
+            globalRTLTextPlugin['processStyledBidirectionalText'] = rtlTextPlugin.processStyledBidirectionalText;
+        };
+    }
+
+    setReferrer(mapID: string, referrer: string) {
+        this.referrer = referrer;
+    }
+
+    setImages(mapId: string, images: Array<string>, callback: WorkerTileCallback) {
+        this.availableImages[mapId] = images;
+        callback();
+    }
+
+    setLayers(mapId: string, layers: Array<LayerSpecification>, callback: WorkerTileCallback) {
+        this.getLayerIndex(mapId).replace(layers);
+        callback();
+    }
+
+    updateLayers(mapId: string, params: {layers: Array<LayerSpecification>, removedIds: Array<string>}, callback: WorkerTileCallback) {
+        this.getLayerIndex(mapId).update(params.layers, params.removedIds);
+        callback();
+    }
+
+    loadTile(mapId: string, params: WorkerTileParameters & {type: string}, callback: WorkerTileCallback) {
+        assert(params.type);
+        this.getWorkerSource(mapId, params.type, params.source).loadTile(params, callback);
+    }
+
+    loadDEMTile(mapId: string, params: WorkerDEMTileParameters, callback: WorkerDEMTileCallback) {
+        this.getDEMWorkerSource(mapId, params.source).loadTile(params, callback);
+    }
+
+    reloadTile(mapId: string, params: WorkerTileParameters & {type: string}, callback: WorkerTileCallback) {
+        assert(params.type);
+        this.getWorkerSource(mapId, params.type, params.source).reloadTile(params, callback);
+    }
+
+    abortTile(mapId: string, params: TileParameters & {type: string}, callback: WorkerTileCallback) {
+        assert(params.type);
+        this.getWorkerSource(mapId, params.type, params.source).abortTile(params, callback);
+    }
+
+    removeTile(mapId: string, params: TileParameters & {type: string}, callback: WorkerTileCallback) {
+        assert(params.type);
+        this.getWorkerSource(mapId, params.type, params.source).removeTile(params, callback);
+    }
+
+    removeDEMTile(mapId: string, params: TileParameters) {
+        this.getDEMWorkerSource(mapId, params.source).removeTile(params);
+    }
+
+    removeSource(mapId: string, params: {source: string} & {type: string}, callback: WorkerTileCallback) {
+        assert(params.type);
+        assert(params.source);
+
+        if (!this.workerSources[mapId] ||
+            !this.workerSources[mapId][params.type] ||
+            !this.workerSources[mapId][params.type][params.source]) {
+            return;
+        }
+
+        const worker = this.workerSources[mapId][params.type][params.source];
+        delete this.workerSources[mapId][params.type][params.source];
+
+        if (worker.removeSource !== undefined) {
+            worker.removeSource(params, callback);
+        } else {
+            callback();
+        }
+    }
+
+    /**
+     * Load a {@link WorkerSource} script at params.url.  The script is run
+     * (using importScripts) with `registerWorkerSource` in scope, which is a
+     * function taking `(name, workerSourceObject)`.
+     *  @private
+     */
+    loadWorkerSource(map: string, params: { url: string }, callback: Callback<void>) {
+        try {
+            this.self.importScripts(params.url);
+            callback();
+        } catch (e) {
+            callback(e.toString());
+        }
+    }
+
+    syncRTLPluginState(map: string, state: PluginState, callback: Callback<boolean>) {
+        try {
+            globalRTLTextPlugin.setState(state);
+            const pluginURL = globalRTLTextPlugin.getPluginURL();
+            if (
+                globalRTLTextPlugin.isLoaded() &&
+                !globalRTLTextPlugin.isParsed() &&
+                pluginURL != null // Not possible when `isLoaded` is true, but keeps flow happy
+            ) {
+                this.self.importScripts(pluginURL);
+                const complete = globalRTLTextPlugin.isParsed();
+                const error = complete ? undefined : new Error(`RTL Text Plugin failed to import scripts from ${pluginURL}`);
+                callback(error, complete);
+            }
+        } catch (e) {
+            callback(e.toString());
+        }
+    }
+
+    getAvailableImages(mapId: string) {
+        let availableImages = this.availableImages[mapId];
+
+        if (!availableImages) {
+            availableImages = [];
+        }
+
+        return availableImages;
+    }
+
+    getLayerIndex(mapId: string) {
+        let layerIndexes = this.layerIndexes[mapId];
+        if (!layerIndexes) {
+            layerIndexes = this.layerIndexes[mapId] = new StyleLayerIndex();
+        }
+        return layerIndexes;
+    }
+
+    getWorkerSource(mapId: string, type: string, source: string) {
+        if (!this.workerSources[mapId])
+            this.workerSources[mapId] = {};
+        if (!this.workerSources[mapId][type])
+            this.workerSources[mapId][type] = {};
+
+        if (!this.workerSources[mapId][type][source]) {
+            // use a wrapped actor so that we can attach a target mapId param
+            // to any messages invoked by the WorkerSource
+            const actor = {
+                send: (type, data, callback) => {
+                    this.actor.send(type, data, callback, mapId);
+                }
+            };
+            this.workerSources[mapId][type][source] = new (this.workerSourceTypes[type]: any)((actor: any), this.getLayerIndex(mapId), this.getAvailableImages(mapId));
+        }
+
+        return this.workerSources[mapId][type][source];
+    }
+
+    getDEMWorkerSource(mapId: string, source: string) {
+        if (!this.demWorkerSources[mapId])
+            this.demWorkerSources[mapId] = {};
+
+        if (!this.demWorkerSources[mapId][source]) {
+            this.demWorkerSources[mapId][source] = new RasterDEMTileWorkerSource();
+        }
+
+        return this.demWorkerSources[mapId][source];
+    }
+
+    enforceCacheSizeLimit(mapId: string, limit: number) {
+        enforceCacheSizeLimit(limit);
+    }
+}
+
+/* global self, WorkerGlobalScope */
+if (typeof WorkerGlobalScope !== 'undefined' &&
+    typeof self !== 'undefined' &&
+    self instanceof WorkerGlobalScope) {
+    self.worker = new Worker(self);
+}

package/src/source/worker_source.js

@@ -0,0 +1,106 @@
+// @flow
+
+import type {RequestParameters} from '../util/ajax';
+import type {RGBAImage, AlphaImage} from '../util/image';
+import type {GlyphPositions} from '../render/glyph_atlas';
+import type ImageAtlas from '../render/image_atlas';
+import type {OverscaledTileID} from './tile_id';
+import type {Bucket} from '../data/bucket';
+import type FeatureIndex from '../data/feature_index';
+import type {CollisionBoxArray} from '../data/array_types';
+import type DEMData from '../data/dem_data';
+import type {StyleGlyph} from '../style/style_glyph';
+import type {StyleImage} from '../style/style_image';
+import type {PromoteIdSpecification} from '../style-spec/types';
+import window from '../util/window';
+const {ImageBitmap} = window;
+
+export type TileParameters = {
+    source: string,
+    uid: string,
+};
+
+export type WorkerTileParameters = TileParameters & {
+    tileID: OverscaledTileID,
+    request: RequestParameters,
+    zoom: number,
+    maxZoom: number,
+    tileSize: number,
+    promoteId: ?PromoteIdSpecification,
+    pixelRatio: number,
+    showCollisionBoxes: boolean,
+    collectResourceTiming?: boolean,
+    returnDependencies?: boolean
+};
+
+export type WorkerDEMTileParameters = TileParameters & {
+    coord: { z: number, x: number, y: number, w: number },
+    rawImageData: RGBAImage | ImageBitmap,
+    encoding: "mapbox" | "terrarium"
+};
+
+export type WorkerTileResult = {
+    buckets: Array<Bucket>,
+    imageAtlas: ImageAtlas,
+    glyphAtlasImage: AlphaImage,
+    featureIndex: FeatureIndex,
+    collisionBoxArray: CollisionBoxArray,
+    rawTileData?: ArrayBuffer,
+    resourceTiming?: Array<PerformanceResourceTiming>,
+    // Only used for benchmarking:
+    glyphMap?: {[_: string]: {[_: number]: ?StyleGlyph}} | null,
+    iconMap?: {[_: string]: StyleImage} | null,
+    glyphPositions?: GlyphPositions | null
+};
+
+export type WorkerTileCallback = (error: ?Error, result: ?WorkerTileResult) => void;
+export type WorkerDEMTileCallback = (err: ?Error, result: ?DEMData) => void;
+
+/**
+ * May be implemented by custom source types to provide code that can be run on
+ * the WebWorkers. In addition to providing a custom
+ * {@link WorkerSource#loadTile}, any other methods attached to a `WorkerSource`
+ * implementation may also be targeted by the {@link Source} via
+ * `dispatcher.getActor().send('source-type.methodname', params, callback)`.
+ *
+ * @see {@link Map#addSourceType}
+ * @private
+ *
+ * @class WorkerSource
+ * @param actor
+ * @param layerIndex
+ */
+export interface WorkerSource {
+    // Disabled due to https://github.com/facebook/flow/issues/5208
+    // constructor(actor: Actor, layerIndex: StyleLayerIndex): WorkerSource;
+
+    /**
+     * Loads a tile from the given params and parse it into buckets ready to send
+     * back to the main thread for rendering.  Should call the callback with:
+     * `{ buckets, featureIndex, collisionIndex, rawTileData}`.
+     */
+    loadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
+
+    /**
+     * Re-parses a tile that has already been loaded.  Yields the same data as
+     * {@link WorkerSource#loadTile}.
+     */
+    reloadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
+
+    /**
+     * Aborts loading a tile that is in progress.
+     */
+    abortTile(params: TileParameters, callback: WorkerTileCallback): void;
+
+    /**
+     * Removes this tile from any local caches.
+     */
+    removeTile(params: TileParameters, callback: WorkerTileCallback): void;
+
+    /**
+     * Tells the WorkerSource to abort in-progress tasks and release resources.
+     * The foreground Source is responsible for ensuring that 'removeSource' is
+     * the last message sent to the WorkerSource.
+     */
+    removeSource?: (params: {source: string}, callback: WorkerTileCallback) => void;
+}

package/src/source/worker_tile.js

@@ -0,0 +1,224 @@
+// @flow
+
+import FeatureIndex from '../data/feature_index';
+
+import {performSymbolLayout} from '../symbol/symbol_layout';
+import {CollisionBoxArray} from '../data/array_types';
+import DictionaryCoder from '../util/dictionary_coder';
+import SymbolBucket from '../data/bucket/symbol_bucket';
+import LineBucket from '../data/bucket/line_bucket';
+import FillBucket from '../data/bucket/fill_bucket';
+import FillExtrusionBucket from '../data/bucket/fill_extrusion_bucket';
+import {warnOnce, mapObject, values} from '../util/util';
+import assert from 'assert';
+import ImageAtlas from '../render/image_atlas';
+import GlyphAtlas from '../render/glyph_atlas';
+import EvaluationParameters from '../style/evaluation_parameters';
+import {OverscaledTileID} from './tile_id';
+
+import type {Bucket} from '../data/bucket';
+import type Actor from '../util/actor';
+import type StyleLayer from '../style/style_layer';
+import type StyleLayerIndex from '../style/style_layer_index';
+import type {StyleImage} from '../style/style_image';
+import type {StyleGlyph} from '../style/style_glyph';
+import type {
+    WorkerTileParameters,
+    WorkerTileCallback,
+} from '../source/worker_source';
+import type {PromoteIdSpecification} from '../style-spec/types';
+
+class WorkerTile {
+    tileID: OverscaledTileID;
+    uid: string;
+    zoom: number;
+    pixelRatio: number;
+    tileSize: number;
+    source: string;
+    promoteId: ?PromoteIdSpecification;
+    overscaling: number;
+    showCollisionBoxes: boolean;
+    collectResourceTiming: boolean;
+    returnDependencies: boolean;
+
+    status: 'parsing' | 'done';
+    data: VectorTile;
+    collisionBoxArray: CollisionBoxArray;
+
+    abort: ?() => void;
+    reloadCallback: WorkerTileCallback;
+    vectorTile: VectorTile;
+
+    constructor(params: WorkerTileParameters) {
+        this.tileID = new OverscaledTileID(params.tileID.overscaledZ, params.tileID.wrap, params.tileID.canonical.z, params.tileID.canonical.x, params.tileID.canonical.y);
+        this.uid = params.uid;
+        this.zoom = params.zoom;
+        this.pixelRatio = params.pixelRatio;
+        this.tileSize = params.tileSize;
+        this.source = params.source;
+        this.overscaling = this.tileID.overscaleFactor();
+        this.showCollisionBoxes = params.showCollisionBoxes;
+        this.collectResourceTiming = !!params.collectResourceTiming;
+        this.returnDependencies = !!params.returnDependencies;
+        this.promoteId = params.promoteId;
+    }
+
+    parse(data: VectorTile, layerIndex: StyleLayerIndex, availableImages: Array<string>, actor: Actor, callback: WorkerTileCallback) {
+        this.status = 'parsing';
+        this.data = data;
+
+        this.collisionBoxArray = new CollisionBoxArray();
+        const sourceLayerCoder = new DictionaryCoder(Object.keys(data.layers).sort());
+
+        const featureIndex = new FeatureIndex(this.tileID, this.promoteId);
+        featureIndex.bucketLayerIDs = [];
+
+        const buckets: {[_: string]: Bucket} = {};
+
+        const options = {
+            featureIndex,
+            iconDependencies: {},
+            patternDependencies: {},
+            glyphDependencies: {},
+            availableImages
+        };
+
+        const layerFamilies = layerIndex.familiesBySource[this.source];
+        for (const sourceLayerId in layerFamilies) {
+            const sourceLayer = data.layers[sourceLayerId];
+            if (!sourceLayer) {
+                continue;
+            }
+
+            if (sourceLayer.version === 1) {
+                warnOnce(`Vector tile source "${this.source}" layer "${sourceLayerId}" ` +
+                    `does not use vector tile spec v2 and therefore may have some rendering errors.`);
+            }
+
+            const sourceLayerIndex = sourceLayerCoder.encode(sourceLayerId);
+            const features = [];
+            for (let index = 0; index < sourceLayer.length; index++) {
+                const feature = sourceLayer.feature(index);
+                const id = featureIndex.getId(feature, sourceLayerId);
+                features.push({feature, id, index, sourceLayerIndex});
+            }
+
+            for (const family of layerFamilies[sourceLayerId]) {
+                const layer = family[0];
+
+                assert(layer.source === this.source);
+                if (layer.minzoom && this.zoom < Math.floor(layer.minzoom)) continue;
+                if (layer.maxzoom && this.zoom >= layer.maxzoom) continue;
+                if (layer.visibility === 'none') continue;
+
+                recalculateLayers(family, this.zoom, availableImages);
+
+                const bucket = buckets[layer.id] = layer.createBucket({
+                    index: featureIndex.bucketLayerIDs.length,
+                    layers: family,
+                    zoom: this.zoom,
+                    pixelRatio: this.pixelRatio,
+                    overscaling: this.overscaling,
+                    collisionBoxArray: this.collisionBoxArray,
+                    sourceLayerIndex,
+                    sourceID: this.source
+                });
+
+                bucket.populate(features, options, this.tileID.canonical);
+                featureIndex.bucketLayerIDs.push(family.map((l) => l.id));
+            }
+        }
+
+        let error: ?Error;
+        let glyphMap: ?{[_: string]: {[_: number]: ?StyleGlyph}};
+        let iconMap: ?{[_: string]: StyleImage};
+        let patternMap: ?{[_: string]: StyleImage};
+
+        const stacks = mapObject(options.glyphDependencies, (glyphs) => Object.keys(glyphs).map(Number));
+        if (Object.keys(stacks).length) {
+            actor.send('getGlyphs', {uid: this.uid, stacks}, (err, result) => {
+                if (!error) {
+                    error = err;
+                    glyphMap = result;
+                    maybePrepare.call(this);
+                }
+            });
+        } else {
+            glyphMap = {};
+        }
+
+        const icons = Object.keys(options.iconDependencies);
+        if (icons.length) {
+            actor.send('getImages', {icons, source: this.source, tileID: this.tileID, type: 'icons'}, (err, result) => {
+                if (!error) {
+                    error = err;
+                    iconMap = result;
+                    maybePrepare.call(this);
+                }
+            });
+        } else {
+            iconMap = {};
+        }
+
+        const patterns = Object.keys(options.patternDependencies);
+        if (patterns.length) {
+            actor.send('getImages', {icons: patterns, source: this.source, tileID: this.tileID, type: 'patterns'}, (err, result) => {
+                if (!error) {
+                    error = err;
+                    patternMap = result;
+                    maybePrepare.call(this);
+                }
+            });
+        } else {
+            patternMap = {};
+        }
+
+        maybePrepare.call(this);
+
+        function maybePrepare() {
+            if (error) {
+                return callback(error);
+            } else if (glyphMap && iconMap && patternMap) {
+                const glyphAtlas = new GlyphAtlas(glyphMap);
+                const imageAtlas = new ImageAtlas(iconMap, patternMap);
+
+                for (const key in buckets) {
+                    const bucket = buckets[key];
+                    if (bucket instanceof SymbolBucket) {
+                        recalculateLayers(bucket.layers, this.zoom, availableImages);
+                        performSymbolLayout(bucket, glyphMap, glyphAtlas.positions, iconMap, imageAtlas.iconPositions, this.showCollisionBoxes, this.tileID.canonical);
+                    } else if (bucket.hasPattern &&
+                        (bucket instanceof LineBucket ||
+                         bucket instanceof FillBucket ||
+                         bucket instanceof FillExtrusionBucket)) {
+                        recalculateLayers(bucket.layers, this.zoom, availableImages);
+                        bucket.addFeatures(options, this.tileID.canonical, imageAtlas.patternPositions);
+                    }
+                }
+
+                this.status = 'done';
+                callback(null, {
+                    buckets: values(buckets).filter(b => !b.isEmpty()),
+                    featureIndex,
+                    collisionBoxArray: this.collisionBoxArray,
+                    glyphAtlasImage: glyphAtlas.image,
+                    imageAtlas,
+                    // Only used for benchmarking:
+                    glyphMap: this.returnDependencies ? glyphMap : null,
+                    iconMap: this.returnDependencies ? iconMap : null,
+                    glyphPositions: this.returnDependencies ? glyphAtlas.positions : null
+                });
+            }
+        }
+    }
+}
+
+function recalculateLayers(layers: $ReadOnlyArray<StyleLayer>, zoom: number, availableImages: Array<string>) {
+    // Layers are shared and may have been used by a WorkerTile with a different zoom.
+    const parameters = new EvaluationParameters(zoom);
+    for (const layer of layers) {
+        layer.recalculate(parameters, availableImages);
+    }
+}
+
+export default WorkerTile;

package/src/style/create_style_layer.js

@@ -0,0 +1,36 @@
+// @flow
+
+import circle from './style_layer/circle_style_layer';
+import heatmap from './style_layer/heatmap_style_layer';
+import hillshade from './style_layer/hillshade_style_layer';
+import fill from './style_layer/fill_style_layer';
+import fillExtrusion from './style_layer/fill_extrusion_style_layer';
+import line from './style_layer/line_style_layer';
+import symbol from './style_layer/symbol_style_layer';
+import background from './style_layer/background_style_layer';
+import raster from './style_layer/raster_style_layer';
+import CustomStyleLayer from './style_layer/custom_style_layer';
+import type {CustomLayerInterface} from './style_layer/custom_style_layer';
+
+import type {LayerSpecification} from '../style-spec/types';
+
+const subclasses = {
+    circle,
+    heatmap,
+    hillshade,
+    fill,
+    'fill-extrusion': fillExtrusion,
+    line,
+    symbol,
+    background,
+    raster
+};
+
+export default function createStyleLayer(layer: LayerSpecification | CustomLayerInterface) {
+    if (layer.type === 'custom') {
+        return new CustomStyleLayer(layer);
+    } else {
+        return new subclasses[layer.type](layer);
+    }
+}
+

package/src/style/evaluation_parameters.js

@@ -0,0 +1,62 @@
+// @flow
+
+import ZoomHistory from './zoom_history';
+import {isStringInSupportedScript} from '../util/script_detection';
+import {plugin as rtlTextPlugin} from '../source/rtl_text_plugin';
+
+import type {TransitionSpecification} from '../style-spec/types';
+
+export type CrossfadeParameters = {
+    fromScale: number,
+    toScale: number,
+    t: number
+};
+
+class EvaluationParameters {
+    zoom: number;
+    now: number;
+    fadeDuration: number;
+    zoomHistory: ZoomHistory;
+    transition: TransitionSpecification;
+
+    // "options" may also be another EvaluationParameters to copy, see CrossFadedProperty.possiblyEvaluate
+    constructor(zoom: number, options?: *) {
+        this.zoom = zoom;
+
+        if (options) {
+            this.now = options.now;
+            this.fadeDuration = options.fadeDuration;
+            this.zoomHistory = options.zoomHistory;
+            this.transition = options.transition;
+        } else {
+            this.now = 0;
+            this.fadeDuration = 0;
+            this.zoomHistory = new ZoomHistory();
+            this.transition = {};
+        }
+    }
+
+    isSupportedScript(str: string): boolean {
+        return isStringInSupportedScript(str, rtlTextPlugin.isLoaded());
+    }
+
+    crossFadingFactor() {
+        if (this.fadeDuration === 0) {
+            return 1;
+        } else {
+            return Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
+        }
+    }
+
+    getCrossfadeParameters(): CrossfadeParameters {
+        const z = this.zoom;
+        const fraction = z - Math.floor(z);
+        const t = this.crossFadingFactor();
+
+        return z > this.zoomHistory.lastIntegerZoom ?
+            {fromScale: 2, toScale: 1, t: fraction + (1 - fraction) * t} :
+            {fromScale: 0.5, toScale: 1, t: 1 - (1 - t) * fraction};
+    }
+}
+
+export default EvaluationParameters;