@swissgeo/coordinates 1.0.0-beta.2 → 1.0.0

package/src/proj/WebMercatorCoordinateSystem.ts

@@ -0,0 +1,89 @@
+import { round } from '@swissgeo/numbers'
+import proj4 from 'proj4'
+
+import type { SingleCoordinate } from '@/coordinatesUtils'
+
+import { WGS84 } from '@/proj'
+import { PIXEL_LENGTH_IN_KM_AT_ZOOM_ZERO_WITH_256PX_TILES } from '@/proj/CoordinateSystem'
+import CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+import StandardCoordinateSystem from '@/proj/StandardCoordinateSystem'
+
+export default class WebMercatorCoordinateSystem extends StandardCoordinateSystem {
+    constructor() {
+        super({
+            epsgNumber: 3857,
+            label: 'WebMercator',
+            // matrix comes from https://epsg.io/3857.proj4
+            proj4transformationMatrix:
+                '+proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs +type=proj',
+            // bounds are coming from https://github.com/geoadmin/lib-gatilegrid/blob/58d6e574b69d32740a24edbc086d97897d4b41dc/gatilegrid/tilegrids.py#L122-L125
+            bounds: new CoordinateSystemBounds({
+                lowerX: -20037508.342789244,
+                upperX: 20037508.342789244,
+                lowerY: -20037508.342789244,
+                upperY: 20037508.342789244,
+                // center of LV95's extent transformed with epsg.io website
+                customCenter: [917209.87, 5914737.43],
+            }),
+            usesMercatorPyramid: true,
+        })
+    }
+
+    roundCoordinateValue(value: number): number {
+        return round(value, 2)
+    }
+
+    /**
+     * Formula comes from
+     * https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Resolution_and_Scale
+     *
+     *          resolution = 156543.03 meters / pixel * cos(latitude) / (2 ^ zoom level)
+     */
+    getResolutionForZoomAndCenter(zoom: number, center: SingleCoordinate): number {
+        const centerInRad = proj4(this.epsg, WGS84.epsg, center).map(
+            (coordinate) => (coordinate * Math.PI) / 180.0
+        )
+        if (typeof centerInRad[1] !== 'number') {
+            return 0
+        }
+        return round(
+            Math.abs(
+                (PIXEL_LENGTH_IN_KM_AT_ZOOM_ZERO_WITH_256PX_TILES * Math.cos(centerInRad[1])) /
+                    Math.pow(2, zoom)
+            ),
+            2
+        )
+    }
+
+    /**
+     * Calculating zoom level by reversing formula from
+     * https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Resolution_and_Scale :
+     *
+     *          resolution = 156543.03 * cos(latitude) / (2 ^ zoom level)
+     *
+     * So that
+     *
+     *          zoom level = log2( resolution / 156543.03 / cos(latitude) )
+     *
+     * @param resolution Resolution in meter/pixel
+     * @param center As the use an equatorial constant to calculate the zoom level, we need to know
+     *   the latitude of the position the resolution must be calculated at, as we need to take into
+     *   account the deformation of the WebMercator projection (that is greater the further north we
+     *   are)
+     */
+    getZoomForResolutionAndCenter(resolution: number, center: SingleCoordinate): number {
+        const centerInRad = proj4(this.epsg, WGS84.epsg, center).map(
+            (coordinate) => (coordinate * Math.PI) / 180.0
+        )
+        if (typeof centerInRad[1] !== 'number') {
+            return 0
+        }
+        return Math.abs(
+            Math.log2(
+                resolution /
+                    PIXEL_LENGTH_IN_KM_AT_ZOOM_ZERO_WITH_256PX_TILES /
+                    Math.cos(centerInRad[1])
+            )
+        )
+    }
+}

