@maplibre/geojson-vt 5.0.0 → 5.0.2

package/src/wrap.ts

@@ -0,0 +1,81 @@
+
+import {clip} from './clip';
+import type { GeoJSONVTFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import {createFeature} from './feature';
+
+export function wrap(features: GeoJSONVTFeature[], options: GeoJSONVTOptions): GeoJSONVTFeature[] {
+    const buffer = options.buffer / options.extent;
+    let merged = features;
+
+    const left  = clip(features, 1, -1 - buffer, buffer,     0, -1, 2, options); // left world copy
+    const right = clip(features, 1,  1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
+
+    if (!left && !right) return merged;
+
+    merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
+
+    if (left) merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
+    if (right) merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center
+
+    return merged;
+}
+
+function shiftFeatureCoords(features: GeoJSONVTFeature[], offset: number): GeoJSONVTFeature[] {
+    const newFeatures = [];
+
+    for (const feature of features) {
+        switch (feature.type) {
+            case 'Point':
+            case 'MultiPoint':
+            case 'LineString': {
+                const newGeometry = shiftCoords(feature.geometry, offset);
+
+                newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+                continue;
+            }
+
+            case 'MultiLineString':
+            case 'Polygon': {
+                const newGeometry = [];
+                for (const line of feature.geometry) {
+                    newGeometry.push(shiftCoords(line, offset));
+                }
+
+                newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+                continue;
+            }
+
+            case 'MultiPolygon': {
+                const newGeometry = [];
+                for (const polygon of feature.geometry) {
+                    const newPolygon = [];
+                    for (const line of polygon) {
+                        newPolygon.push(shiftCoords(line, offset));
+                    }
+                    newGeometry.push(newPolygon);
+                }
+
+                newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+                continue;
+            }
+        }
+    }
+
+    return newFeatures;
+}
+
+function shiftCoords(points: StartEndSizeArray, offset: number): number[] | StartEndSizeArray {
+    const newPoints: StartEndSizeArray = [];
+    newPoints.size = points.size;
+
+    if (points.start !== undefined) {
+        newPoints.start = points.start;
+        newPoints.end = points.end;
+    }
+
+    for (let i = 0; i < points.length; i += 3) {
+        newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
+    }
+
+    return newPoints;
+}

package/src/clip.js

@@ -1,200 +0,0 @@
-
-import createFeature from './feature.js';
-
-/* clip features between two vertical or horizontal axis-parallel lines:
- *     |        |
- *  ___|___     |     /
- * /   |   \____|____/
- *     |        |
- *
- * k1 and k2 are the line coordinates
- * axis: 0 for x, 1 for y
- * minAll and maxAll: minimum and maximum coordinate value for all features
- */
-export default function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
-    k1 /= scale;
-    k2 /= scale;
-
-    if (minAll >= k1 && maxAll < k2) return features; // trivial accept
-    else if (maxAll < k1 || minAll >= k2) return null; // trivial reject
-
-    const clipped = [];
-
-    for (const feature of features) {
-        const geometry = feature.geometry;
-        let type = feature.type;
-
-        const min = axis === 0 ? feature.minX : feature.minY;
-        const max = axis === 0 ? feature.maxX : feature.maxY;
-
-        if (min >= k1 && max < k2) { // trivial accept
-            clipped.push(feature);
-            continue;
-        } else if (max < k1 || min >= k2) { // trivial reject
-            continue;
-        }
-
-        let newGeometry = [];
-
-        if (type === 'Point' || type === 'MultiPoint') {
-            clipPoints(geometry, newGeometry, k1, k2, axis);
-
-        } else if (type === 'LineString') {
-            clipLine(geometry, newGeometry, k1, k2, axis, false, options.lineMetrics);
-
-        } else if (type === 'MultiLineString') {
-            clipLines(geometry, newGeometry, k1, k2, axis, false);
-
-        } else if (type === 'Polygon') {
-            clipLines(geometry, newGeometry, k1, k2, axis, true);
-
-        } else if (type === 'MultiPolygon') {
-            for (const polygon of geometry) {
-                const newPolygon = [];
-                clipLines(polygon, newPolygon, k1, k2, axis, true);
-                if (newPolygon.length) {
-                    newGeometry.push(newPolygon);
-                }
-            }
-        }
-
-        if (newGeometry.length) {
-            if (options.lineMetrics && type === 'LineString') {
-                for (const line of newGeometry) {
-                    clipped.push(createFeature(feature.id, type, line, feature.tags));
-                }
-                continue;
-            }
-
-            if (type === 'LineString' || type === 'MultiLineString') {
-                if (newGeometry.length === 1) {
-                    type = 'LineString';
-                    newGeometry = newGeometry[0];
-                } else {
-                    type = 'MultiLineString';
-                }
-            }
-            if (type === 'Point' || type === 'MultiPoint') {
-                type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
-            }
-
-            clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
-        }
-    }
-
-    return clipped.length ? clipped : null;
-}
-
-function clipPoints(geom, newGeom, k1, k2, axis) {
-    for (let i = 0; i < geom.length; i += 3) {
-        const a = geom[i + axis];
-
-        if (a >= k1 && a <= k2) {
-            addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
-        }
-    }
-}
-
-function clipLine(geom, newGeom, k1, k2, axis, isPolygon, trackMetrics) {
-
-    let slice = newSlice(geom);
-    const intersect = axis === 0 ? intersectX : intersectY;
-    let len = geom.start;
-    let segLen, t;
-
-    for (let i = 0; i < geom.length - 3; i += 3) {
-        const ax = geom[i];
-        const ay = geom[i + 1];
-        const az = geom[i + 2];
-        const bx = geom[i + 3];
-        const by = geom[i + 4];
-        const a = axis === 0 ? ax : ay;
-        const b = axis === 0 ? bx : by;
-        let exited = false;
-
-        if (trackMetrics) segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
-
-        if (a < k1) {
-            // ---|-->  | (line enters the clip region from the left)
-            if (b > k1) {
-                t = intersect(slice, ax, ay, bx, by, k1);
-                if (trackMetrics) slice.start = len + segLen * t;
-            }
-        } else if (a > k2) {
-            // |  <--|--- (line enters the clip region from the right)
-            if (b < k2) {
-                t = intersect(slice, ax, ay, bx, by, k2);
-                if (trackMetrics) slice.start = len + segLen * t;
-            }
-        } else {
-            addPoint(slice, ax, ay, az);
-        }
-        if (b < k1 && a >= k1) {
-            // <--|---  | or <--|-----|--- (line exits the clip region on the left)
-            t = intersect(slice, ax, ay, bx, by, k1);
-            exited = true;
-        }
-        if (b > k2 && a <= k2) {
-            // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
-            t = intersect(slice, ax, ay, bx, by, k2);
-            exited = true;
-        }
-
-        if (!isPolygon && exited) {
-            if (trackMetrics) slice.end = len + segLen * t;
-            newGeom.push(slice);
-            slice = newSlice(geom);
-        }
-
-        if (trackMetrics) len += segLen;
-    }
-
-    // add the last point
-    let last = geom.length - 3;
-    const ax = geom[last];
-    const ay = geom[last + 1];
-    const az = geom[last + 2];
-    const a = axis === 0 ? ax : ay;
-    if (a >= k1 && a <= k2) addPoint(slice, ax, ay, az);
-
-    // close the polygon if its endpoints are not the same after clipping
-    last = slice.length - 3;
-    if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
-        addPoint(slice, slice[0], slice[1], slice[2]);
-    }
-
-    // add the final slice
-    if (slice.length) {
-        newGeom.push(slice);
-    }
-}
-
-function newSlice(line) {
-    const slice = [];
-    slice.size = line.size;
-    slice.start = line.start;
-    slice.end = line.end;
-    return slice;
-}
-
-function clipLines(geom, newGeom, k1, k2, axis, isPolygon) {
-    for (const line of geom) {
-        clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
-    }
-}
-
-function addPoint(out, x, y, z) {
-    out.push(x, y, z);
-}
-
-function intersectX(out, ax, ay, bx, by, x) {
-    const t = (x - ax) / (bx - ax);
-    addPoint(out, x, ay + (by - ay) * t, 1);
-    return t;
-}
-
-function intersectY(out, ax, ay, bx, by, y) {
-    const t = (y - ay) / (by - ay);
-    addPoint(out, ax + (bx - ax) * t, y, 1);
-    return t;
-}

