@maplibre/geojson-vt 5.0.3 → 6.0.0

package/src/convert.ts

@@ -1,131 +1,147 @@
 
 import {simplify} from './simplify';
 import {createFeature} from './feature';
-import type { GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray } from './definitions';
+import type {GeoJSONVTInternalFeature, GeoJSONVTOptions, StartEndSizeArray} from './definitions';
 
 /**
- * converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
+ * converts GeoJSON to internal source features (an intermediate projected JSON vector format with simplification data)
  * @param data
  * @param options
  * @returns
  */
-export function convert(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
+export function convertToInternal(data: GeoJSON.GeoJSON, options: GeoJSONVTOptions): GeoJSONVTInternalFeature[] {
     const features: GeoJSONVTInternalFeature[] = [];
 
     switch (data.type) {
         case 'FeatureCollection':
             for (let i = 0; i < data.features.length; i++) {
-                convertFeature(features, data.features[i], options, i);
+                featureToInternal(features, data.features[i], options, i);
             }
             break;
         case 'Feature':
-            convertFeature(features, data, options);
+            featureToInternal(features, data, options);
             break;
         default:
-            convertFeature(features, {type: "Feature" as const, geometry: data, properties: undefined}, options);
+            featureToInternal(features, {type: "Feature" as const, geometry: data, properties: undefined}, options);
     }
 
     return features;
 }
 
-function convertFeature(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number) {
+function featureToInternal(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number) {
     if (!geojson.geometry) return;
 
     if (geojson.geometry.type === 'GeometryCollection') {
-        for (const singleGeometry of geojson.geometry.geometries) {
-            convertFeature(features, {
-                id: geojson.id,
-                type: 'Feature',
-                geometry: singleGeometry,
-                properties: geojson.properties
-            }, options, index);
-        }
+        convertGeometryCollection(features, geojson, geojson.geometry, options, index);
         return;
     }
 
     const coords = geojson.geometry.coordinates;
     if (!coords?.length) return;
 
+    const id = getFeatureId(geojson, options, index);
     const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
-    let id = geojson.id;
-    if (options.promoteId) {
-        id = geojson.properties?.[options.promoteId];
-    } else if (options.generateId) {
-        id = index || 0;
-    }
 
     switch (geojson.geometry.type) {
-        case 'Point': {
-            const pointGeometry: StartEndSizeArray = [];
-            convertPoint(geojson.geometry.coordinates, pointGeometry);
+        case 'Point':
+            convertPointFeature(features, id, geojson.geometry, geojson.properties);
+            return;
 
-            features.push(createFeature(id, geojson.geometry.type, pointGeometry, geojson.properties));
+        case 'MultiPoint':
+            convertMultiPointFeature(features, id, geojson.geometry, geojson.properties);
             return;
-        }
 
-        case 'MultiPoint': {
-            const multiPointGeometry: StartEndSizeArray = [];
-            for (const p of geojson.geometry.coordinates) {
-                convertPoint(p, multiPointGeometry);
-            }
+        case 'LineString':
+            convertLineStringFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            return;
 
-            features.push(createFeature(id, geojson.geometry.type, multiPointGeometry, geojson.properties));
+        case 'MultiLineString':
+            convertMultiLineStringFeature(features, id, geojson.geometry, tolerance, options, geojson.properties);
             return;
-        }
 
-        case 'LineString': {
-            const lineGeometry: StartEndSizeArray = [];
-            convertLine(geojson.geometry.coordinates, lineGeometry, tolerance, false);
+        case 'Polygon':
+            convertPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
+            return;
 
-            features.push(createFeature(id, geojson.geometry.type, lineGeometry, geojson.properties));
+        case 'MultiPolygon':
+            convertMultiPolygonFeature(features, id, geojson.geometry, tolerance, geojson.properties);
             return;
-        }
 
-        case 'MultiLineString': {
-            if (options.lineMetrics) {
-                // explode into linestrings in order to track metrics
-                for (const line of geojson.geometry.coordinates) {
-                    const lineGeometry: StartEndSizeArray = [];
-                    convertLine(line, lineGeometry, tolerance, false);
-                    features.push(createFeature(id, 'LineString', lineGeometry, geojson.properties));
-                }
-                return;
-            }
+        default:
+            throw new Error('Input data is not a valid GeoJSON object.');
+    }
+}
 
-            const multiLineGeometry: StartEndSizeArray[] = [];
-            convertLines(geojson.geometry.coordinates, multiLineGeometry, tolerance, false);
+function getFeatureId(geojson: GeoJSON.Feature, options: GeoJSONVTOptions, index?: number): number | string | undefined {
+    if (options.promoteId) {
+        return geojson.properties?.[options.promoteId];
+    }
+    if (options.generateId) {
+        return index || 0;
+    }
+    return geojson.id;
+}
 
-            features.push(createFeature(id, geojson.geometry.type, multiLineGeometry, geojson.properties));
-            return;
-        }
+function convertGeometryCollection(features: GeoJSONVTInternalFeature[], geojson: GeoJSON.Feature, geometry: GeoJSON.GeometryCollection, options: GeoJSONVTOptions, index?: number) {
+    for (const geom of geometry.geometries) {
+        featureToInternal(features, {
+            id: geojson.id,
+            type: 'Feature',
+            geometry: geom,
+            properties: geojson.properties
+        }, options, index);
+    }
+}
 
-        case 'Polygon': {
-            const polygonGeometry: StartEndSizeArray[] = [];
-            convertLines(geojson.geometry.coordinates, polygonGeometry, tolerance, true);
+function convertPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Point, properties: GeoJSON.GeoJsonProperties) {
+    const out: number[] = [];
+    out.push(projectX(geom.coordinates[0]), projectY(geom.coordinates[1]), 0);
+    features.push(createFeature(id, 'Point', out, properties));
+}
 
-            features.push(createFeature(id, geojson.geometry.type, polygonGeometry, geojson.properties));
-            return;
-        }
+function convertMultiPointFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiPoint, properties: GeoJSON.GeoJsonProperties) {
+    const out: number[] = [];
+    for (const coords of geom.coordinates) {
+        out.push(projectX(coords[0]), projectY(coords[1]), 0);
+    }
+    features.push(createFeature(id, 'MultiPoint', out, properties));
+}
 