package/src/proj/__test__/CoordinateSystem.spec.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+
+import { LV95, WEBMERCATOR, WGS84 } from '@/proj'
+import CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+import StandardCoordinateSystem from '@/proj/StandardCoordinateSystem'
+
+class BoundlessCoordinateSystem extends StandardCoordinateSystem {
+    constructor() {
+        super({
+            usesMercatorPyramid: false,
+            proj4transformationMatrix: 'test',
+            label: 'test',
+            epsgNumber: 1234,
+        })
+    }
+    getResolutionForZoomAndCenter(): number {
+        return 0
+    }
+
+    getZoomForResolutionAndCenter(): number {
+        return 0
+    }
+
+    roundCoordinateValue(): number {
+        return 0
+    }
+}
+
+describe('CoordinateSystem', () => {
+    const coordinateSystemWithouBounds = new BoundlessCoordinateSystem()
+    describe('getBoundsAs', () => {
+        it('returns undefined if the bounds are not defined', () => {
+            expect(coordinateSystemWithouBounds.getBoundsAs(WEBMERCATOR)).to.be.undefined
+        })
+        it('transforms LV95 into WebMercator correctly', () => {
+            const result = LV95.getBoundsAs(WEBMERCATOR)
+            expect(result).to.be.an.instanceOf(CoordinateSystemBounds)
+            // numbers are coming from epsg.io's transform tool
+            const acceptableDelta = 0.01
+            expect(result!.lowerX).to.approximately(572215.44, acceptableDelta)
+            expect(result!.lowerY).to.approximately(5684416.96, acceptableDelta)
+            expect(result!.upperX).to.approximately(1277662.36, acceptableDelta)
+            expect(result!.upperY).to.approximately(6145307.39, acceptableDelta)
+        })
+        it('transforms LV95 into WGS84 correctly', () => {
+            const result = LV95.getBoundsAs(WGS84)
+            expect(result).to.be.an.instanceOf(CoordinateSystemBounds)
+            // numbers are coming from epsg.io's transform tool
+            const acceptableDelta = 0.0001
+            expect(result!.lowerX).to.approximately(5.14029, acceptableDelta)
+            expect(result!.lowerY).to.approximately(45.39812, acceptableDelta)
+            expect(result!.upperX).to.approximately(11.47744, acceptableDelta)
+            expect(result!.upperY).to.approximately(48.23062, acceptableDelta)
+        })
+    })
+    describe('isInBound', () => {
+        it('returns false if no bounds are defined', () => {
+            expect(coordinateSystemWithouBounds.isInBounds(0, 0)).to.be.false
+            expect(coordinateSystemWithouBounds.isInBounds(1, 1)).to.be.false
+        })
+        // the remaining tests for this function are handled in the CoordinateSystemBounds.spec.ts file
+    })
+})

package/src/proj/__test__/CoordinateSystemBounds.spec.ts