package/src/convert.js

@@ -1,139 +0,0 @@
-
-import simplify from './simplify.js';
-import createFeature from './feature.js';
-
-// converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
-
-export default function convert(data, options) {
-    const features = [];
-    if (data.type === 'FeatureCollection') {
-        for (let i = 0; i < data.features.length; i++) {
-            convertFeature(features, data.features[i], options, i);
-        }
-
-    } else if (data.type === 'Feature') {
-        convertFeature(features, data, options);
-
-    } else {
-        // single geometry or a geometry collection
-        convertFeature(features, {geometry: data}, options);
-    }
-
-    return features;
-}
-
-function convertFeature(features, geojson, options, index) {
-    if (!geojson.geometry) return;
-
-    const coords = geojson.geometry.coordinates;
-    if (coords && coords.length === 0) return;
-
-    const type = geojson.geometry.type;
-    const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
-    let geometry = [];
-    let id = geojson.id;
-    if (options.promoteId) {
-        id = geojson.properties[options.promoteId];
-    } else if (options.generateId) {
-        id = index || 0;
-    }
-    if (type === 'Point') {
-        convertPoint(coords, geometry);
-
-    } else if (type === 'MultiPoint') {
-        for (const p of coords) {
-            convertPoint(p, geometry);
-        }
-
-    } else if (type === 'LineString') {
-        convertLine(coords, geometry, tolerance, false);
-
-    } else if (type === 'MultiLineString') {
-        if (options.lineMetrics) {
-            // explode into linestrings to be able to track metrics
-            for (const line of coords) {
-                geometry = [];
-                convertLine(line, geometry, tolerance, false);
-                features.push(createFeature(id, 'LineString', geometry, geojson.properties));
-            }
-            return;
-        }
-        convertLines(coords, geometry, tolerance, false);
-
-    } else if (type === 'Polygon') {
-        convertLines(coords, geometry, tolerance, true);
-
-    } else if (type === 'MultiPolygon') {
-        for (const polygon of coords) {
-            const newPolygon = [];
-            convertLines(polygon, newPolygon, tolerance, true);
-            geometry.push(newPolygon);
-        }
-    } else if (type === 'GeometryCollection') {
-        for (const singleGeometry of geojson.geometry.geometries) {
-            convertFeature(features, {
-                id,
-                geometry: singleGeometry,
-                properties: geojson.properties
-            }, options, index);
-        }
-        return;
-    } else {
-        throw new Error('Input data is not a valid GeoJSON object.');
-    }
-
-    features.push(createFeature(id, type, geometry, geojson.properties));
-}
-
-function convertPoint(coords, out) {
-    out.push(projectX(coords[0]), projectY(coords[1]), 0);
-}
-
-function convertLine(ring, out, tolerance, isPolygon) {
-    let x0, y0;
-    let size = 0;
-
-    for (let j = 0; j < ring.length; j++) {
-        const x = projectX(ring[j][0]);
-        const y = projectY(ring[j][1]);
-
-        out.push(x, y, 0);
-
-        if (j > 0) {
-            if (isPolygon) {
-                size += (x0 * y - x * y0) / 2; // area
-            } else {
-                size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2)); // length
-            }
-        }
-        x0 = x;
-        y0 = y;
-    }
-
-    const last = out.length - 3;
-    out[2] = 1;
-    if (tolerance > 0) simplify(out, 0, last, tolerance);
-    out[last + 2] = 1;
-
-    out.size = Math.abs(size);
-    out.start = 0;
-    out.end = out.size;
-}
-
-function convertLines(rings, out, tolerance, isPolygon) {
-    for (let i = 0; i < rings.length; i++) {
-        const geom = [];
-        convertLine(rings[i], geom, tolerance, isPolygon);
-        out.push(geom);
-    }
-}
-
-function projectX(x) {
-    return x / 360 + 0.5;
-}
-
-function projectY(y) {
-    const sin = Math.sin(y * Math.PI / 180);
-    const y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
-    return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
-}

