@scoova/mgl 1.0.0

package/src/geo/mercator_coordinate.test.ts

@@ -0,0 +1,34 @@
+import {LngLat} from './lng_lat';
+import {MercatorCoordinate, mercatorScale} from './mercator_coordinate';
+
+describe('LngLat', () => {
+    test('#constructor', () => {
+        expect(new MercatorCoordinate(0, 0) instanceof MercatorCoordinate).toBeTruthy();
+        expect(new MercatorCoordinate(0, 0, 0) instanceof MercatorCoordinate).toBeTruthy();
+    });
+
+    test('#fromLngLat', () => {
+        const nullIsland = new LngLat(0, 0);
+        expect(MercatorCoordinate.fromLngLat(nullIsland)).toEqual({x: 0.5, y: 0.5, z: 0});
+    });
+
+    test('#toLngLat', () => {
+        const dc = new LngLat(-77, 39);
+        expect(MercatorCoordinate.fromLngLat(dc, 500).toLngLat()).toEqual({lng: -77, lat: 39});
+    });
+
+    test('#toAltitude', () => {
+        const dc = new LngLat(-77, 39);
+        expect(MercatorCoordinate.fromLngLat(dc, 500).toAltitude()).toBe(500);
+    });
+
+    test('#mercatorScale', () => {
+        expect(mercatorScale(0)).toBe(1);
+        expect(mercatorScale(45)).toBe(1.414213562373095);
+    });
+
+    test('#meterInMercatorCoordinateUnits', () => {
+        const nullIsland = new LngLat(0, 0);
+        expect(MercatorCoordinate.fromLngLat(nullIsland).meterInMercatorCoordinateUnits()).toBe(2.4981121214570498e-8);
+    });
+});

package/src/geo/mercator_coordinate.ts

@@ -0,0 +1,157 @@
+import {LngLat, earthRadius} from '../geo/lng_lat';
+import type {LngLatLike} from '../geo/lng_lat';
+import {IMercatorCoordinate} from '@maplibre/maplibre-gl-style-spec';
+
+/*
+ * The average circumference of the world in meters.
+ */
+const earthCircumference = 2 * Math.PI * earthRadius; // meters
+
+/*
+ * The circumference at a line of latitude in meters.
+ */
+function circumferenceAtLatitude(latitude: number) {
+    return earthCircumference * Math.cos(latitude * Math.PI / 180);
+}
+
+export function mercatorXfromLng(lng: number) {
+    return (180 + lng) / 360;
+}
+
+export function mercatorYfromLat(lat: number) {
+    return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
+}
+
+export function mercatorZfromAltitude(altitude: number, lat: number) {
+    return altitude / circumferenceAtLatitude(lat);
+}
+
+export function lngFromMercatorX(x: number) {
+    return x * 360 - 180;
+}
+
+export function latFromMercatorY(y: number) {
+    const y2 = 180 - y * 360;
+    return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+}
+
+export function altitudeFromMercatorZ(z: number, y: number) {
+    return z * circumferenceAtLatitude(latFromMercatorY(y));
+}
+
+/**
+ * Determine the Mercator scale factor for a given latitude, see
+ * https://en.wikipedia.org/wiki/Mercator_projection#Scale_factor
+ *
+ * At the equator the scale factor will be 1, which increases at higher latitudes.
+ *
+ * @param lat - Latitude
+ * @returns scale factor
+ */
+export function mercatorScale(lat: number) {
+    return 1 / Math.cos(lat * Math.PI / 180);
+}
+
+/**
+ * A `MercatorCoordinate` object represents a projected three dimensional position.
+ *
+ * `MercatorCoordinate` uses the web mercator projection ([EPSG:3857](https://epsg.io/3857)) with slightly different units:
+ *
+ * - the size of 1 unit is the width of the projected world instead of the "mercator meter"
+ * - the origin of the coordinate space is at the north-west corner instead of the middle
+ *
+ * For example, `MercatorCoordinate(0, 0, 0)` is the north-west corner of the mercator world and
+ * `MercatorCoordinate(1, 1, 0)` is the south-east corner. If you are familiar with
+ * [vector tiles](https://github.com/mapbox/vector-tile-spec) it may be helpful to think
+ * of the coordinate space as the `0/0/0` tile with an extent of `1`.
+ *
+ * The `z` dimension of `MercatorCoordinate` is conformal. A cube in the mercator coordinate space would be rendered as a cube.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let nullIsland = new MercatorCoordinate(0.5, 0.5, 0);
+ * ```
+ * @see [Add a custom style layer](https://maplibre.org/maplibre-gl-js/docs/examples/custom-style-layer/)
+ */
+export class MercatorCoordinate implements IMercatorCoordinate {
+    x: number;
+    y: number;
+    z: number;
+
+    /**
+     * @param x - The x component of the position.
+     * @param y - The y component of the position.
+     * @param z - The z component of the position.
+     */
+    constructor(x: number, y: number, z: number = 0) {
+        this.x = +x;
+        this.y = +y;
+        this.z = +z;
+    }
+
+    /**
+     * Project a `LngLat` to a `MercatorCoordinate`.
+     *
+     * @param lngLatLike - The location to project.
+     * @param altitude - The altitude in meters of the position.
+     * @returns The projected mercator coordinate.
+     * @example
+     * ```ts
+     * let coord = MercatorCoordinate.fromLngLat({ lng: 0, lat: 0}, 0);
+     * coord; // MercatorCoordinate(0.5, 0.5, 0)
+     * ```
+     */
+    static fromLngLat(lngLatLike: LngLatLike, altitude: number = 0): MercatorCoordinate {
+        const lngLat = LngLat.convert(lngLatLike);
+
+        return new MercatorCoordinate(
+            mercatorXfromLng(lngLat.lng),
+            mercatorYfromLat(lngLat.lat),
+            mercatorZfromAltitude(altitude, lngLat.lat));
+    }
+
+    /**
+     * Returns the `LngLat` for the coordinate.
+     *
+     * @returns The `LngLat` object.
+     * @example
+     * ```ts
+     * let coord = new MercatorCoordinate(0.5, 0.5, 0);
+     * let lngLat = coord.toLngLat(); // LngLat(0, 0)
+     * ```
+     */
+    toLngLat() {
+        return new LngLat(
+            lngFromMercatorX(this.x),
+            latFromMercatorY(this.y));
+    }
+
+    /**
+     * Returns the altitude in meters of the coordinate.
+     *
+     * @returns The altitude in meters.
+     * @example
+     * ```ts
+     * let coord = new MercatorCoordinate(0, 0, 0.02);
+     * coord.toAltitude(); // 6914.281956295339
+     * ```
+     */
+    toAltitude(): number {
+        return altitudeFromMercatorZ(this.z, this.y);
+    }
+
+    /**
+     * Returns the distance of 1 meter in `MercatorCoordinate` units at this latitude.
+     *
+     * For coordinates in real world units using meters, this naturally provides the scale
+     * to transform into `MercatorCoordinate`s.
+     *
+     * @returns Distance of 1 meter in `MercatorCoordinate` units.
+     */
+    meterInMercatorCoordinateUnits(): number {
+        // 1 meter / circumference at equator in meters * Mercator projection scale factor at this latitude
+        return 1 / earthCircumference * mercatorScale(latFromMercatorY(this.y));
+    }
+}

