open-vector-tile/dist/open/gridLayer.js

This library reads/writes Open Vector Tiles

import { Pbf as Protobuf } from 'pbf-ts';
import { deltaDecodeArray, deltaEncodeArray } from '../util.js';
/** Grid object to read from */
export class GridData {
    #pbf;
    name = 'default';
    dataPos = 0;
    extent = 8_192;
    size = 0;
    min = 0;
    max = 0;
    /**
     * @param pbf - the pbf protocol we are reading from
     * @param end - the position to stop at
     */
    constructor(pbf, end) {
        this.#pbf = pbf;
        pbf.readFields(this.#readGrid, this, end);
    }
    /**
     * Get the raw gridded data. Reads much like a raw image.
     * @returns - the decomposed gridded data
     */
    data() {
        this.#pbf.pos = this.dataPos;
        return deltaDecodeArray(this.#pbf.readPackedVarint()).map((v) => unmapValue(v, this.min, this.max, this.extent));
    }
    /**
     * @param tag - the tag to read
     * @param grid - the elevation data to mutate
     * @param pbf - the Protobuf to pull the appropriate data from
     */
    #readGrid(tag, grid, pbf) {
        if (tag === 1)
            grid.extent = pbf.readVarint();
        else if (tag === 2)
            grid.size = pbf.readVarint();
        else if (tag === 3)
            grid.min = pbf.readFloat();
        else if (tag === 4)
            grid.max = pbf.readFloat();
        else if (tag === 5)
            grid.dataPos = pbf.pos;
        else if (tag === 6)
            grid.name = pbf.readString();
    }
}
/**
 * @param input - the data to encode
 * @returns - the encoded data
 */
export function writeGridData(input) {
    const pbf = new Protobuf();
    const { name, data, size, extent } = input;
    const max = data.reduce((a, b) => Math.max(a, b), 0);
    const min = data.reduce((a, b) => Math.min(a, b), 0);
    const reMapped = data.map((v) => remapValue(v, min, max, extent));
    const d_coded = deltaEncodeArray(reMapped);
    pbf.writeVarintField(1, extent);
    pbf.writeVarintField(2, size);
    pbf.writeFloatField(3, min);
    pbf.writeFloatField(4, max);
    pbf.writePackedVarint(5, d_coded);
    pbf.writeStringField(6, name);
    return pbf.commit();
}
/**
 * @param value - input value to remap
 * @param min - min value
 * @param max - max value
 * @param extent - extent defines the 0->extent range to remap to
 * @returns - remapped value
 */
function remapValue(value, min, max, extent) {
    return Math.round(((value - min) * extent) / (max - min));
}
/**
 * @param value - input value to unmap
 * @param min - min value
 * @param max - max value
 * @param extent - extent defines the 0->extent range to remap from
 * @returns - unremapped value
 */
function unmapValue(value, min, max, extent) {
    return (value * (max - min)) / extent + min;
}
/**
 * @param r - red
 * @param g - green
 * @param b - blue
 * @returns - elevation
 */
export function convertTerrariumElevationData(r, g, b) {
    return r * 256.0 + g + b / 256.0 - 32768.0;
}
/**
 * @param r - red
 * @param g - green
 * @param b - blue
 * @returns - elevation
 */
export function convertMapboxElevationData(r, g, b) {
    return -10000 + (r * 256 * 256 + g * 256 + b) * 0.1;
}
//# sourceMappingURL=gridLayer.js.map