-        case 'MultiPolygon': {
-            const multiPolygonGeometry: StartEndSizeArray[][] = [];
-            for (const polygon of geojson.geometry.coordinates) {
-                const newPolygon: StartEndSizeArray[] = [];
-                convertLines(polygon, newPolygon, tolerance, true);
-                multiPolygonGeometry.push(newPolygon);
-            }
+function convertLineStringFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.LineString, tolerance: number, properties: GeoJSON.GeoJsonProperties) {
+    const out: StartEndSizeArray = [];
+    convertLine(geom.coordinates, out, tolerance, false);
+    features.push(createFeature(id, 'LineString', out, properties));
+}
 
-            features.push(createFeature(id, geojson.geometry.type, multiPolygonGeometry, geojson.properties));
-            return;
+function convertMultiLineStringFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiLineString, tolerance: number, options: GeoJSONVTOptions, properties: GeoJSON.GeoJsonProperties) {
+    if (options.lineMetrics) {
+        // explode into linestrings to be able to track metrics
+        for (const line of geom.coordinates) {
+            const out: StartEndSizeArray = [];
+            convertLine(line, out, tolerance, false);
+            features.push(createFeature(id, 'LineString', out, properties));
         }
-
-        default:
-            throw new Error('Input data is not a valid GeoJSON object.');
+    } else {
+        const out: StartEndSizeArray[] = [];
+        convertLines(geom.coordinates, out, tolerance, false);
+        features.push(createFeature(id, 'MultiLineString', out, properties));
     }
 }
 
