@loaders.gl/gis 4.0.0-alpha.23 → 4.0.0-alpha.25

package/dist/lib/flat-geojson-to-binary.js

@@ -1,385 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEST_EXPORTS = exports.flatGeojsonToBinary = void 0;
-/* eslint-disable indent */
-const polygon_1 = require("@math.gl/polygon");
-/**
- * Convert binary features to flat binary arrays. Similar to
- * `geojsonToBinary` helper function, except that it expects
- * a binary representation of the feature data, which enables
- * 2X-3X speed increase in parse speed, compared to using
- * geoJSON. See `binary-vector-tile/VectorTileFeature` for
- * data format detais
- *
- * @param features
- * @param geometryInfo
- * @param options
- * @returns filled arrays
- */
-function flatGeojsonToBinary(features, geometryInfo, options) {
-    const propArrayTypes = extractNumericPropTypes(features);
-    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
-    return fillArrays(features, {
-        propArrayTypes,
-        ...geometryInfo
-    }, {
-        numericPropKeys: (options && options.numericPropKeys) || numericPropKeys,
-        PositionDataType: options ? options.PositionDataType : Float32Array,
-        triangulate: options ? options.triangulate : true
-    });
-}
-exports.flatGeojsonToBinary = flatGeojsonToBinary;
-exports.TEST_EXPORTS = {
-    extractNumericPropTypes
-};
-/**
- * Extracts properties that are always numeric
- *
- * @param features
- * @returns object with numeric types
- */
-function extractNumericPropTypes(features) {
-    const propArrayTypes = {};
-    for (const feature of features) {
-        if (feature.properties) {
-            for (const key in feature.properties) {
-                // If property has not been seen before, or if property has been numeric
-                // in all previous features, check if numeric in this feature
-                // If not numeric, Array is stored to prevent rechecking in the future
-                // Additionally, detects if 64 bit precision is required
-                const val = feature.properties[key];
-                propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
-            }
-        }
-    }
-    return propArrayTypes;
-}
-/**
- * Fills coordinates into pre-allocated typed arrays
- *
- * @param features
- * @param geometryInfo
- * @param options
- * @returns an accessor object with value and size keys
- */
-// eslint-disable-next-line complexity, max-statements
-function fillArrays(features, geometryInfo, options) {
-    const { pointPositionsCount, pointFeaturesCount, linePositionsCount, linePathsCount, lineFeaturesCount, polygonPositionsCount, polygonObjectsCount, polygonRingsCount, polygonFeaturesCount, propArrayTypes, coordLength } = geometryInfo;
-    const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
-    const hasGlobalId = features[0] && 'id' in features[0];
-    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-    const points = {
-        type: 'Point',
-        positions: new PositionDataType(pointPositionsCount * coordLength),
-        globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-        featureIds: pointFeaturesCount > 65535
-            ? new Uint32Array(pointPositionsCount)
-            : new Uint16Array(pointPositionsCount),
-        numericProps: {},
-        properties: [],
-        fields: []
-    };
-    const lines = {
-        type: 'LineString',
-        pathIndices: linePositionsCount > 65535
-            ? new Uint32Array(linePathsCount + 1)
-            : new Uint16Array(linePathsCount + 1),
-        positions: new PositionDataType(linePositionsCount * coordLength),
-        globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
-        featureIds: lineFeaturesCount > 65535
-            ? new Uint32Array(linePositionsCount)
-            : new Uint16Array(linePositionsCount),
-        numericProps: {},
-        properties: [],
-        fields: []
-    };
-    const polygons = {
-        type: 'Polygon',
-        polygonIndices: polygonPositionsCount > 65535
-            ? new Uint32Array(polygonObjectsCount + 1)
-            : new Uint16Array(polygonObjectsCount + 1),
-        primitivePolygonIndices: polygonPositionsCount > 65535
-            ? new Uint32Array(polygonRingsCount + 1)
-            : new Uint16Array(polygonRingsCount + 1),
-        positions: new PositionDataType(polygonPositionsCount * coordLength),
-        globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-        featureIds: polygonFeaturesCount > 65535
-            ? new Uint32Array(polygonPositionsCount)
-            : new Uint16Array(polygonPositionsCount),
-        numericProps: {},
-        properties: [],
-        fields: []
-    };
-    if (triangulate) {
-        polygons.triangles = [];
-    }
-    // Instantiate numeric properties arrays; one value per vertex
-    for (const object of [points, lines, polygons]) {
-        for (const propName of numericPropKeys) {
-            // If property has been numeric in all previous features in which the property existed, check
-            // if numeric in this feature
-            const T = propArrayTypes[propName];
-            object.numericProps[propName] = new T(object.positions.length / coordLength);
-        }
-    }
-    // Set last element of path/polygon indices as positions length
-    lines.pathIndices[linePathsCount] = linePositionsCount;
-    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
-    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-    const indexMap = {
-        pointPosition: 0,
-        pointFeature: 0,
-        linePosition: 0,
-        linePath: 0,
-        lineFeature: 0,
-        polygonPosition: 0,
-        polygonObject: 0,
-        polygonRing: 0,
-        polygonFeature: 0,
-        feature: 0
-    };
-    for (const feature of features) {
-        const geometry = feature.geometry;
-        const properties = feature.properties || {};
-        switch (geometry.type) {
-            case 'Point':
-                handlePoint(geometry, points, indexMap, coordLength, properties);
-                points.properties.push(keepStringProperties(properties, numericPropKeys));
-                if (hasGlobalId) {
-                    points.fields.push({ id: feature.id });
-                }
-                indexMap.pointFeature++;
-                break;
-            case 'LineString':
-                handleLineString(geometry, lines, indexMap, coordLength, properties);
-                lines.properties.push(keepStringProperties(properties, numericPropKeys));
-                if (hasGlobalId) {
-                    lines.fields.push({ id: feature.id });
-                }
-                indexMap.lineFeature++;
-                break;
-            case 'Polygon':
-                handlePolygon(geometry, polygons, indexMap, coordLength, properties);
-                polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-                if (hasGlobalId) {
-                    polygons.fields.push({ id: feature.id });
-                }
-                indexMap.polygonFeature++;
-                break;
-            default:
-                throw new Error('Invalid geometry type');
-        }
-        indexMap.feature++;
-    }
-    // Wrap each array in an accessor object with value and size keys
-    return makeAccessorObjects(points, lines, polygons, coordLength);
-}
-/**
- * Fills (Multi)Point coordinates into points object of arrays
- *
- * @param geometry
- * @param points
- * @param indexMap
- * @param coordLength
- * @param properties
- */
-function handlePoint(geometry, points, indexMap, coordLength, properties) {
-    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
-    const nPositions = geometry.data.length / coordLength;
-    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
-    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-    indexMap.pointPosition += nPositions;
-}
-/**
- * Fills (Multi)LineString coordinates into lines object of arrays
- *
- * @param geometry
- * @param lines
- * @param indexMap
- * @param coordLength
- * @param properties
- */
-function handleLineString(geometry, lines, indexMap, coordLength, properties) {
-    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
-    const nPositions = geometry.data.length / coordLength;
-    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
-    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
-    for (let i = 0, il = geometry.indices.length; i < il; ++i) {
-        // Extract range of data we are working with, defined by start
-        // and end indices (these index into the geometry.data array)
-        const start = geometry.indices[i];
-        const end = i === il - 1
-            ? geometry.data.length // last line, so read to end of data
-            : geometry.indices[i + 1]; // start index for next line
-        lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
-        indexMap.linePosition += (end - start) / coordLength;
-    }
-}
-/**
- * Fills (Multi)Polygon coordinates into polygons object of arrays
- *
- * @param geometry
- * @param polygons
- * @param indexMap
- * @param coordLength
- * @param properties
- */
-function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
-    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
-    const nPositions = geometry.data.length / coordLength;
-    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-    // Unlike Point & LineString geometry.indices is a 2D array
-    for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
-        const startPosition = indexMap.polygonPosition;
-        polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
-        const areas = geometry.areas[l];
-        const indices = geometry.indices[l];
-        const nextIndices = geometry.indices[l + 1];
-        for (let i = 0, il = indices.length; i < il; ++i) {
-            const start = indices[i];
-            const end = i === il - 1
-                ? // last line, so either read to:
-                    nextIndices === undefined
-                        ? geometry.data.length // end of data (no next indices)
-                        : nextIndices[0] // start of first line in nextIndices
-                : indices[i + 1]; // start index for next line
-            polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
-            indexMap.polygonPosition += (end - start) / coordLength;
-        }
-        const endPosition = indexMap.polygonPosition;
-        triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
-    }
-}
-/**
- * Triangulate polygon using earcut
- *
- * @param polygons
- * @param areas
- * @param indices
- * @param param3
- */
-function triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength }) {
-    if (!polygons.triangles) {
-        return;
-    }
-    const start = startPosition * coordLength;
-    const end = endPosition * coordLength;
-    // Extract positions and holes for just this polygon
-    const polygonPositions = polygons.positions.subarray(start, end);
-    // Holes are referenced relative to outer polygon
-    const offset = indices[0];
-    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
-    // Compute triangulation
-    // @ts-expect-error TODO can earcut handle binary arrays? Add tests?
-    const triangles = (0, polygon_1.earcut)(polygonPositions, holes, coordLength, areas);
-    // Indices returned by triangulation are relative to start
-    // of polygon, so we need to offset
-    for (let t = 0, tl = triangles.length; t < tl; ++t) {
-        polygons.triangles.push(startPosition + triangles[t]);
-    }
-}
-/**
- * Wraps an object containing array into accessors
- *
- * @param obj
- * @param size
- */
-function wrapProps(obj, size) {
-    const returnObj = {};
-    for (const key in obj) {
-        returnObj[key] = { value: obj[key], size };
-    }
-    return returnObj;
-}
-/**
- * Wrap each array in an accessor object with value and size keys
- *
- * @param points
- * @param lines
- * @param polygons
- * @param coordLength
- * @returns object
- */
-function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const binaryFeatures = {
-        points: {
-            ...points,
-            positions: { value: points.positions, size: coordLength },
-            globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-            featureIds: { value: points.featureIds, size: 1 },
-            numericProps: wrapProps(points.numericProps, 1)
-        },
-        lines: {
-            ...lines,
-            positions: { value: lines.positions, size: coordLength },
-            pathIndices: { value: lines.pathIndices, size: 1 },
-            globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-            featureIds: { value: lines.featureIds, size: 1 },
-            numericProps: wrapProps(lines.numericProps, 1)
-        },
-        polygons: {
-            ...polygons,
-            positions: { value: polygons.positions, size: coordLength },
-            polygonIndices: { value: polygons.polygonIndices, size: 1 },
-            primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
-            globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-            featureIds: { value: polygons.featureIds, size: 1 },
-            numericProps: wrapProps(polygons.numericProps, 1)
-        }
-    };
-    if (polygons.triangles) {
-        binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
-    }
-    return binaryFeatures;
-}
-/**
- * Add numeric properties to object
- *
- * @param object
- * @param properties
- * @param index
- * @param length
- */
-function fillNumericProperties(object, properties, index, length) {
-    for (const numericPropName in object.numericProps) {
-        if (numericPropName in properties) {
-            const value = properties[numericPropName];
-            object.numericProps[numericPropName].fill(value, index, index + length);
-        }
-    }
-}
-/**
- * Keep string properties in object
- *
- * @param properties
- * @param numericKeys
- * @returns object
- */
-function keepStringProperties(properties, numericKeys) {
-    const props = {};
-    for (const key in properties) {
-        if (!numericKeys.includes(key)) {
-            props[key] = properties[key];
-        }
-    }
-    return props;
-}
-/**
- *
- * Deduce correct array constructor to use for a given value
- *
- * @param x value to test
- * @param constructor previous constructor deduced
- * @returns PropArrayConstructor
- */
-function deduceArrayType(x, constructor) {
-    if (constructor === Array || !Number.isFinite(x)) {
-        return Array;
-    }
-    // If this or previous value required 64bits use Float64Array
-    return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
-}