@@ -0,0 +1,252 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import type { SingleCoordinate } from '@/coordinatesUtils'
+
+import { LV95 } from '@/proj'
+import CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+
+describe('CoordinateSystemBounds', () => {
+    describe('splitIfOutOfBounds(coordinates, bounds)', () => {
+        let bounds: CoordinateSystemBounds
+
+        beforeEach(() => {
+            bounds = new CoordinateSystemBounds({ lowerX: 0, upperX: 100, lowerY: 50, upperY: 100 })
+        })
+
+        it('returns a single CoordinatesChunk if no split is needed', () => {
+            const coordinatesWithinBounds: SingleCoordinate[] = [
+                [bounds.lowerX + 1, bounds.upperY - 1],
+                [bounds.lowerX + 2, bounds.upperY - 2],
+                [bounds.lowerX + 3, bounds.upperY - 3],
+                [bounds.lowerX + 4, bounds.upperY - 4],
+                [bounds.lowerX + 5, bounds.upperY - 5],
+                [bounds.lowerX + 6, bounds.upperY - 6],
+                [bounds.lowerX + 7, bounds.upperY - 7],
+            ]
+            const result = bounds.splitIfOutOfBounds(coordinatesWithinBounds)
+            expect(result).to.be.an('Array').of.length(1)
+            const [singleChunk] = result!
+            expect(singleChunk).to.be.an('Object').that.has.ownProperty('coordinates')
+            expect(singleChunk).to.haveOwnProperty('isWithinBounds')
+            expect(singleChunk!.isWithinBounds).to.be.true
+            expect(singleChunk!.coordinates).to.eql(coordinatesWithinBounds)
+        })
+        it('splits the given coordinates in two chunks if part of it is outside bounds', () => {
+            const yValue = 50
+            const coordinatesOverlappingBounds: SingleCoordinate[] = [
+                // starting by adding coordinates out of bounds
+                [bounds.lowerX - 1, yValue],
+                // split should occur here as we start to be in bounds
+                [bounds.lowerX + 1, yValue],
+                [50, yValue],
+                [bounds.upperX - 1, yValue],
+            ]
+            const result = bounds.splitIfOutOfBounds(coordinatesOverlappingBounds)
+            expect(result).to.be.an('Array').of.length(2)
+            const [outOfBoundChunk, inBoundChunk] = result!
+            expect(outOfBoundChunk).to.haveOwnProperty('isWithinBounds')
+            expect(outOfBoundChunk!.isWithinBounds).to.be.false
+            expect(outOfBoundChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(outOfBoundChunk!.coordinates[0]).to.eql(coordinatesOverlappingBounds[0])
+            // checking that the split happened on the bounds
+            const intersectingCoordinate = outOfBoundChunk!.coordinates[1]
+            expect(intersectingCoordinate).to.be.an('Array').of.length(2)
+            expect(intersectingCoordinate).to.eql([bounds.lowerX, yValue])
+            // next chunk must start by the intersecting coordinate
+            expect(inBoundChunk).to.haveOwnProperty('isWithinBounds')
+            expect(inBoundChunk!.isWithinBounds).to.be.true
+            expect(inBoundChunk!.coordinates).to.be.an('Array').of.length(4)
+            const [firstInBoundCoordinate] = inBoundChunk!.coordinates
+            expect(firstInBoundCoordinate).to.be.an('Array').of.length(2)
+            expect(firstInBoundCoordinate).to.eql([bounds.lowerX, yValue])
+            // checking that further coordinates have been correctly copied
+            coordinatesOverlappingBounds.slice(1).forEach((coordinate, index) => {
+                expect(inBoundChunk!.coordinates[index + 1]![0]).to.eq(coordinate[0])
+                expect(inBoundChunk!.coordinates[index + 1]![1]).to.eq(coordinate[1])
+            })
+        })
+        it('gives similar results if coordinates are given in the reverse order', () => {
+            const yValue = 50
+            // same test data as previous test, but reversed
+            const coordinatesOverlappingBounds: SingleCoordinate[] = [
+                [bounds.lowerX - 1, yValue] as SingleCoordinate,
+                [bounds.lowerX + 1, yValue] as SingleCoordinate,
+                [50, yValue] as SingleCoordinate,
+                [bounds.upperX - 1, yValue] as SingleCoordinate,
+            ].toReversed()
+            const result = bounds.splitIfOutOfBounds(coordinatesOverlappingBounds)
+            expect(result).to.be.an('Array').of.length(2)
+            const [inBoundChunk, outOfBoundChunk] = result!
+
+            // first chunk must now be the in bound one
+            expect(inBoundChunk).to.haveOwnProperty('isWithinBounds')
+            expect(inBoundChunk!.isWithinBounds).to.be.true
+            expect(inBoundChunk!.coordinates).to.be.an('Array').of.length(4)
+            const lastInBoundCoordinate = inBoundChunk!.coordinates.splice(-1)[0]
+            expect(lastInBoundCoordinate).to.be.an('Array').of.length(2)
+            expect(lastInBoundCoordinate).to.eql([bounds.lowerX, yValue])
+
+            expect(outOfBoundChunk).to.haveOwnProperty('isWithinBounds')
+            expect(outOfBoundChunk!.isWithinBounds).to.be.false
+            expect(outOfBoundChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(outOfBoundChunk!.coordinates[0]).to.eql([bounds.lowerX, yValue])
+        })
+        it('handles properly a line going multiple times out of bounds', () => {
+            const coordinatesGoingBackAndForth: SingleCoordinate[] = [
+                [-1, 51], // outside
+                [1, 51], // inside going in the X direction
+                [1, 101], // outside going in the Y direction
+                [101, 101], // outside
+                [99, 99], // inside going both directions
+                [1, 51], // inside moving on the other side of the bounds
+            ]
+            const expectedFirstIntersection: SingleCoordinate = [bounds.lowerX, 51]
+            const expectedSecondIntersection: SingleCoordinate = [1, bounds.upperY]
+            const expectedThirdIntersection: SingleCoordinate = [bounds.upperX, bounds.upperY]
+
+            const result = bounds.splitIfOutOfBounds(coordinatesGoingBackAndForth)
+            expect(result).to.be.an('Array').of.length(4)
+            const [firstChunk, secondChunk, thirdChunk, fourthChunk] = result!
+            // first chunk should have two coordinates, the first from the list and the first intersection
+            expect(firstChunk!.isWithinBounds).to.be.false
+            expect(firstChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(firstChunk!.coordinates[0]).to.eql(coordinatesGoingBackAndForth[0])
+            expect(firstChunk!.coordinates[1]).to.eql(expectedFirstIntersection)
+            // second chunk should start with the first intersection, then include the second coord
+            // and finish with the second intersection
+            expect(secondChunk!.coordinates).to.be.an('Array').of.length(3)
+            expect(secondChunk!.isWithinBounds).to.be.true
+            expect(secondChunk!.coordinates[0]).to.eql(expectedFirstIntersection)
+            expect(secondChunk!.coordinates[1]).to.eql(coordinatesGoingBackAndForth[1])
+            expect(secondChunk!.coordinates[2]).to.eql(expectedSecondIntersection)
+            // third chunk should be : intersection2, coord3, coord4, intersection3
+            expect(thirdChunk!.coordinates).to.be.an('Array').of.length(4)
+            expect(thirdChunk!.isWithinBounds).to.be.false
+            expect(thirdChunk!.coordinates[0]).to.eql(expectedSecondIntersection)
+            expect(thirdChunk!.coordinates[1]).to.eql(coordinatesGoingBackAndForth[2])
+            expect(thirdChunk!.coordinates[2]).to.eql(coordinatesGoingBackAndForth[3])
+            expect(thirdChunk!.coordinates[3]).to.eql(expectedThirdIntersection)
+            // last chunk should be : intersection3, coord5, coord6
+            expect(fourthChunk!.coordinates).to.be.an('Array').of.length(3)
+            expect(fourthChunk!.isWithinBounds).to.be.true
+            expect(fourthChunk!.coordinates[0]).to.eql(expectedThirdIntersection)
+            expect(fourthChunk!.coordinates[1]).to.eql(coordinatesGoingBackAndForth[4])
+            expect(fourthChunk!.coordinates[2]).to.eql(coordinatesGoingBackAndForth[5])
+        })
+        it('splits correctly a line crossing bounds two times in a straight line (no stop inside)', () => {
+            const coordinatesGoingThrough: SingleCoordinate[] = [
+                [-1, 50], // outside
+                [101, 50], // outside
+            ]
+            const expectedFirstIntersection: SingleCoordinate = [bounds.lowerX, 50]
+            const expectedSecondIntersection: SingleCoordinate = [bounds.upperX, 50]
+
+            const result = bounds.splitIfOutOfBounds(coordinatesGoingThrough)
+            expect(result).to.be.an('Array').of.length(3)
+            const [firstChunk, secondChunk, thirdChunk] = result!
+
+            expect(firstChunk!.isWithinBounds).to.be.false
+            expect(firstChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(firstChunk!.coordinates[0]).to.eql(coordinatesGoingThrough[0])
+            expect(firstChunk!.coordinates[1]).to.eql(expectedFirstIntersection)
+
+            expect(secondChunk!.isWithinBounds).to.be.true
+            expect(secondChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(secondChunk!.coordinates[0]).to.eql(expectedFirstIntersection)
+            expect(secondChunk!.coordinates[1]).to.eql(expectedSecondIntersection)
+
+            expect(thirdChunk!.isWithinBounds).to.be.false
+            expect(thirdChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(thirdChunk!.coordinates[0]).to.eql(expectedSecondIntersection)
+            expect(thirdChunk!.coordinates[1]).to.eql(coordinatesGoingThrough[1])
+        })
+        it('handles some "real" use case well', () => {
+            const sample1: SingleCoordinate[] = [
+                [2651000, 1392000],
+                [2932500, 894500],
+            ]
+            const result = LV95.bounds.splitIfOutOfBounds(sample1)
+            expect(result).to.be.an('Array').of.length(3)
+            const [firstChunk, secondChunk, thirdChunk] = result!
+
+            expect(firstChunk!.isWithinBounds).to.be.false
+            expect(firstChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(firstChunk!.coordinates[0]).to.eql(sample1[0])
+            expect(firstChunk!.coordinates[1]![0]).to.approximately(2674764.8, 0.1)
+            expect(firstChunk!.coordinates[1]![1]).to.approximately(1350000, 0.1)
+
+            expect(secondChunk!.isWithinBounds).to.be.true
+            expect(secondChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(secondChunk!.coordinates[0]![0]).to.approximately(2674764.8, 0.1)
+            expect(secondChunk!.coordinates[0]![1]).to.approximately(1350000, 0.1)
+            expect(secondChunk!.coordinates[1]![0]).to.approximately(2855830.1, 0.1)
+            expect(secondChunk!.coordinates[1]![1]).to.approximately(1030000, 0.1)
+
+            expect(thirdChunk!.isWithinBounds).to.be.false
+            expect(thirdChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(thirdChunk!.coordinates[0]![0]).to.approximately(2855830.1, 0.1)
+            expect(thirdChunk!.coordinates[0]![1]).to.approximately(1030000, 0.1)
+            expect(thirdChunk!.coordinates[1]).to.eql(sample1[1])
+
+            const reversedResult = LV95.bounds.splitIfOutOfBounds(sample1.toReversed())
+            expect(reversedResult).to.be.an('Array').of.length(3)
+            const [firstReversedChunk, secondReversedChunk, thirdReversedChunk] = reversedResult!
+
+            expect(firstReversedChunk!.isWithinBounds).to.be.false
+            expect(firstReversedChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(firstReversedChunk!.coordinates[0]).to.eql(sample1[1])
+            expect(firstReversedChunk!.coordinates[1]![0]).to.approximately(2855830.1, 0.1)
+            expect(firstReversedChunk!.coordinates[1]![1]).to.approximately(1030000, 0.1)
+
+            expect(secondReversedChunk!.isWithinBounds).to.be.true
+            expect(secondReversedChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(secondReversedChunk!.coordinates[0]![0]).to.approximately(2855830.1, 0.1)
+            expect(secondReversedChunk!.coordinates[0]![1]).to.approximately(1030000, 0.1)
+            expect(secondReversedChunk!.coordinates[1]![0]).to.approximately(2674764.8, 0.1)
+            expect(secondReversedChunk!.coordinates[1]![1]).to.approximately(1350000, 0.1)
+
+            expect(thirdReversedChunk!.isWithinBounds).to.be.false
+            expect(thirdReversedChunk!.coordinates).to.be.an('Array').of.length(2)
+            expect(thirdReversedChunk!.coordinates[0]![0]).to.approximately(2674764.8, 0.1)
+            expect(thirdReversedChunk!.coordinates[0]![1]).to.approximately(1350000, 0.1)
+            expect(thirdReversedChunk!.coordinates[1]).to.eql(sample1[0])
+        })
+    })
+    describe('isInBounds(x, y)', () => {
+        const testInstance = new CoordinateSystemBounds({
+            lowerX: -1,
+            upperX: 1,
+            lowerY: -1,
+            upperY: 1,
+        })
+        it('returns true if we are on the border of the bounds', () => {
+            expect(testInstance.isInBounds(-1, -1)).to.be.true
+            expect(testInstance.isInBounds(-1, 1)).to.be.true
+            expect(testInstance.isInBounds(1, -1)).to.be.true
+            expect(testInstance.isInBounds(1, 1)).to.be.true
+        })
+        it('returns true if we are in bounds not touching any border', () => {
+            expect(testInstance.isInBounds(0, 0)).to.be.true
+        })
+        it('returns false if only one parameter (X or Y) is out of bound', () => {
+            expect(testInstance.isInBounds(-1, -2)).to.be.false
+            expect(testInstance.isInBounds(-2, -1)).to.be.false
+            expect(testInstance.isInBounds(-1, 2)).to.be.false
+            expect(testInstance.isInBounds(2, -1)).to.be.false
+            expect(testInstance.isInBounds(1, -2)).to.be.false
+            expect(testInstance.isInBounds(-2, 1)).to.be.false
+            expect(testInstance.isInBounds(1, 2)).to.be.false
+            expect(testInstance.isInBounds(2, 1)).to.be.false
+        })
+    })
+    describe('flatten', () => {
+        const lowerX = 123
+        const upperX = 456
+        const lowerY = 345
+        const upperY = 678
+        const testInstance = new CoordinateSystemBounds({ lowerX, upperX, lowerY, upperY })
+        it('produces a flatten array correctly', () => {
+            expect(testInstance.flatten).to.eql([lowerX, lowerY, upperX, upperY])
+        })
+    })
+})

package/src/proj/__test__/SwissCoordinateSystem.spec.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest'
+
+import { LV03, LV95 } from '@/proj'
+import {
+    LV95_RESOLUTIONS,
+    SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX,
+} from '@/proj/SwissCoordinateSystem'
+
+describe('Unit test functions from SwissCoordinateSystem', () => {
+    describe('transformCustomZoomLevelToStandard', () => {
+        it('transforms rounded value correctly', () => {
+            // most zoom levels on mf-geoadmin3 were forced as integer, so we have to make sure we translate them correctly
+            // there is 14 zoom levels described in mf-geoadmin3
+            for (let swisstopoZoom = 0; swisstopoZoom <= 14; swisstopoZoom++) {
+                expect(LV95.transformCustomZoomLevelToStandard(swisstopoZoom)).to.eq(
+                    SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[swisstopoZoom]
+                )
+                expect(LV03.transformCustomZoomLevelToStandard(swisstopoZoom)).to.eq(
+                    SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[swisstopoZoom]
+                )
+            }
+        })
+        it('floors any floating swisstopo zoom given before searching for the equivalent', () => {
+            for (let swisstopoZoom = 0; swisstopoZoom <= 14; swisstopoZoom++) {
+                for (let above = swisstopoZoom; above < swisstopoZoom + 1; above += 0.1) {
+                    expect(LV95.transformCustomZoomLevelToStandard(above)).to.eq(
+                        SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[swisstopoZoom]
+                    )
+                    expect(LV03.transformCustomZoomLevelToStandard(above)).to.eq(
+                        SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[swisstopoZoom]
+                    )
+                }
+            }
+        })
+    })
+    describe('transformStandardZoomLevelToCustom', () => {
+        it('transforms exact value correctly', () => {
+            SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX.forEach(
+                (mercatorZoom, swisstopoZoom) => {
+                    expect(LV95.transformStandardZoomLevelToCustom(mercatorZoom)).to.eq(
+                        swisstopoZoom
+                    )
+                    expect(LV03.transformStandardZoomLevelToCustom(mercatorZoom)).to.eq(
+                        swisstopoZoom
+                    )
+                }
+            )
+        })
+        it('finds the closest swisstopo zoom from the mercator zoom given', () => {
+            const acceptableDeltaInMercatorZoomLevel = 0.15
+            // generating ranges of mercator zoom that matches the steps of the matrix
+            const rangeOfMercatorZoomToTest = SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX.map(
+                (mercatorZoom, lv95Zoom) => {
+                    if (lv95Zoom === 0) {
+                        return {
+                            start: 0,
+                            end:
+                                SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[0]! -
+                                acceptableDeltaInMercatorZoomLevel,
+                            expected: 0,
+                        }
+                    }
+                    if (lv95Zoom >= 14) {
+                        return {
+                            start: 21,
+                            end: 30,
+                            expected: lv95Zoom,
+                        }
+                    }
+                    const nextZoomLevel =
+                        SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[lv95Zoom + 1]!
+                    return {
+                        start: mercatorZoom + acceptableDeltaInMercatorZoomLevel,
+                        end: nextZoomLevel,
+                        expected: lv95Zoom + 1,
+                    }
+                }
+            )
+            rangeOfMercatorZoomToTest.forEach((range) => {
+                for (
+                    let zoomLevel = range.start;
+                    zoomLevel <= range.end;
+                    zoomLevel += acceptableDeltaInMercatorZoomLevel
+                ) {
+                    expect(LV95.transformStandardZoomLevelToCustom(zoomLevel)).to.eq(
+                        range.expected,
+                        `Mercator zoom ${zoomLevel} was not translated to LV95 correctly`
+                    )
+                    expect(LV03.transformStandardZoomLevelToCustom(zoomLevel)).to.eq(
+                        range.expected,
+                        `Mercator zoom ${zoomLevel} was not translated to LV03 correctly`
+                    )
+                }
+            })
+        })
+    })
+    describe('getZoomForResolutionAndY', () => {
+        it('returns zoom=0 if the resolution is too great', () => {
+            expect(LV95.getZoomForResolutionAndCenter(LV95_RESOLUTIONS[0]! + 1)).to.eq(0)
+            expect(LV03.getZoomForResolutionAndCenter(LV95_RESOLUTIONS[0]! + 1)).to.eq(0)
+        })
+        it('returns zoom correctly while resolution is exactly on a threshold', () => {
+            for (let i = 0; i < LV95_RESOLUTIONS.length - 1; i++) {
+                expect(LV95.getZoomForResolutionAndCenter(LV95_RESOLUTIONS[i]!)).to.eq(i)
+                expect(LV03.getZoomForResolutionAndCenter(LV95_RESOLUTIONS[i]!)).to.eq(i)
+            }
+        })
+        it('returns zoom correctly while resolution is in between the two thresholds', () => {
+            for (let i = 0; i < LV95_RESOLUTIONS.length - 2; i++) {
+                for (
+                    let resolution = LV95_RESOLUTIONS[i]! - 1;
+                    resolution > LV95_RESOLUTIONS[i + 1]!;
+                    resolution--
+                ) {
+                    expect(LV95.getZoomForResolutionAndCenter(resolution)).to.eq(
+                        i + 1,
+                        `resolution ${resolution} was misinterpreted`
+                    )
+                    expect(LV03.getZoomForResolutionAndCenter(resolution)).to.eq(
+                        i + 1,
+                        `resolution ${resolution} was misinterpreted`
+                    )
+                }
+            }
+        })
+        it('returns the max zoom available, event if the resolution is smaller than expected', () => {
+            const smallestResolution = LV95_RESOLUTIONS[LV95_RESOLUTIONS.length - 1]!
+            expect(LV95.getZoomForResolutionAndCenter(smallestResolution - 0.1)).to.eq(
+                LV95_RESOLUTIONS.indexOf(smallestResolution)
+            )
+            expect(LV03.getZoomForResolutionAndCenter(smallestResolution - 0.1)).to.eq(
+                LV95_RESOLUTIONS.indexOf(smallestResolution)
+            )
+        })
+    })
+})

package/src/proj/index.ts

@@ -0,0 +1,65 @@
+import CoordinateSystem, {
+    STANDARD_ZOOM_LEVEL_1_25000_MAP,
+    SWISS_ZOOM_LEVEL_1_25000_MAP,
+} from '@/proj/CoordinateSystem'
+import CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+import CustomCoordinateSystem from '@/proj/CustomCoordinateSystem'
+import LV03CoordinateSystem from '@/proj/LV03CoordinateSystem'
+import LV95CoordinateSystem from '@/proj/LV95CoordinateSystem'
+import StandardCoordinateSystem from '@/proj/StandardCoordinateSystem'
+import SwissCoordinateSystem, {
+    LV95_RESOLUTIONS,
+    SWISSTOPO_TILEGRID_RESOLUTIONS,
+} from '@/proj/SwissCoordinateSystem'
+import WebMercatorCoordinateSystem from '@/proj/WebMercatorCoordinateSystem'
+import WGS84CoordinateSystem from '@/proj/WGS84CoordinateSystem'
+
+export const LV95: LV95CoordinateSystem = new LV95CoordinateSystem()
+export const LV03: LV03CoordinateSystem = new LV03CoordinateSystem()
+export const WGS84: WGS84CoordinateSystem = new WGS84CoordinateSystem()
+export const WEBMERCATOR: WebMercatorCoordinateSystem = new WebMercatorCoordinateSystem()
+
+export type * from '@/proj/types'
+
+/** Representation of many (available in this app) projection systems */
+export const allCoordinateSystems: CoordinateSystem[] = [LV95, LV03, WGS84, WEBMERCATOR]
+
+interface SwissGeoCoordinateConstants {
+    STANDARD_ZOOM_LEVEL_1_25000_MAP: number
+    SWISS_ZOOM_LEVEL_1_25000_MAP: number
+    LV95_RESOLUTIONS: number[]
+    SWISSTOPO_TILEGRID_RESOLUTIONS: number[]
+}
+
+const constants: SwissGeoCoordinateConstants = {
+    STANDARD_ZOOM_LEVEL_1_25000_MAP,
+    SWISS_ZOOM_LEVEL_1_25000_MAP,
+    LV95_RESOLUTIONS,
+    SWISSTOPO_TILEGRID_RESOLUTIONS,
+}
+
+export interface SwissGeoCoordinateCRS {
+    LV95: LV95CoordinateSystem
+    LV03: LV03CoordinateSystem
+    WGS84: WGS84CoordinateSystem
+    WEBMERCATOR: WebMercatorCoordinateSystem
+    allCoordinateSystems: CoordinateSystem[]
+}
+
+const crs: SwissGeoCoordinateCRS = {
+    LV95,
+    LV03,
+    WGS84,
+    WEBMERCATOR,
+    allCoordinateSystems,
+}
+export {
+    crs,
+    constants,
+    CoordinateSystem,
+    CoordinateSystemBounds,
+    CustomCoordinateSystem,
+    StandardCoordinateSystem,
+    SwissCoordinateSystem,
+}
+export default crs

package/src/proj/types.ts

@@ -0,0 +1,22 @@
+import type { SingleCoordinate } from '@/coordinatesUtils'
+
+/**
+ * Group of coordinates resulting in a "split by bounds" function. Will also contain information if
+ * this chunk is within or outside the bounds from which it was cut from.
+ */
+export interface CoordinatesChunk {
+    /** Coordinates of this chunk */
+    coordinates: SingleCoordinate[]
+    /** Will be true if this chunk contains coordinates that are located within bounds */
+    isWithinBounds: boolean
+}
+
+/** Representation of a resolution step in a coordinate system. Can be linked to a zoom level or not. */
+export interface ResolutionStep {
+    /** Resolution of this step, in meters/pixel */
+    resolution: number
+    /** Corresponding zoom level for this resolution step */
+    zoom?: number
+    /** Name of the map product shown at this resolution/zoom */
+    label?: string
+}

package/src/registerProj4.ts

@@ -0,0 +1,38 @@
+import type proj4 from 'proj4'
+
+import log from '@swissgeo/log'
+
+import type CoordinateSystem from '@/proj/CoordinateSystem'
+
+import { LV03, LV95, WEBMERCATOR } from '@/proj'
+
+/**
+ * Proj4 comes with [EPSG:4326]{@link https://epsg.io/4326} as default projection.
+ *
+ * By default, this adds the two Swiss projections ([LV95/EPSG:2056]{@link https://epsg.io/2056} and
+ * [LV03/EPSG:21781]{@link https://epsg.io/21781}) and metric Web Mercator
+ * ([EPSG:3857]{@link https://epsg.io/3857}) definitions to proj4
+ *
+ * Further projection can be added by settings the param projections (do not forget to include LV95,
+ * LV03 and/or WebMercator if you intended to use them too)
+ */
+const registerProj4 = (
+    proj4Instance: typeof proj4,
+    projections: CoordinateSystem[] = [WEBMERCATOR, LV95, LV03]
+): void => {
+    // adding projection defining a transformation matrix to proj4 (these projection matrices can be found on the epsg.io website)
+    projections
+        .filter((projection) => projection.proj4transformationMatrix)
+        .forEach((projection) => {
+            try {
+                proj4Instance.defs(projection.epsg, projection.proj4transformationMatrix)
+            } catch (err) {
+                const error = err ? (err as Error) : new Error('Unknown error')
+                log.error('Error while setting up projection in proj4', projection.epsg, error)
+                throw error
+            }
+        })
+}
+
+export { registerProj4 }
+export default registerProj4

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+    "extends": "@swissgeo/config-typescript/tsconfig.vue.json",
+    "include": ["**/*.ts", "**/*.vue"]
+}