@mapgis/mapbox-gl 1.9.10 → 16.0.0

package/src/source/tile_cache.js

@@ -0,0 +1,212 @@
+// @flow
+
+import {OverscaledTileID} from './tile_id';
+import type Tile from './tile';
+
+/**
+ * A [least-recently-used cache](http://en.wikipedia.org/wiki/Cache_algorithms)
+ * with hash lookup made possible by keeping a list of keys in parallel to
+ * an array of dictionary of values
+ *
+ * @private
+ */
+class TileCache {
+    max: number;
+    data: {[key: string]: Array<{ value: Tile, timeout: ?TimeoutID}>};
+    order: Array<string>;
+    onRemove: (element: Tile) => void;
+    /**
+     * @param {number} max number of permitted values
+     * @param {Function} onRemove callback called with items when they expire
+     */
+    constructor(max: number, onRemove: (element: Tile) => void) {
+        this.max = max;
+        this.onRemove = onRemove;
+        this.reset();
+    }
+
+    /**
+     * Clear the cache
+     *
+     * @returns {TileCache} this cache
+     * @private
+     */
+    reset() {
+        for (const key in this.data) {
+            for (const removedData of this.data[key]) {
+                if (removedData.timeout) clearTimeout(removedData.timeout);
+                this.onRemove(removedData.value);
+            }
+        }
+
+        this.data = {};
+        this.order = [];
+
+        return this;
+    }
+
+    /**
+     * Add a key, value combination to the cache, trimming its size if this pushes
+     * it over max length.
+     *
+     * @param {OverscaledTileID} tileID lookup key for the item
+     * @param {*} data any value
+     *
+     * @returns {TileCache} this cache
+     * @private
+     */
+    add(tileID: OverscaledTileID, data: Tile, expiryTimeout: number | void) {
+        const key = tileID.wrapped().key;
+        if (this.data[key] === undefined) {
+            this.data[key] = [];
+        }
+
+        const dataWrapper = {
+            value: data,
+            timeout: undefined
+        };
+
+        if (expiryTimeout !== undefined) {
+            dataWrapper.timeout = setTimeout(() => {
+                this.remove(tileID, dataWrapper);
+            }, expiryTimeout);
+        }
+
+        this.data[key].push(dataWrapper);
+        this.order.push(key);
+
+        if (this.order.length > this.max) {
+            const removedData = this._getAndRemoveByKey(this.order[0]);
+            if (removedData) this.onRemove(removedData);
+        }
+
+        return this;
+    }
+
+    /**
+     * Determine whether the value attached to `key` is present
+     *
+     * @param {OverscaledTileID} tileID the key to be looked-up
+     * @returns {boolean} whether the cache has this value
+     * @private
+     */
+    has(tileID: OverscaledTileID): boolean {
+        return tileID.wrapped().key in this.data;
+    }
+
+    /**
+     * Get the value attached to a specific key and remove data from cache.
+     * If the key is not found, returns `null`
+     *
+     * @param {OverscaledTileID} tileID the key to look up
+     * @returns {*} the data, or null if it isn't found
+     * @private
+     */
+    getAndRemove(tileID: OverscaledTileID): ?Tile {
+        if (!this.has(tileID)) { return null; }
+        return this._getAndRemoveByKey(tileID.wrapped().key);
+    }
+
+    /*
+     * Get and remove the value with the specified key.
+     */
+    _getAndRemoveByKey(key: string): ?Tile {
+        const data = this.data[key].shift();
+        if (data.timeout) clearTimeout(data.timeout);
+
+        if (this.data[key].length === 0) {
+            delete this.data[key];
+        }
+        this.order.splice(this.order.indexOf(key), 1);
+
+        return data.value;
+    }
+
+    /*
+     * Get the value with the specified (wrapped tile) key.
+     */
+    getByKey(key: string): ?Tile {
+        const data = this.data[key];
+        return data ? data[0].value : null;
+    }
+
+    /**
+     * Get the value attached to a specific key without removing data
+     * from the cache. If the key is not found, returns `null`
+     *
+     * @param {OverscaledTileID} tileID the key to look up
+     * @returns {*} the data, or null if it isn't found
+     * @private
+     */
+    get(tileID: OverscaledTileID): ?Tile {
+        if (!this.has(tileID)) { return null; }
+
+        const data = this.data[tileID.wrapped().key][0];
+        return data.value;
+    }
+
+    /**
+     * Remove a key/value combination from the cache.
+     *
+     * @param {OverscaledTileID} tileID the key for the pair to delete
+     * @param {Tile} value If a value is provided, remove that exact version of the value.
+     * @returns {TileCache} this cache
+     * @private
+     */
+    remove(tileID: OverscaledTileID, value: ?{ value: Tile, timeout: ?TimeoutID}) {
+        if (!this.has(tileID)) { return this; }
+        const key = tileID.wrapped().key;
+
+        const dataIndex = value === undefined ? 0 : this.data[key].indexOf(value);
+        const data = this.data[key][dataIndex];
+        this.data[key].splice(dataIndex, 1);
+        if (data.timeout) clearTimeout(data.timeout);
+        if (this.data[key].length === 0) {
+            delete this.data[key];
+        }
+        this.onRemove(data.value);
+        this.order.splice(this.order.indexOf(key), 1);
+
+        return this;
+    }
+
+    /**
+     * Change the max size of the cache.
+     *
+     * @param {number} max the max size of the cache
+     * @returns {TileCache} this cache
+     * @private
+     */
+    setMaxSize(max: number): TileCache {
+        this.max = max;
+
+        while (this.order.length > this.max) {
+            const removedData = this._getAndRemoveByKey(this.order[0]);
+            if (removedData) this.onRemove(removedData);
+        }
+
+        return this;
+    }
+
+    /**
+     * Remove entries that do not pass a filter function. Used for removing
+     * stale tiles from the cache.
+     *
+     * @param {function} filterFn Determines whether the tile is filtered. If the supplied function returns false, the tile will be filtered out.
+     */
+    filter(filterFn: (tile: Tile) => boolean) {
+        const removed = [];
+        for (const key in this.data) {
+            for (const entry of this.data[key]) {
+                if (!filterFn(entry.value)) {
+                    removed.push(entry);
+                }
+            }
+        }
+        for (const r of removed) {
+            this.remove(r.value.tileID, r);
+        }
+    }
+}
+
+export default TileCache;