package/dist/lib/geojson-to-binary.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geojsonToBinary = void 0;
-const extract_geometry_info_1 = require("./extract-geometry-info");
-const geojson_to_flat_geojson_1 = require("./geojson-to-flat-geojson");
-const flat_geojson_to_binary_1 = require("./flat-geojson-to-binary");
-/**
- * Convert GeoJSON features to flat binary arrays
- *
- * @param features
- * @param options
- * @returns features in binary format, grouped by geometry type
- */
-function geojsonToBinary(features, options = { fixRingWinding: true, triangulate: true }) {
-    const geometryInfo = (0, extract_geometry_info_1.extractGeometryInfo)(features);
-    const coordLength = geometryInfo.coordLength;
-    const { fixRingWinding } = options;
-    const flatFeatures = (0, geojson_to_flat_geojson_1.geojsonToFlatGeojson)(features, { coordLength, fixRingWinding });
-    return (0, flat_geojson_to_binary_1.flatGeojsonToBinary)(flatFeatures, geometryInfo, {
-        numericPropKeys: options.numericPropKeys,
-        PositionDataType: options.PositionDataType || Float32Array,
-        triangulate: options.triangulate
-    });
-}
-exports.geojsonToBinary = geojsonToBinary;

package/dist/lib/geojson-to-flat-geojson.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geojsonToFlatGeojson = void 0;
-const polygon_1 = require("@math.gl/polygon");
-/**
- * Convert GeoJSON features to Flat GeoJSON features
- *
- * @param features
- * @param options
- * @returns an Array of Flat GeoJSON features
- */
-function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
-    return features.map((feature) => flattenFeature(feature, options));
-}
-exports.geojsonToFlatGeojson = geojsonToFlatGeojson;
-/**
- * Helper function to copy Point values from `coordinates` into `data` & `indices`
- *
- * @param coordinates
- * @param data
- * @param indices
- * @param options
- */
-function flattenPoint(coordinates, data, indices, options) {
-    indices.push(data.length);
-    data.push(...coordinates);
-    // Pad up to coordLength
-    for (let i = coordinates.length; i < options.coordLength; i++) {
-        data.push(0);
-    }
-}
-/**
- * Helper function to copy LineString values from `coordinates` into `data` & `indices`
- *
- * @param coordinates
- * @param data
- * @param indices
- * @param options
- */
-function flattenLineString(coordinates, data, indices, options) {
-    indices.push(data.length);
-    for (const c of coordinates) {
-        data.push(...c);
-        // Pad up to coordLength
-        for (let i = c.length; i < options.coordLength; i++) {
-            data.push(0);
-        }
-    }
-}
-/**
- * Helper function to copy Polygon values from `coordinates` into `data` & `indices` & `areas`
- *
- * @param coordinates
- * @param data
- * @param indices
- * @param areas
- * @param options
- */
-function flattenPolygon(coordinates, data, indices, areas, options) {
-    let count = 0;
-    const ringAreas = [];
-    const polygons = [];
-    for (const lineString of coordinates) {
-        const lineString2d = lineString.map((p) => p.slice(0, 2));
-        let area = (0, polygon_1.getPolygonSignedArea)(lineString2d.flat());
-        const ccw = area < 0;
-        // Exterior ring must be CCW and interior rings CW
-        if (options.fixRingWinding && ((count === 0 && !ccw) || (count > 0 && ccw))) {
-            lineString.reverse();
-            area = -area;
-        }
-        ringAreas.push(area);
-        flattenLineString(lineString, data, polygons, options);
-        count++;
-    }
-    if (count > 0) {
-        areas.push(ringAreas);
-        indices.push(polygons);
-    }
-}
-/**
- * Flatten single GeoJSON feature into Flat GeoJSON
- *
- * @param feature
- * @param options
- * @returns A Flat GeoJSON feature
- */
-function flattenFeature(feature, options) {
-    const { geometry } = feature;
-    if (geometry.type === 'GeometryCollection') {
-        throw new Error('GeometryCollection type not supported');
-    }
-    const data = [];
-    const indices = [];
-    let areas;
-    let type;
-    switch (geometry.type) {
-        case 'Point':
-            type = 'Point';
-            flattenPoint(geometry.coordinates, data, indices, options);
-            break;
-        case 'MultiPoint':
-            type = 'Point';
-            geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
-            break;
-        case 'LineString':
-            type = 'LineString';
-            flattenLineString(geometry.coordinates, data, indices, options);
-            break;
-        case 'MultiLineString':
-            type = 'LineString';
-            geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
-            break;
-        case 'Polygon':
-            type = 'Polygon';
-            areas = [];
-            flattenPolygon(geometry.coordinates, data, indices, areas, options);
-            break;
-        case 'MultiPolygon':
-            type = 'Polygon';
-            areas = [];
-            geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
-            break;
-        default:
-            throw new Error(`Unknown type: ${type}`);
-    }
-    return { ...feature, geometry: { type, indices, data, areas } };
-}