package/src/feature.js

@@ -1,43 +0,0 @@
-
-export default function createFeature(id, type, geom, tags) {
-    const feature = {
-        id: id == null ? null : id,
-        type,
-        geometry: geom,
-        tags,
-        minX: Infinity,
-        minY: Infinity,
-        maxX: -Infinity,
-        maxY: -Infinity
-    };
-
-    if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
-        calcLineBBox(feature, geom);
-
-    } else if (type === 'Polygon') {
-        // the outer ring (ie [0]) contains all inner rings
-        calcLineBBox(feature, geom[0]);
-
-    } else if (type === 'MultiLineString') {
-        for (const line of geom) {
-            calcLineBBox(feature, line);
-        }
-
-    } else if (type === 'MultiPolygon') {
-        for (const polygon of geom) {
-            // the outer ring (ie [0]) contains all inner rings
-            calcLineBBox(feature, polygon[0]);
-        }
-    }
-
-    return feature;
-}
-
-function calcLineBBox(feature, geom) {
-    for (let i = 0; i < geom.length; i += 3) {
-        feature.minX = Math.min(feature.minX, geom[i]);
-        feature.minY = Math.min(feature.minY, geom[i + 1]);
-        feature.maxX = Math.max(feature.maxX, geom[i]);
-        feature.maxY = Math.max(feature.maxY, geom[i + 1]);
-    }
-}