package/src/geo/projection/projection.ts

@@ -0,0 +1,72 @@
+import type {Tile} from '../../source/tile';
+import {pixelsToTileUnits} from '../../source/pixels_to_tile_units';
+import type {PointProjection} from '../../symbol/projection';
+
+/**
+ * A greatly reduced version of the `Projection` interface from the globe branch,
+ * used to port symbol bugfixes over to the main branch. Will be replaced with
+ * the proper interface once globe is merged.
+ */
+export type Projection = {
+    useSpecialProjectionForSymbols: boolean;
+    isOccluded(_x, _y, _t): boolean;
+    projectTileCoordinates(_x, _y, _t, _ele): PointProjection;
+    getPitchedTextCorrection(_transform, _anchor, _tile): number;
+    translatePosition(transform: { angle: number; zoom: number }, tile: Tile, translate: [number, number], translateAnchor: 'map' | 'viewport'): [number, number];
+    getCircleRadiusCorrection(tr: any): number;
+};
+
+export function createProjection(): Projection {
+    return {
+        isOccluded(_x: any, _y: any, _t: any) {
+            return false;
+        },
+        getPitchedTextCorrection(_transform: any, _anchor: any, _tile: any) {
+            return 1.0;
+        },
+        get useSpecialProjectionForSymbols() { return false; },
+        projectTileCoordinates(_x, _y, _t, _ele) {
+            // This function should only be used when useSpecialProjectionForSymbols is set to true.
+            throw new Error('Not implemented.');
+        },
+        translatePosition(transform, tile, translate, translateAnchor) {
+            return translatePosition(transform, tile, translate, translateAnchor);
+        },
+        getCircleRadiusCorrection(_: any) {
+            return 1.0;
+        }
+    };
+}
+
+/**
+ * Returns a translation in tile units that correctly incorporates the view angle and the *-translate and *-translate-anchor properties.
+ * @param inViewportPixelUnitsUnits - True when the units accepted by the matrix are in viewport pixels instead of tile units.
+ *
+ * Temporarily imported from globe branch.
+ */
+function translatePosition(
+    transform: { angle: number; zoom: number },
+    tile: Tile,
+    translate: [number, number],
+    translateAnchor: 'map' | 'viewport',
+    inViewportPixelUnitsUnits: boolean = false
+): [number, number] {
+    if (!translate[0] && !translate[1]) return [0, 0];
+
+    const angle = inViewportPixelUnitsUnits ?
+        (translateAnchor === 'map' ? transform.angle : 0) :
+        (translateAnchor === 'viewport' ? -transform.angle : 0);
+
+    if (angle) {
+        const sinA = Math.sin(angle);
+        const cosA = Math.cos(angle);
+        translate = [
+            translate[0] * cosA - translate[1] * sinA,
+            translate[0] * sinA + translate[1] * cosA
+        ];
+    }
+
+    return [
+        inViewportPixelUnitsUnits ? translate[0] : pixelsToTileUnits(tile, translate[0], transform.zoom),
+        inViewportPixelUnitsUnits ? translate[1] : pixelsToTileUnits(tile, translate[1], transform.zoom)];
+}