package/dist/lib/transform.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformGeoJsonCoords = exports.transformBinaryCoords = void 0;
-/**
- * Apply transformation to every coordinate of binary features
- * @param  binaryFeatures binary features
- * @param  transformCoordinate Function to call on each coordinate
- * @return Transformed binary features
- */
-function transformBinaryCoords(binaryFeatures, transformCoordinate) {
-    if (binaryFeatures.points) {
-        transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
-    }
-    if (binaryFeatures.lines) {
-        transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
-    }
-    if (binaryFeatures.polygons) {
-        transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
-    }
-    return binaryFeatures;
-}
-exports.transformBinaryCoords = transformBinaryCoords;
-/** Transform one binary geometry */
-function transformBinaryGeometryPositions(binaryGeometry, fn) {
-    const { positions } = binaryGeometry;
-    for (let i = 0; i < positions.value.length; i += positions.size) {
-        // @ts-ignore inclusion of bigint causes problems
-        const coord = Array.from(positions.value.subarray(i, i + positions.size));
-        const transformedCoord = fn(coord);
-        // @ts-ignore typescript typing for .set seems to require bigint?
-        positions.value.set(transformedCoord, i);
-    }
-}
-/**
- * Apply transformation to every coordinate of GeoJSON features
- *
- * @param  features Array of GeoJSON features
- * @param  fn       Function to call on each coordinate
- * @return          Transformed GeoJSON features
- */
-function transformGeoJsonCoords(features, fn) {
-    for (const feature of features) {
-        // @ts-ignore
-        feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
-    }
-    return features;
-}
-exports.transformGeoJsonCoords = transformGeoJsonCoords;
-function coordMap(array, fn) {
-    if (isCoord(array)) {
-        return fn(array);
-    }
-    return array.map((item) => {
-        return coordMap(item, fn);
-    });
-}
-function isCoord(array) {
-    return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
-}