package/src/tile.js

@@ -1,123 +0,0 @@
-
-export default function createTile(features, z, tx, ty, options) {
-    const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
-    const tile = {
-        features: [],
-        numPoints: 0,
-        numSimplified: 0,
-        numFeatures: features.length,
-        source: null,
-        x: tx,
-        y: ty,
-        z,
-        transformed: false,
-        minX: 2,
-        minY: 1,
-        maxX: -1,
-        maxY: 0
-    };
-    for (const feature of features) {
-        addFeature(tile, feature, tolerance, options);
-    }
-    return tile;
-}
-
-function addFeature(tile, feature, tolerance, options) {
-    const geom = feature.geometry;
-    const type = feature.type;
-    const simplified = [];
-
-    tile.minX = Math.min(tile.minX, feature.minX);
-    tile.minY = Math.min(tile.minY, feature.minY);
-    tile.maxX = Math.max(tile.maxX, feature.maxX);
-    tile.maxY = Math.max(tile.maxY, feature.maxY);
-
-    if (type === 'Point' || type === 'MultiPoint') {
-        for (let i = 0; i < geom.length; i += 3) {
-            simplified.push(geom[i], geom[i + 1]);
-            tile.numPoints++;
-            tile.numSimplified++;
-        }
-
-    } else if (type === 'LineString') {
-        addLine(simplified, geom, tile, tolerance, false, false);
-
-    } else if (type === 'MultiLineString' || type === 'Polygon') {
-        for (let i = 0; i < geom.length; i++) {
-            addLine(simplified, geom[i], tile, tolerance, type === 'Polygon', i === 0);
-        }
-
-    } else if (type === 'MultiPolygon') {
-
-        for (let k = 0; k < geom.length; k++) {
-            const polygon = geom[k];
-            for (let i = 0; i < polygon.length; i++) {
-                addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
-            }
-        }
-    }
-
-    if (simplified.length) {
-        let tags = feature.tags || null;
-
-        if (type === 'LineString' && options.lineMetrics) {
-            tags = {};
-            for (const key in feature.tags) tags[key] = feature.tags[key];
-            /* eslint-disable dot-notation */
-            tags['mapbox_clip_start'] = geom.start / geom.size;
-            tags['mapbox_clip_end'] = geom.end / geom.size;
-            /* eslint-enable dot-notation */
-        }
-
-        const tileFeature = {
-            geometry: simplified,
-            type: type === 'Polygon' || type === 'MultiPolygon' ? 3 :
-            (type === 'LineString' || type === 'MultiLineString' ? 2 : 1),
-            tags
-        };
-        if (feature.id !== null) {
-            tileFeature.id = feature.id;
-        }
-        tile.features.push(tileFeature);
-    }
-}
-
-function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
-    const sqTolerance = tolerance * tolerance;
-
-    if (tolerance > 0 && (geom.size < (isPolygon ? sqTolerance : tolerance))) {
-        tile.numPoints += geom.length / 3;
-        return;
-    }
-
-    const ring = [];
-
-    for (let i = 0; i < geom.length; i += 3) {
-        if (tolerance === 0 || geom[i + 2] > sqTolerance) {
-            tile.numSimplified++;
-            ring.push(geom[i], geom[i + 1]);
-        }
-        tile.numPoints++;
-    }
-
-    if (isPolygon) rewind(ring, isOuter);
-
-    result.push(ring);
-}
-
-function rewind(ring, clockwise) {
-    let area = 0;
-    for (let i = 0, len = ring.length, j = len - 2; i < len; j = i, i += 2) {
-        area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
-    }
-    if (area > 0 === clockwise) {
-        for (let i = 0, len = ring.length; i < len / 2; i += 2) {
-            const x = ring[i];
-            const y = ring[i + 1];
-            ring[i] = ring[len - 2 - i];
-            ring[i + 1] = ring[len - 1 - i];
-            ring[len - 2 - i] = x;
-            ring[len - 1 - i] = y;
-        }
-    }
-}

