@scoova/mgl 1.0.0

package/src/geo/transform.test.ts

@@ -0,0 +1,509 @@
+import Point from '@mapbox/point-geometry';
+import {MAX_VALID_LATITUDE, Transform} from './transform';
+import {LngLat} from './lng_lat';
+import {OverscaledTileID, CanonicalTileID} from '../source/tile_id';
+import {fixedLngLat, fixedCoord} from '../../test/unit/lib/fixed';
+import type {Terrain} from '../render/terrain';
+
+describe('transform', () => {
+    test('creates a transform', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(500, 500);
+        expect(transform.unmodified).toBe(true);
+        expect(transform.tileSize).toBe(512);
+        expect(transform.worldSize).toBe(512);
+        expect(transform.width).toBe(500);
+        expect(transform.minZoom).toBe(0);
+        expect(transform.minPitch).toBe(0);
+        // Support signed zero
+        expect(transform.bearing === 0 ? 0 : transform.bearing).toBe(0);
+        expect(transform.bearing = 1).toBe(1);
+        expect(transform.bearing).toBe(1);
+        expect(transform.bearing = 0).toBe(0);
+        expect(transform.unmodified).toBe(false);
+        expect(transform.minZoom = 10).toBe(10);
+        expect(transform.maxZoom = 10).toBe(10);
+        expect(transform.minZoom).toBe(10);
+        expect(transform.center).toEqual({lng: 0, lat: 0});
+        expect(transform.maxZoom).toBe(10);
+        expect(transform.minPitch = 10).toBe(10);
+        expect(transform.maxPitch = 10).toBe(10);
+        expect(transform.size.equals(new Point(500, 500))).toBe(true);
+        expect(transform.centerPoint.equals(new Point(250, 250))).toBe(true);
+        expect(transform.scaleZoom(0)).toBe(-Infinity);
+        expect(transform.scaleZoom(10)).toBe(3.3219280948873626);
+        expect(transform.point).toEqual(new Point(262144, 262144));
+        expect(transform.height).toBe(500);
+        expect(transform.nearZ).toBe(10);
+        expect(transform.farZ).toBe(804.8028169246645);
+        expect([...transform.projectionMatrix.values()]).toEqual([3, 0, 0, 0, 0, 3, 0, 0, -0, 0, -1.0251635313034058, -1, 0, 0, -20.25163459777832, 0]);
+        expect([...transform.modelViewProjectionMatrix.values()]).toEqual([3, 0, 0, 0, 0, -2.954423259036624, -0.1780177690666898, -0.17364817766693033, 0, 0.006822967915294533, -0.013222891287479163, -0.012898324631281611, -786432, 774484.3308168967, 47414.91102496082, 46270.827886319785]);
+        expect(fixedLngLat(transform.pointLocation(new Point(250, 250)))).toEqual({lng: 0, lat: 0});
+        expect(fixedCoord(transform.pointCoordinate(new Point(250, 250)))).toEqual({x: 0.5, y: 0.5, z: 0});
+        expect(transform.locationPoint(new LngLat(0, 0))).toEqual({x: 250, y: 250});
+        expect(transform.locationCoordinate(new LngLat(0, 0))).toEqual({x: 0.5, y: 0.5, z: 0});
+    });
+
+    test('does not throw on bad center', () => {
+        expect(() => {
+            const transform = new Transform(0, 22, 0, 60, true);
+            transform.resize(500, 500);
+            transform.center = new LngLat(50, -90);
+        }).not.toThrow();
+    });
+
+    test('setLocationAt', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(500, 500);
+        transform.zoom = 4;
+        expect(transform.center).toEqual({lng: 0, lat: 0});
+        transform.setLocationAtPoint(new LngLat(13, 10), new Point(15, 45));
+        expect(fixedLngLat(transform.pointLocation(new Point(15, 45)))).toEqual({lng: 13, lat: 10});
+    });
+
+    test('setLocationAt tilted', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(500, 500);
+        transform.zoom = 4;
+        transform.pitch = 50;
+        expect(transform.center).toEqual({lng: 0, lat: 0});
+        transform.setLocationAtPoint(new LngLat(13, 10), new Point(15, 45));
+        expect(fixedLngLat(transform.pointLocation(new Point(15, 45)))).toEqual({lng: 13, lat: 10});
+    });
+
+    test('has a default zoom', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(500, 500);
+        expect(transform.tileZoom).toBe(0);
+        expect(transform.tileZoom).toBe(transform.zoom);
+    });
+
+    test('set zoom inits tileZoom with zoom value', () => {
+        const transform = new Transform(0, 22, 0, 60);
+        transform.zoom = 5;
+        expect(transform.tileZoom).toBe(5);
+    });
+
+    test('set zoom clamps tileZoom to non negative value ', () => {
+        const transform = new Transform(-2, 22, 0, 60);
+        transform.zoom = -2;
+        expect(transform.tileZoom).toBe(0);
+    });
+
+    test('set fov', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.fov = 10;
+        expect(transform.fov).toBe(10);
+        transform.fov = 10;
+        expect(transform.fov).toBe(10);
+    });
+
+    test('lngRange & latRange constrain zoom and center', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.center = new LngLat(0, 0);
+        transform.zoom = 10;
+        transform.resize(500, 500);
+
+        transform.lngRange = [-5, 5];
+        transform.latRange = [-5, 5];
+
+        transform.zoom = 0;
+        expect(transform.zoom).toBe(5.1357092861044045);
+
+        transform.center = new LngLat(-50, -30);
+        expect(transform.center).toEqual(new LngLat(0, -0.0063583052861417855));
+
+        transform.zoom = 10;
+        transform.center = new LngLat(-50, -30);
+        expect(transform.center).toEqual(new LngLat(-4.828338623046875, -4.828969771321582));
+    });
+
+    test('lngRange & latRange constrain zoom and center after cloning', () => {
+        const old = new Transform(0, 22, 0, 60, true);
+        old.center = new LngLat(0, 0);
+        old.zoom = 10;
+        old.resize(500, 500);
+
+        old.lngRange = [-5, 5];
+        old.latRange = [-5, 5];
+
+        const transform = old.clone();
+
+        transform.zoom = 0;
+        expect(transform.zoom).toBe(5.1357092861044045);
+
+        transform.center = new LngLat(-50, -30);
+        expect(transform.center).toEqual(new LngLat(0, -0.0063583052861417855));
+
+        transform.zoom = 10;
+        transform.center = new LngLat(-50, -30);
+        expect(transform.center).toEqual(new LngLat(-4.828338623046875, -4.828969771321582));
+    });
+
+    test('lngRange can constrain zoom and center across meridian', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.center = new LngLat(180, 0);
+        transform.zoom = 10;
+        transform.resize(500, 500);
+
+        // equivalent ranges
+        const lngRanges: [number, number][] = [
+            [175, -175], [175, 185], [-185, -175], [-185, 185]
+        ];
+
+        for (const lngRange of lngRanges) {
+            transform.lngRange = lngRange;
+            transform.latRange = [-5, 5];
+
+            transform.zoom = 0;
+            expect(transform.zoom).toBe(5.1357092861044045);
+
+            transform.center = new LngLat(-50, -30);
+            expect(transform.center).toEqual(new LngLat(180, -0.0063583052861417855));
+
+            transform.zoom = 10;
+            transform.center = new LngLat(-50, -30);
+            expect(transform.center).toEqual(new LngLat(-175.171661376953125, -4.828969771321582));
+
+            transform.center = new LngLat(230, 0);
+            expect(transform.center).toEqual(new LngLat(-175.171661376953125, 0));
+
+            transform.center = new LngLat(130, 0);
+            expect(transform.center).toEqual(new LngLat(175.171661376953125, 0));
+        }
+    });
+
+    describe('coveringTiles', () => {
+        const options = {
+            minzoom: 1,
+            maxzoom: 10,
+            tileSize: 512
+        };
+
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(200, 200);
+
+        test('general', () => {
+
+            // make slightly off center so that sort order is not subject to precision issues
+            transform.center = new LngLat(-0.01, 0.01);
+
+            transform.zoom = 0;
+            expect(transform.coveringTiles(options)).toEqual([]);
+
+            transform.zoom = 1;
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(1, 0, 1, 0, 0),
+                new OverscaledTileID(1, 0, 1, 1, 0),
+                new OverscaledTileID(1, 0, 1, 0, 1),
+                new OverscaledTileID(1, 0, 1, 1, 1)]);
+
+            transform.zoom = 2.4;
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(2, 0, 2, 1, 1),
+                new OverscaledTileID(2, 0, 2, 2, 1),
+                new OverscaledTileID(2, 0, 2, 1, 2),
+                new OverscaledTileID(2, 0, 2, 2, 2)]);
+
+            transform.zoom = 10;
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(10, 0, 10, 511, 511),
+                new OverscaledTileID(10, 0, 10, 512, 511),
+                new OverscaledTileID(10, 0, 10, 511, 512),
+                new OverscaledTileID(10, 0, 10, 512, 512)]);
+
+            transform.zoom = 11;
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(10, 0, 10, 511, 511),
+                new OverscaledTileID(10, 0, 10, 512, 511),
+                new OverscaledTileID(10, 0, 10, 511, 512),
+                new OverscaledTileID(10, 0, 10, 512, 512)]);
+
+            transform.zoom = 5.1;
+            transform.pitch = 60.0;
+            transform.bearing = 32.0;
+            transform.center = new LngLat(56.90, 48.20);
+            transform.resize(1024, 768);
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(5, 0, 5, 21, 11),
+                new OverscaledTileID(5, 0, 5, 20, 11),
+                new OverscaledTileID(5, 0, 5, 21, 10),
+                new OverscaledTileID(5, 0, 5, 20, 10),
+                new OverscaledTileID(5, 0, 5, 21, 12),
+                new OverscaledTileID(5, 0, 5, 22, 11),
+                new OverscaledTileID(5, 0, 5, 20, 12),
+                new OverscaledTileID(5, 0, 5, 22, 10),
+                new OverscaledTileID(5, 0, 5, 21, 9),
+                new OverscaledTileID(5, 0, 5, 20, 9),
+                new OverscaledTileID(5, 0, 5, 22, 9),
+                new OverscaledTileID(5, 0, 5, 23, 10),
+                new OverscaledTileID(5, 0, 5, 21, 8),
+                new OverscaledTileID(5, 0, 5, 20, 8),
+                new OverscaledTileID(5, 0, 5, 23, 9),
+                new OverscaledTileID(5, 0, 5, 22, 8),
+                new OverscaledTileID(5, 0, 5, 23, 8),
+                new OverscaledTileID(5, 0, 5, 21, 7),
+                new OverscaledTileID(5, 0, 5, 20, 7),
+                new OverscaledTileID(5, 0, 5, 24, 9),
+                new OverscaledTileID(5, 0, 5, 22, 7)
+            ]);
+
+            transform.zoom = 8;
+            transform.pitch = 60;
+            transform.bearing = 45.0;
+            transform.center = new LngLat(25.02, 60.15);
+            transform.resize(300, 50);
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(8, 0, 8, 145, 74),
+                new OverscaledTileID(8, 0, 8, 145, 73),
+                new OverscaledTileID(8, 0, 8, 146, 74)
+            ]);
+
+            transform.resize(50, 300);
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(8, 0, 8, 145, 74),
+                new OverscaledTileID(8, 0, 8, 145, 73),
+                new OverscaledTileID(8, 0, 8, 146, 74),
+                new OverscaledTileID(8, 0, 8, 146, 73)
+            ]);
+
+            transform.zoom = 2;
+            transform.pitch = 0;
+            transform.bearing = 0;
+            transform.resize(300, 300);
+        });
+
+        test('calculates tile coverage at w > 0', () => {
+            transform.center = new LngLat(630.01, 0.01);
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(2, 2, 2, 1, 1),
+                new OverscaledTileID(2, 2, 2, 1, 2),
+                new OverscaledTileID(2, 2, 2, 0, 1),
+                new OverscaledTileID(2, 2, 2, 0, 2)
+            ]);
+        });
+
+        test('calculates tile coverage at w = -1', () => {
+            transform.center = new LngLat(-360.01, 0.01);
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(2, -1, 2, 1, 1),
+                new OverscaledTileID(2, -1, 2, 1, 2),
+                new OverscaledTileID(2, -1, 2, 2, 1),
+                new OverscaledTileID(2, -1, 2, 2, 2)
+            ]);
+        });
+
+        test('calculates tile coverage across meridian', () => {
+            transform.zoom = 1;
+            transform.center = new LngLat(-180.01, 0.01);
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(1, 0, 1, 0, 0),
+                new OverscaledTileID(1, 0, 1, 0, 1),
+                new OverscaledTileID(1, -1, 1, 1, 0),
+                new OverscaledTileID(1, -1, 1, 1, 1)
+            ]);
+        });
+
+        test('only includes tiles for a single world, if renderWorldCopies is set to false', () => {
+            transform.zoom = 1;
+            transform.center = new LngLat(-180.01, 0.01);
+            transform.renderWorldCopies = false;
+            expect(transform.coveringTiles(options)).toEqual([
+                new OverscaledTileID(1, 0, 1, 0, 0),
+                new OverscaledTileID(1, 0, 1, 0, 1)
+            ]);
+        });
+
+    });
+
+    test('coveringZoomLevel', () => {
+        const options = {
+            minzoom: 1,
+            maxzoom: 10,
+            tileSize: 512,
+            roundZoom: false,
+        };
+
+        const transform = new Transform(0, 22, 0, 60, true);
+
+        transform.zoom = 0;
+        expect(transform.coveringZoomLevel(options)).toBe(0);
+
+        transform.zoom = 0.1;
+        expect(transform.coveringZoomLevel(options)).toBe(0);
+
+        transform.zoom = 1;
+        expect(transform.coveringZoomLevel(options)).toBe(1);
+
+        transform.zoom = 2.4;
+        expect(transform.coveringZoomLevel(options)).toBe(2);
+
+        transform.zoom = 10;
+        expect(transform.coveringZoomLevel(options)).toBe(10);
+
+        transform.zoom = 11;
+        expect(transform.coveringZoomLevel(options)).toBe(11);
+
+        transform.zoom = 11.5;
+        expect(transform.coveringZoomLevel(options)).toBe(11);
+
+        options.tileSize = 256;
+
+        transform.zoom = 0;
+        expect(transform.coveringZoomLevel(options)).toBe(1);
+
+        transform.zoom = 0.1;
+        expect(transform.coveringZoomLevel(options)).toBe(1);
+
+        transform.zoom = 1;
+        expect(transform.coveringZoomLevel(options)).toBe(2);
+
+        transform.zoom = 2.4;
+        expect(transform.coveringZoomLevel(options)).toBe(3);
+
+        transform.zoom = 10;
+        expect(transform.coveringZoomLevel(options)).toBe(11);
+
+        transform.zoom = 11;
+        expect(transform.coveringZoomLevel(options)).toBe(12);
+
+        transform.zoom = 11.5;
+        expect(transform.coveringZoomLevel(options)).toBe(12);
+
+        options.roundZoom = true;
+
+        expect(transform.coveringZoomLevel(options)).toBe(13);
+    });
+
+    test('clamps latitude', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+
+        expect(transform.project(new LngLat(0, -90))).toEqual(transform.project(new LngLat(0, -MAX_VALID_LATITUDE)));
+        expect(transform.project(new LngLat(0, 90))).toEqual(transform.project(new LngLat(0, MAX_VALID_LATITUDE)));
+    });
+
+    test('clamps pitch', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+
+        transform.pitch = 45;
+        expect(transform.pitch).toBe(45);
+
+        transform.pitch = -10;
+        expect(transform.pitch).toBe(0);
+
+        transform.pitch = 90;
+        expect(transform.pitch).toBe(60);
+    });
+
+    test('visibleUnwrappedCoordinates', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(200, 200);
+        transform.zoom = 0;
+        transform.center = new LngLat(-170.01, 0.01);
+
+        let unwrappedCoords = transform.getVisibleUnwrappedCoordinates(new CanonicalTileID(0, 0, 0));
+        expect(unwrappedCoords).toHaveLength(4);
+
+        //getVisibleUnwrappedCoordinates should honor _renderWorldCopies
+        transform._renderWorldCopies = false;
+        unwrappedCoords = transform.getVisibleUnwrappedCoordinates(new CanonicalTileID(0, 0, 0));
+        expect(unwrappedCoords).toHaveLength(1);
+    });
+
+    test('maintains high float precision when calculating matrices', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(200.25, 200.25);
+        transform.zoom = 20.25;
+        transform.pitch = 67.25;
+        transform.center = new LngLat(0.0, 0.0);
+        transform._calcMatrices();
+
+        expect(transform.customLayerMatrix()[0].toString().length).toBeGreaterThan(10);
+        expect(transform.glCoordMatrix[0].toString().length).toBeGreaterThan(10);
+        expect(transform.maxPitchScaleFactor()).toBeCloseTo(2.366025418080343, 5);
+    });
+
+    test('recalculateZoom', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.elevation = 200;
+        transform.center = new LngLat(10.0, 50.0);
+        transform.zoom = 14;
+        transform.pitch = 45;
+        transform.resize(512, 512);
+
+        // This should be an invariant throughout - the zoom is greater when the camera is
+        // closer to the terrain (and therefore also when the terrain is closer to the camera),
+        // but that shouldn't change the camera's position in world space if that wasn't requested.
+        const expectedAltitude = 1865.7579397718;
+        expect(transform.getCameraPosition().altitude).toBeCloseTo(expectedAltitude, 10);
+
+        // expect same values because of no elevation change
+        const terrain = {
+            getElevationForLngLatZoom: () => 200,
+            pointCoordinate: () => null
+        };
+        transform.recalculateZoom(terrain as any);
+        expect(transform.getCameraPosition().altitude).toBeCloseTo(expectedAltitude, 10);
+        expect(transform.zoom).toBe(14);
+
+        // expect new zoom because of elevation change
+        terrain.getElevationForLngLatZoom = () => 400;
+        transform.recalculateZoom(terrain as any);
+        expect(transform.elevation).toBe(400);
+        expect(transform._center.lng).toBeCloseTo(10, 10);
+        expect(transform._center.lat).toBeCloseTo(50, 10);
+        expect(transform.getCameraPosition().altitude).toBeCloseTo(expectedAltitude, 10);
+        expect(transform.zoom).toBeCloseTo(14.1845318986, 10);
+
+        // expect new zoom because of elevation change to point below sea level
+        terrain.getElevationForLngLatZoom = () => -200;
+        transform.recalculateZoom(terrain as any);
+        expect(transform.elevation).toBe(-200);
+        expect(transform.getCameraPosition().altitude).toBeCloseTo(expectedAltitude, 10);
+        expect(transform.zoom).toBeCloseTo(13.6895075574, 10);
+    });
+
+    test('pointCoordinate with terrain when returning null should fall back to 2D', () => {
+        const transform = new Transform(0, 22, 0, 60, true);
+        transform.resize(500, 500);
+        const terrain = {
+            pointCoordinate: () => null
+        } as any as Terrain;
+        const coordinate = transform.pointCoordinate(new Point(0, 0), terrain);
+
+        expect(coordinate).toBeDefined();
+    });
+
+    test('horizon', () => {
+        const transform = new Transform(0, 22, 0, 85, true);
+        transform.resize(500, 500);
+        transform.pitch = 75;
+        const horizon = transform.getHorizon();
+
+        expect(horizon).toBeCloseTo(170.8176101748407, 10);
+    });
+
+    test('getBounds with horizon', () => {
+        const transform = new Transform(0, 22, 0, 85, true);
+        transform.resize(500, 500);
+
+        transform.pitch = 60;
+        expect(transform.getBounds().getNorthWest().toArray()).toStrictEqual(transform.pointLocation(new Point(0, 0)).toArray());
+
+        transform.pitch = 75;
+        const top = Math.max(0, transform.height / 2 - transform.getHorizon());
+        expect(top).toBeCloseTo(79.1823898251593, 10);
+        expect(transform.getBounds().getNorthWest().toArray()).toStrictEqual(transform.pointLocation(new Point(0, top)).toArray());
+    });
+
+    test('lngLatToCameraDepth', () => {
+        const transform = new Transform(0, 22, 0, 85, true);
+        transform.resize(500, 500);
+        transform.center = new LngLat(10.0, 50.0);
+
+        expect(transform.lngLatToCameraDepth(new LngLat(10, 50), 4)).toBeCloseTo(0.9997324396231673);
+        transform.pitch = 60;
+        expect(transform.lngLatToCameraDepth(new LngLat(10, 50), 4)).toBeCloseTo(0.9865782165762236);
+
+    });
+});