package/src/source/tile_id.js

@@ -0,0 +1,402 @@
+// @flow
+
+import { getTileBBox as getMecartorBBox } from "@mapbox/whoots-js";
+import EXTENT from "../data/extent";
+import Point from "@mapbox/point-geometry";
+import MercatorCoordinate from "../geo/mercator_coordinate";
+
+import assert from "assert";
+import { register } from "../util/web_worker_transfer";
+import { TileUrlReplaceSpecification } from "../style-spec/types";
+
+import CRS from "../ui/crs";
+
+export class CanonicalTileID {
+    z: number;
+    x: number;
+    y: number;
+    z_replace: string;
+    y_replace: string;
+    x_replace: string;
+    key: string;
+
+    constructor(z: number, x: number, y: number) {
+        assert(z >= 0 && z <= 25);
+        assert(x >= 0 && x < Math.pow(2, z));
+        assert(y >= 0 && y < Math.pow(2, z));
+        this.z = z;
+        this.x = x;
+        this.y = y;
+        this.key = calculateKey(0, z, z, x, y);
+        this.z_replace = undefined;
+        this.x_replace = undefined;
+        this.y_replace = undefined;
+    }
+
+    offsetZ(offset: number) {
+        if (offset) {
+            this.z += offset;
+        }
+    }
+
+    replaceX(x: any) {
+        this.x_replace = x;
+    }
+
+    replaceY(y: any) {
+        this.y_replace = y;
+    }
+
+    replaceZ(z: any) {
+        this.z_replace = z;
+    }
+
+    format(str, size) {
+        //截取右8位，不足的位数前面补0
+        var i = str.length;
+        if (i >= size) {
+            str = str.substring(i - size, i);
+        } else {
+            var str0 = "";
+            for (let i = 0; i < size; i++) {
+                str0 += "0";
+            }
+            str = str0.substring(0, str0.length - i) + str;
+        }
+        return str;
+    }
+
+    replaceRule(replace: TileUrlReplaceSpecification, value): string {
+        const { type, fixlength, prefix, postfix } = replace;
+        let str = value;
+        let fix = 0;
+        switch (type) {
+            case "hex":
+                str = value.toString(16).toUpperCase();
+                break;
+            case "dec":
+                str = value.toString(10).toUpperCase();
+                break;
+            case "oct":
+                str = value.toString(8).toUpperCase();
+                break;
+            case "bin":
+                str = value.toString(2).toUpperCase();
+                break;
+            case "replace":
+                break;
+        }
+        if (fixlength) {
+            str = this.format(str, fixlength)
+        }
+
+        if (prefix) {
+            str = prefix + str;
+        }
+        if (postfix) {
+            str = str + postfix;
+        }
+        return str;
+    }
+
+    equals(id: CanonicalTileID) {
+        return this.z === id.z && this.x === id.x && this.y === id.y;
+    }
+
+    // given a list of urls, choose a url template and return a tile URL
+    url(urls: Array<string>, scheme: ?string) {
+        const { x_replace, y_replace, z_replace } = this;
+        const url = urls[(this.x + this.y) % urls.length];
+        const reverse = url.indexOf("reversebbox=true") >= 0 ? true : false;
+        let bbox = this.getTileBBox(this.x, this.y, this.z);
+        if (reverse) {
+            let bound = bbox.split(",");
+            bbox = `${bound[1]},${bound[0]},${bound[3]},${bound[2]}`;
+            console.warn("reverse", bbox);
+        }
+        // const bbox3857 = getTileBBox(this.x, this.y, this.z);
+        // const bbox4326 = getLatlngBBox(this.x, this.y, this.z);
+        const quadkey = getQuadkey(this.z, this.x, this.y);
+        let z_rule = this.z,
+            x_rule = this.x,
+            y_rule = this.y;
+
+        if (x_replace || y_replace || z_replace) {
+            if (z_replace) {
+                z_rule = this.replaceRule(z_replace, this.z);
+            }
+            if (x_replace) {
+                x_rule = this.replaceRule(x_replace, this.x);
+            }
+            if (y_replace) {
+                y_rule = this.replaceRule(y_replace, this.y);
+            }
+        }
+
+        return url
+            .replace(
+                "{prefix}",
+                (this.x % 16).toString(16) + (this.y % 16).toString(16)
+            )
+            .replace("{z}", String(z_rule))
+            .replace("{x}", String(x_rule))
+            .replace(
+                "{y}",
+                String(
+                    scheme === "tms" ? Math.pow(2, this.z) - this.y - 1 : y_rule
+                )
+            )
+            .replace("{quadkey}", quadkey)
+            .replace("{bbox}", bbox);
+    }
+
+    getTilePoint(coord: MercatorCoordinate) {
+        const tilesAtZoom = Math.pow(2, this.z);
+        return new Point(
+            (coord.x * tilesAtZoom - this.x) * EXTENT,
+            (coord.y * tilesAtZoom - this.y) * EXTENT
+        );
+    }
+
+    getTileBBox(x, y, z) {
+        return getMecartorBBox(x, y, z);
+    }
+
+    getCRS() {
+        return CRS.EPSG3857;
+    }
+
+    toString() {
+        return `${this.z}/${this.x}/${this.y}`;
+    }
+}
+
+export class UnwrappedTileID {
+    wrap: number;
+    canonical: CanonicalTileID;
+    key: string;
+
+    constructor(wrap: number, canonical: CanonicalTileID) {
+        this.wrap = wrap;
+        this.canonical = canonical;
+        this.key = calculateKey(
+            wrap,
+            canonical.z,
+            canonical.z,
+            canonical.x,
+            canonical.y
+        );
+    }
+}
+
+export class OverscaledTileID {
+    overscaledZ: number;
+    wrap: number;
+    canonical: CanonicalTileID;
+    key: string;
+    posMatrix: Float32Array;
+
+    constructor(
+        overscaledZ: number,
+        wrap: number,
+        z: number,
+        x: number,
+        y: number
+    ) {
+        assert(overscaledZ >= z);
+        this.overscaledZ = overscaledZ;
+        this.wrap = wrap;
+        this.canonical = new CanonicalTileID(z, +x, +y);
+        this.key = calculateKey(wrap, overscaledZ, z, x, y);
+    }
+
+    equals(id: OverscaledTileID) {
+        return (
+            this.overscaledZ === id.overscaledZ &&
+            this.wrap === id.wrap &&
+            this.canonical.equals(id.canonical)
+        );
+    }
+
+    scaledTo(targetZ: number) {
+        assert(targetZ <= this.overscaledZ);
+        const zDifference = this.canonical.z - targetZ;
+        if (targetZ > this.canonical.z) {
+            return new OverscaledTileID(
+                targetZ,
+                this.wrap,
+                this.canonical.z,
+                this.canonical.x,
+                this.canonical.y
+            );
+        } else {
+            return new OverscaledTileID(
+                targetZ,
+                this.wrap,
+                targetZ,
+                this.canonical.x >> zDifference,
+                this.canonical.y >> zDifference
+            );
+        }
+    }
+
+    /*
+     * calculateScaledKey is an optimization:
+     * when withWrap == true, implements the same as this.scaledTo(z).key,
+     * when withWrap == false, implements the same as this.scaledTo(z).wrapped().key.
+     */
+    calculateScaledKey(targetZ: number, withWrap: boolean): string {
+        assert(targetZ <= this.overscaledZ);
+        const zDifference = this.canonical.z - targetZ;
+        if (targetZ > this.canonical.z) {
+            return calculateKey(
+                this.wrap * +withWrap,
+                targetZ,
+                this.canonical.z,
+                this.canonical.x,
+                this.canonical.y
+            );
+        } else {
+            return calculateKey(
+                this.wrap * +withWrap,
+                targetZ,
+                targetZ,
+                this.canonical.x >> zDifference,
+                this.canonical.y >> zDifference
+            );
+        }
+    }
+
+    isChildOf(parent: OverscaledTileID) {
+        if (parent.wrap !== this.wrap) {
+            // We can't be a child if we're in a different world copy
+            return false;
+        }
+        const zDifference = this.canonical.z - parent.canonical.z;
+        // We're first testing for z == 0, to avoid a 32 bit shift, which is undefined.
+        return (
+            parent.overscaledZ === 0 ||
+            (parent.overscaledZ < this.overscaledZ &&
+                parent.canonical.x === this.canonical.x >> zDifference &&
+                parent.canonical.y === this.canonical.y >> zDifference)
+        );
+    }
+
+    children(sourceMaxZoom: number) {
+        if (this.overscaledZ >= sourceMaxZoom) {
+            // return a single tile coord representing a an overscaled tile
+            return [
+                new OverscaledTileID(
+                    this.overscaledZ + 1,
+                    this.wrap,
+                    this.canonical.z,
+                    this.canonical.x,
+                    this.canonical.y
+                ),
+            ];
+        }
+
+        const z = this.canonical.z + 1;
+        const x = this.canonical.x * 2;
+        const y = this.canonical.y * 2;
+        return [
+            new OverscaledTileID(z, this.wrap, z, x, y),
+            new OverscaledTileID(z, this.wrap, z, x + 1, y),
+            new OverscaledTileID(z, this.wrap, z, x, y + 1),
+            new OverscaledTileID(z, this.wrap, z, x + 1, y + 1),
+        ];
+    }
+
+    isLessThan(rhs: OverscaledTileID) {
+        if (this.wrap < rhs.wrap) return true;
+        if (this.wrap > rhs.wrap) return false;
+
+        if (this.overscaledZ < rhs.overscaledZ) return true;
+        if (this.overscaledZ > rhs.overscaledZ) return false;
+
+        if (this.canonical.x < rhs.canonical.x) return true;
+        if (this.canonical.x > rhs.canonical.x) return false;
+
+        if (this.canonical.y < rhs.canonical.y) return true;
+        return false;
+    }
+
+    wrapped() {
+        return new OverscaledTileID(
+            this.overscaledZ,
+            0,
+            this.canonical.z,
+            this.canonical.x,
+            this.canonical.y
+        );
+    }
+
+    unwrapTo(wrap: number) {
+        return new OverscaledTileID(
+            this.overscaledZ,
+            wrap,
+            this.canonical.z,
+            this.canonical.x,
+            this.canonical.y
+        );
+    }
+
+    overscaleFactor() {
+        return Math.pow(2, this.overscaledZ - this.canonical.z);
+    }
+
+    toUnwrapped() {
+        return new UnwrappedTileID(this.wrap, this.canonical);
+    }
+
+    toString() {
+        return `${this.overscaledZ}/${this.canonical.x}/${this.canonical.y}`;
+    }
+
+    getTilePoint(coord: MercatorCoordinate) {
+        return this.canonical.getTilePoint(
+            new MercatorCoordinate(coord.x - this.wrap, coord.y)
+        );
+    }
+}
+
+function calculateKey(
+    wrap: number,
+    overscaledZ: number,
+    z: number,
+    x: number,
+    y: number
+): string {
+    wrap *= 2;
+    if (wrap < 0) wrap = wrap * -1 - 1;
+    const dim = 1 << z;
+    return (
+        (dim * dim * wrap + dim * y + x).toString(36) +
+        z.toString(36) +
+        overscaledZ.toString(36)
+    );
+}
+
+function getQuadkey(z, x, y) {
+    let quadkey = "",
+        mask;
+    for (let i = z; i > 0; i--) {
+        mask = 1 << (i - 1);
+        quadkey += (x & mask ? 1 : 0) + (y & mask ? 2 : 0);
+    }
+    return quadkey;
+}
+
+function getLatlngBBox(x, y, z) {
+    let bbox = "";
+    let scale = 360 / Math.pow(2, z);
+    let left = scale * x - 180;
+    let right = scale * (x + 1) - 180;
+    let top = 90 - scale * y;
+    let bottom = 90 - scale * (y + 1);
+    bbox = left + "," + bottom + "," + right + "," + top;
+    return bbox;
+}
+
+register("CanonicalTileID", CanonicalTileID);
+register("OverscaledTileID", OverscaledTileID, { omit: ["posMatrix"] });