-function convertPoint(coords: GeoJSON.Position, out: number[]) {
-    out.push(projectX(coords[0]), projectY(coords[1]), 0);
+function convertPolygonFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.Polygon, tolerance: number, properties: GeoJSON.GeoJsonProperties) {
+    const out: StartEndSizeArray[] = [];
+    convertLines(geom.coordinates, out, tolerance, true);
+    features.push(createFeature(id, 'Polygon', out, properties));
+}
+
+function convertMultiPolygonFeature(features: GeoJSONVTInternalFeature[], id: number | string | undefined, geom: GeoJSON.MultiPolygon, tolerance: number, properties: GeoJSON.GeoJsonProperties) {
+    const out: StartEndSizeArray[][] = [];
+    for (const polygon of geom.coordinates) {
+        const polygonOut: StartEndSizeArray[] = [];
+        convertLines(polygon, polygonOut, tolerance, true);
+        out.push(polygonOut);
+    }
+    features.push(createFeature(id, 'MultiPolygon', out, properties));
 }
 
 function convertLine(ring: GeoJSON.Position[], out: StartEndSizeArray, tolerance: number, isPolygon: boolean) {
@@ -167,11 +183,17 @@ function convertLines(rings: GeoJSON.Position[][], out: StartEndSizeArray[], tol
     }
 }
 