package/src/transform.js

@@ -1,41 +0,0 @@
-
-// Transforms the coordinates of each feature in the given tile from
-// mercator-projected space into (extent x extent) tile space.
-export default function transformTile(tile, extent) {
-    if (tile.transformed) return tile;
-
-    const z2 = 1 << tile.z;
-    const tx = tile.x;
-    const ty = tile.y;
-
-    for (const feature of tile.features) {
-        const geom = feature.geometry;
-        const type = feature.type;
-
-        feature.geometry = [];
-
-        if (type === 1) {
-            for (let j = 0; j < geom.length; j += 2) {
-                feature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
-            }
-        } else {
-            for (let j = 0; j < geom.length; j++) {
-                const ring = [];
-                for (let k = 0; k < geom[j].length; k += 2) {
-                    ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
-                }
-                feature.geometry.push(ring);
-            }
-        }
-    }
-
-    tile.transformed = true;
-
-    return tile;
-}
-
-function transformPoint(x, y, extent, z2, tx, ty) {
-    return [
-        Math.round(extent * (x * z2 - tx)),
-        Math.round(extent * (y * z2 - ty))];
-}

package/src/wrap.js

@@ -1,68 +0,0 @@
-
-import clip from './clip.js';
-import createFeature from './feature.js';
-
-export default function wrap(features, options) {
-    const buffer = options.buffer / options.extent;
-    let merged = features;
-    const left  = clip(features, 1, -1 - buffer, buffer,     0, -1, 2, options); // left world copy
-    const right = clip(features, 1,  1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
-
-    if (left || right) {
-        merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
-
-        if (left) merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
-        if (right) merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center
-    }
-
-    return merged;
-}
-
-function shiftFeatureCoords(features, offset) {
-    const newFeatures = [];
-
-    for (let i = 0; i < features.length; i++) {
-        const feature = features[i];
-        const type = feature.type;
-
-        let newGeometry;
-
-        if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
-            newGeometry = shiftCoords(feature.geometry, offset);
-
-        } else if (type === 'MultiLineString' || type === 'Polygon') {
-            newGeometry = [];
-            for (const line of feature.geometry) {
-                newGeometry.push(shiftCoords(line, offset));
-            }
-        } else if (type === 'MultiPolygon') {
-            newGeometry = [];
-            for (const polygon of feature.geometry) {
-                const newPolygon = [];
-                for (const line of polygon) {
-                    newPolygon.push(shiftCoords(line, offset));
-                }
-                newGeometry.push(newPolygon);
-            }
-        }
-
-        newFeatures.push(createFeature(feature.id, type, newGeometry, feature.tags));
-    }
-
-    return newFeatures;
-}
-
-function shiftCoords(points, offset) {
-    const newPoints = [];
-    newPoints.size = points.size;
-
-    if (points.start !== undefined) {
-        newPoints.start = points.start;
-        newPoints.end = points.end;
-    }
-
-    for (let i = 0; i < points.length; i += 3) {
-        newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
-    }
-    return newPoints;
-}