-function projectX(x: number) {
+/**
+ * Convert longitude to spherical mercator in [0..1] range
+ */
+export function projectX(x: number) {
     return x / 360 + 0.5;
 }
 
-function projectY(y: number) {
+/**
+ * Convert latitude to spherical mercator in [0..1] range
+ */
+export function projectY(y: number) {
     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/deconvert.test.ts

@@ -0,0 +1,153 @@
+
+import {test, expect} from 'vitest';
+import {featureToGeoJSON, unprojectX, unprojectY} from './deconvert';
+import {projectX, projectY} from './convert';
+import type {GeoJSONVTInternalFeature} from './definitions';
+
+test('project/unproject roundtrip retains precision', () => {
+    const coords = [
+        {lng: 0, lat: 0},
+        {lng: 90, lat: 45.0564839289},
+        {lng: -90, lat: -45.0564839289},
+        {lng: 180, lat: 85.0511287798},
+        {lng: -180, lat: -85.0511287798},
+        {lng: 45.1234567895, lat: 23.5456789012},
+        {lng: -123.9876543210, lat: -67.8901234564},
+        {lng: 0.0000000001, lat: 0.0000000001},
+        {lng: 179.9999999999, lat: 85},
+        {lng: -179.9999999999, lat: -85}
+    ];
+
+    for (const {lng, lat} of coords) {
+        expect(unprojectX(projectX(lng))).toBeCloseTo(lng, 10);
+        expect(unprojectY(projectY(lat))).toBeCloseTo(lat, 10);
+    }
+});
+
+test('featureToGeoJSON: converts Point geometry', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'Point',
+        id: 'point1',
+        geometry: [0.5, 0.5, 0],
+        tags: {name: 'Test Point'},
+        minX: 0.5, minY: 0.5, maxX: 0.5, maxY: 0.5
+    };
+
+    const result = featureToGeoJSON(feature);
+
+    expect(result.type).toBe('Feature');
+    expect(result.geometry.type).toBe('Point');
+    expect((result.geometry as GeoJSON.Point).coordinates).toEqual([0, 0]);
+    expect(result.id).toBe('point1');
+    expect(result.properties).toEqual({name: 'Test Point'});
+});
+
+test('featureToGeoJSON: converts MultiPoint geometry', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'MultiPoint',
+        id: 'multipoint1',
+        geometry: [0.5, 0.5, 0, 0.525, 0.5, 0],
+        tags: {},
+        minX: 0.5, minY: 0.5, maxX: 0.525, maxY: 0.5
+    };
+
+    const result = featureToGeoJSON(feature);
+
+    expect(result.geometry.type).toBe('MultiPoint');
+    expect((result.geometry as GeoJSON.MultiPoint).coordinates.length).toBe(2);
+});
+
+test('featureToGeoJSON: converts LineString geometry', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'LineString',
+        id: 'line1',
+        geometry: [0.5, 0.5, 0, 0.525, 0.5, 0, 0.525, 0.525, 0],
+        tags: {highway: 'primary'},
+        minX: 0.5, minY: 0.5, maxX: 0.525, maxY: 0.525
+    };
+
+    const result = featureToGeoJSON(feature);
+
+    expect(result.geometry.type).toBe('LineString');
+    expect((result.geometry as GeoJSON.LineString).coordinates.length).toBe(3);
+});
+
+test('featureToGeoJSON: converts MultiLineString geometry', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'MultiLineString',
+        id: 'multiline1',
+        geometry: [
+            [0.5, 0.5, 0, 0.525, 0.5, 0],
+            [0.55, 0.55, 0, 0.575, 0.55, 0]
+        ],
+        tags: {},
+        minX: 0.5, minY: 0.5, maxX: 0.575, maxY: 0.55
+    };
+
+    const result = featureToGeoJSON(feature);
+
+    expect(result.geometry.type).toBe('MultiLineString');
+    expect((result.geometry as GeoJSON.MultiLineString).coordinates.length).toBe(2);
+});
+
+test('featureToGeoJSON: converts Polygon geometry', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'Polygon',
+        id: 'polygon1',
+        geometry: [
+            [0.5, 0.5, 0, 0.6, 0.5, 0, 0.6, 0.6, 0, 0.5, 0.6, 0, 0.5, 0.5, 0],
+            [0.52, 0.52, 0, 0.58, 0.52, 0, 0.58, 0.58, 0, 0.52, 0.58, 0, 0.52, 0.52, 0]
+        ],
+        tags: {landuse: 'residential'},
+        minX: 0.5, minY: 0.5, maxX: 0.6, maxY: 0.6
+    };
+
+    const result = featureToGeoJSON(feature);
+
+    expect(result.geometry.type).toBe('Polygon');
+    expect((result.geometry as GeoJSON.Polygon).coordinates.length).toBe(2);
+});
+
+test('featureToGeoJSON: converts MultiPolygon geometry', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'MultiPolygon',
+        id: 'multipolygon1',
+        geometry: [
+            [[0.5, 0.5, 0, 0.52, 0.5, 0, 0.52, 0.52, 0, 0.5, 0.52, 0, 0.5, 0.5, 0]],
+            [[0.55, 0.55, 0, 0.57, 0.55, 0, 0.57, 0.57, 0, 0.55, 0.57, 0, 0.55, 0.55, 0]]
+        ],
+        tags: {},
+        minX: 0.5, minY: 0.5, maxX: 0.57, maxY: 0.57
+    };
+
+    const result = featureToGeoJSON(feature);
+
+    expect(result.geometry.type).toBe('MultiPolygon');
+    expect((result.geometry as GeoJSON.MultiPolygon).coordinates.length).toBe(2);
+});
+
+test('featureToGeoJSON: handles various id types', () => {
+    const noId: GeoJSONVTInternalFeature = {type: 'Point', geometry: [0.5, 0.5, 0], tags: {}, minX: 0.5, minY: 0.5, maxX: 0.5, maxY: 0.5};
+    const stringId: GeoJSONVTInternalFeature = {type: 'Point', id: 'string-id', geometry: [0.5, 0.5, 0], tags: {}, minX: 0.5, minY: 0.5, maxX: 0.5, maxY: 0.5};
+    const numberId: GeoJSONVTInternalFeature = {type: 'Point', id: 42, geometry: [0.5, 0.5, 0], tags: {}, minX: 0.5, minY: 0.5, maxX: 0.5, maxY: 0.5};
+
+    expect(featureToGeoJSON(noId).id).toBeUndefined();
+    expect(featureToGeoJSON(stringId).id).toBe('string-id');
+    expect(featureToGeoJSON(numberId).id).toBe(42);
+});
+
+test('featureToGeoJSON: correctly unprojects known coordinates', () => {
+    const feature: GeoJSONVTInternalFeature = {
+        type: 'MultiPoint',
+        geometry: [0.5, 0.5, 0, 0, 0.5, 0, 1, 0.5, 0],
+        tags: {},
+        minX: 0, minY: 0.5, maxX: 1, maxY: 0.5
+    };
+
+    const result = featureToGeoJSON(feature);
+    const coords = (result.geometry as GeoJSON.MultiPoint).coordinates;
+
+    expect(coords[0]).toEqual([0, 0]);
+    expect(coords[1]).toEqual([-180, 0]);
+    expect(coords[2]).toEqual([180, 0]);
+});

package/src/deconvert.ts

@@ -0,0 +1,92 @@
+import type {GeoJSONVTInternalFeature} from './definitions';
+
+/**
+ * Converts internal source features back to GeoJSON format.
+ */
+export function convertToGeoJSON(source: GeoJSONVTInternalFeature[]): GeoJSON.GeoJSON {
+    const geojson: GeoJSON.GeoJSON = {
+        type: 'FeatureCollection',
+        features: source.map(feature => featureToGeoJSON(feature))
+    };
+
+    return geojson;
+}
+
+/**
+ * Converts a single internal feature to GeoJSON format.
+ */
+export function featureToGeoJSON(feature: GeoJSONVTInternalFeature): GeoJSON.Feature {
+    const geojsonFeature: GeoJSON.Feature = {
+        type: 'Feature',
+        geometry: geometryToGeoJSON(feature),
+        properties: feature.tags
+    };
+    if (feature.id != null) {
+        geojsonFeature.id = feature.id;
+    }
+
+    return geojsonFeature;
+}
+
+/**
+ * Converts a single internal feature geometry to GeoJSON format.
+ */
+function geometryToGeoJSON(feature: GeoJSONVTInternalFeature): GeoJSON.Geometry {
+    const {type, geometry} = feature;
+
+    switch (type) {
+        case 'Point':
+            return {
+                type: type,
+                coordinates: unprojectPoint(geometry[0], geometry[1])
+            };
+        case 'MultiPoint':
+        case 'LineString':
+            return {
+                type: type,
+                coordinates: unprojectPoints(geometry)
+            };
+        case 'MultiLineString':
+        case 'Polygon':
+            return {
+                type: type,
+                coordinates: geometry.map(ring => unprojectPoints(ring))
+            };
+        case 'MultiPolygon':
+            return {
+                type: type,
+                coordinates: geometry.map(polygon =>
+                    polygon.map(ring => unprojectPoints(ring))
+                )
+            };
+    }
+}
+
+export function unprojectPoints(coords: number[]): GeoJSON.Position[] {
+    const result: GeoJSON.Position[] = [];
+
+    for (let i = 0; i < coords.length; i += 3) {
+        result.push(unprojectPoint(coords[i], coords[i + 1]));
+    }
+
+    return result;
+}
+
+function unprojectPoint(x: number, y: number): GeoJSON.Position {
+    return [unprojectX(x), unprojectY(y)];
+}
+
+/**
+ * Convert spherical mercator in [0..1] range to longitude
+ */
+export function unprojectX(x: number): number {
+    return (x - 0.5) * 360;
+}
+
+/**
+ * Convert spherical mercator in [0..1] range to latitude
+ */
+export function unprojectY(y: number): number {
+    const y2 = (180 - y * 360) * Math.PI / 180;
+    return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
+}