@swissgeo/coordinates 1.0.0-rc.1 → 1.0.0

package/src/proj/CoordinateSystemBounds.ts

@@ -0,0 +1,170 @@
+import type { Coord } from '@turf/turf'
+import type { Feature, FeatureCollection, GeoJsonProperties, LineString } from 'geojson'
+
+import {
+    bboxPolygon,
+    booleanPointInPolygon,
+    distance,
+    lineSplit,
+    lineString,
+    points,
+} from '@turf/turf'
+import { sortBy } from 'lodash'
+
+import type { SingleCoordinate } from '@/coordinatesUtils'
+import type { CoordinatesChunk } from '@/proj/types'
+
+interface CoordinateSystemBoundsProps {
+    lowerX: number
+    upperX: number
+    lowerY: number
+    upperY: number
+    customCenter?: SingleCoordinate
+}
+
+/**
+ * Turf's lineSplit function doesn't ensure split path will be ordered in its output.
+ *
+ * This code aims to reorder the result of this function in the correct order. Comes from a GitHub
+ * issue (see link below)
+ *
+ * @see https://github.com/Turfjs/turf/issues/1989#issuecomment-753147919
+ */
+function reassembleLineSegments(
+    origin: Coord,
+    path: FeatureCollection<LineString, GeoJsonProperties>
+): Feature<LineString>[] {
+    let candidateFeatures = path.features
+    const orderedFeatures: Feature<LineString, GeoJsonProperties>[] = []
+    while (candidateFeatures.length > 0) {
+        candidateFeatures = sortBy(candidateFeatures, (f) => {
+            if (f.geometry && f.geometry.coordinates && f.geometry.coordinates[0]) {
+                return distance(origin, f.geometry.coordinates[0])
+            } else {
+                throw new Error('Feature missing geometry')
+            }
+        })
+        const closest = candidateFeatures.shift()!
+        const closestOrigin = closest.geometry.coordinates[closest.geometry.coordinates.length - 1]
+        if (closestOrigin) {
+            origin = closestOrigin
+        }
+        orderedFeatures.push(closest)
+    }
+    return orderedFeatures
+}
+
+/**
+ * Representation of boundaries of a coordinate system (also sometime called extent)
+ *
+ * It is expressed by the most bottom left points possible / top right point possible, meaning that
+ * a combination of these two gives us the area in which the coordinate system can produce valid
+ * coordinates
+ */
+export default class CoordinateSystemBounds {
+    public readonly lowerX: number
+    public readonly upperX: number
+    public readonly lowerY: number
+    public readonly upperY: number
+    public readonly customCenter?: SingleCoordinate
+
+    public readonly bottomLeft: SingleCoordinate
+    public readonly bottomRight: SingleCoordinate
+    public readonly topLeft: SingleCoordinate
+    public readonly topRight: SingleCoordinate
+
+    public readonly center: SingleCoordinate
+    /** A flattened version of the bounds such as [lowerX, lowerY, upperX, upperY] */
+    public readonly flatten: [number, number, number, number]
+
+    /**
+     * @param args.lowerX
+     * @param args.upperX
+     * @param args.lowerY
+     * @param args.upperY
+     * @param args.customCenter If this bounds must have a different center (if we want to offset
+     *   the natural center of those bounds). If no custom center is given, the center will be
+     *   calculated relative to the bounds.
+     */
+    constructor(args: CoordinateSystemBoundsProps) {
+        const { lowerX, upperX, lowerY, upperY, customCenter } = args
+        this.lowerX = lowerX
+        this.upperX = upperX
+        this.lowerY = lowerY
+        this.upperY = upperY
+        this.customCenter = customCenter
+
+        this.bottomLeft = [this.lowerX, this.lowerY]
+        this.bottomRight = [this.upperX, this.lowerY]
+        this.topLeft = [this.lowerX, this.upperY]
+        this.topRight = [this.upperX, this.upperY]
+
+        this.center = this.customCenter ?? [
+            (this.lowerX + this.upperX) / 2,
+            (this.lowerY + this.upperY) / 2,
+        ]
+        this.flatten = [this.lowerX, this.lowerY, this.upperX, this.upperY]
+    }
+
+    isInBounds(x: number, y: number): boolean
+    isInBounds(coordinate: SingleCoordinate): boolean
+
+    isInBounds(xOrCoordinate: number | SingleCoordinate, y?: number): boolean {
+        if (typeof xOrCoordinate === 'number') {
+            return (
+                xOrCoordinate >= this.lowerX &&
+                xOrCoordinate <= this.upperX &&
+                y! >= this.lowerY &&
+                y! <= this.upperY
+            )
+        }
+        return this.isInBounds(xOrCoordinate[0], xOrCoordinate[1])
+    }
+
+    /**
+     * Will split the coordinates in chunks if some portion of the coordinates are outside bounds
+     * (one chunk for the portion inside, one for the portion outside, rinse and repeat if
+     * necessary)
+     *
+     * Can be helpful when requesting information from our backends, but said backend doesn't
+     * support world-wide coverage. Typical example is service-profile, if we give it coordinates
+     * outside LV95 bounds it will fill what it doesn't know with coordinates following LV95 extent
+     * instead of returning undefined
+     *
+     * @param {[Number, Number][]} coordinates Coordinates `[[x1,y1],[x2,y2],...]` expressed in the
+     *   same coordinate system (projection) as the bounds
+     * @returns {CoordinatesChunk[] | undefined}
+     */
+    splitIfOutOfBounds(coordinates: SingleCoordinate[]): CoordinatesChunk[] | undefined {
+        if (!Array.isArray(coordinates) || coordinates.length <= 1) {
+            return
+        }
+        // checking that all coordinates are well-formed
+        if (coordinates.find((coordinate) => coordinate.length !== 2)) {
+            return
+        }
+        // checking if we require splitting
+        if (coordinates.find((coordinate) => !this.isInBounds(coordinate))) {
+            const boundsAsPolygon = bboxPolygon(this.flatten)
+            const paths = lineSplit(lineString(coordinates), boundsAsPolygon)
+            if (coordinates[0]) {
+                paths.features = reassembleLineSegments(coordinates[0], paths)
+            }
+            return paths.features.map((chunk) => {
+                return {
+                    coordinates: chunk.geometry.coordinates,
+                    isWithinBounds: points(chunk.geometry.coordinates).features.every((point) =>
+                        booleanPointInPolygon(point, boundsAsPolygon)
+                    ),
+                } as CoordinatesChunk
+            })
+        }
+        // no splitting needed, we return the coordinates as they were given
+        return [
+            {
+                coordinates: coordinates,
+                isWithinBounds: true,
+            },
+        ]
+    }
+}

package/src/proj/CustomCoordinateSystem.ts

@@ -0,0 +1,58 @@
+import type { SingleCoordinate } from '@/coordinatesUtils'
+import type { CoordinateSystemProps } from '@/proj/CoordinateSystem'
+import type CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+
+import CoordinateSystem from '@/proj/CoordinateSystem'
+
+export interface CustomCoordinateSystemProps extends CoordinateSystemProps {
+    /** With a custom coordinate system, bounds are mandatory. */
+    bounds: CoordinateSystemBounds
+}
+
+/**
+ * Description of a coordinate system that will not use the standard resolution and zoom level
+ * (a.k.a. mercator pyramid).
+ *
+ * This can be used to describe national coordinate systems that are built to represent a subset of
+ * the World, with a custom zoom pyramid to match their map resolutions.
+ *
+ * You can see examples by following {@link SwissCoordinateSystem} and its children.
+ *
+ * @abstract
+ * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
+ */
+export default abstract class CustomCoordinateSystem extends CoordinateSystem {
+    declare public readonly bounds: CoordinateSystemBounds
+
+    protected constructor(args: CustomCoordinateSystemProps) {
+        super(args)
+    }
+
+    /**
+     * The origin to use as anchor for tile coordinate calculations. It will return the bound's
+     * [lowerX, upperY] as default value (meaning the top-left corner of bounds). If this is not the
+     * behavior you want, you have to override this function.
+     */
+    getTileOrigin(): SingleCoordinate {
+        return this.bounds.topLeft
+    }
+
+    /**
+     * Transforms a zoom level from this custom coordinate system, back to a zoom level such as
+     * described in https://wiki.openstreetmap.org/wiki/Zoom_levels
+     *
+     * @abstract
+     * @param customZoomLevel A zoom level in this custom coordinate system
+     * @returns A standard (or OpenStreetMap) zoom level
+     */
+    abstract transformCustomZoomLevelToStandard(customZoomLevel: number): number
+
+    /**
+     * Transforms a standard (or OpenStreetMap) zoom level into a zoom level in this coordinate
+     * system
+     *
+     * @param standardZoomLevel A standard zoom level
+     * @returns A zoom level in this custom coordinate system
+     */
+    abstract transformStandardZoomLevelToCustom(standardZoomLevel: number): number
+}

package/src/proj/LV03CoordinateSystem.ts

@@ -0,0 +1,23 @@
+import CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+import SwissCoordinateSystem from '@/proj/SwissCoordinateSystem'
+
+export default class LV03CoordinateSystem extends SwissCoordinateSystem {
+    constructor() {
+        super({
+            epsgNumber: 21781,
+            label: 'CH1903 / LV03',
+            technicalName: 'LV03',
+            // matrix is coming fom https://epsg.io/21781.proj4
+            proj4transformationMatrix:
+                '+proj=somerc +lat_0=46.9524055555556 +lon_0=7.43958333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +towgs84=674.374,15.056,405.346,0,0,0,0 +units=m +no_defs +type=crs',
+            // bound is coming from https://epsg.io/21781
+            bounds: new CoordinateSystemBounds({
+                lowerX: 485071.58,
+                upperX: 837119.8,
+                lowerY: 74261.72,
+                upperY: 299941.79,
+            }),
+            usesMercatorPyramid: false,
+        })
+    }
+}

package/src/proj/LV95CoordinateSystem.ts

@@ -0,0 +1,35 @@
+import CoordinateSystemBounds from '@/proj/CoordinateSystemBounds'
+import SwissCoordinateSystem from '@/proj/SwissCoordinateSystem'
+
+export default class LV95CoordinateSystem extends SwissCoordinateSystem {
+    constructor() {
+        super({
+            epsgNumber: 2056,
+            label: 'CH1903+ / LV95',
+            technicalName: 'LV95',
+            // matrix is coming fom https://epsg.io/2056.proj4
+            proj4transformationMatrix:
+                '+proj=somerc +lat_0=46.9524055555556 +lon_0=7.43958333333333 +k_0=1 +x_0=2600000 +y_0=1200000 +ellps=bessel +towgs84=674.374,15.056,405.346,0,0,0,0 +units=m +no_defs +type=crs',
+            /**
+             * This can be used to constrain OpenLayers (or another mapping framework) to only ask
+             * for tiles that are within the extent. It should remove, for instance, the big white
+             * zone that is around the pixelkarte-farbe.
+             *
+             * Values are a ripoff of mf-geoadmin3 (see link below) and are not technically the
+             * mathematical bounds of the system, but the limit at which we do not serve data
+             * anymore.
+             *
+             * Those are coordinates expressed in EPSG:2056 (or LV95)
+             *
+             * @see https://github.com/geoadmin/mf-geoadmin3/blob/0ec560069e93fdceb54ce126a3c2d0ef23a50f45/mk/config.mk#L140
+             */
+            bounds: new CoordinateSystemBounds({
+                lowerX: 2420000,
+                upperX: 2900000,
+                lowerY: 1030000,
+                upperY: 1350000,
+            }),
+            usesMercatorPyramid: false,
+        })
+    }
+}

package/src/proj/StandardCoordinateSystem.ts

@@ -0,0 +1,22 @@
+import CoordinateSystem, { STANDARD_ZOOM_LEVEL_1_25000_MAP } from '@/proj/CoordinateSystem'
+
+/**
+ * Coordinate system with a zoom level/resolution calculation based on the size of the Earth at the
+ * equator.
+ *
+ * These will be used to represent WebMercator and WGS84 among others.
+ *
+ * @abstract
+ * @see https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Resolution_and_Scale
+ * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
+ */
+export default abstract class StandardCoordinateSystem extends CoordinateSystem {
+    /** The index in the resolution list where the 1:25000 zoom level is */
+    get1_25000ZoomLevel(): number {
+        return STANDARD_ZOOM_LEVEL_1_25000_MAP
+    }
+
+    getDefaultZoom(): number {
+        return STANDARD_ZOOM_LEVEL_1_25000_MAP
+    }
+}

package/src/proj/SwissCoordinateSystem.ts

@@ -0,0 +1,233 @@
+import { closest, round } from '@swissgeo/numbers'
+
+import type { ResolutionStep } from '@/proj/types'
+
+import {
+    STANDARD_ZOOM_LEVEL_1_25000_MAP,
+    SWISS_ZOOM_LEVEL_1_25000_MAP,
+} from '@/proj/CoordinateSystem'
+import CustomCoordinateSystem from '@/proj/CustomCoordinateSystem'
+
+/**
+ * Resolutions for each LV95 zoom level, from 0 to 14
+ *
+ * @see https://api3.geo.admin.ch/services/sdiservices.html#gettile
+ */
+export const LV95_RESOLUTIONS: number[] = [
+    650.0, 500.0, 250.0, 100.0, 50.0, 20.0, 10.0, 5.0, 2.5, 2.0, 1.0, 0.5, 0.25, 0.1,
+]
+
+/**
+ * Resolutions steps (one per zoom level) for our own WMTS pyramid (see
+ * {@link http://api3.geo.admin.ch/services/sdiservices.html#wmts}) expressed in meters/pixel
+ *
+ * Be mindful that zoom levels described on our doc are expressed for LV95 and need conversion to
+ * World Wide zoom level (see {@link SwissCoordinateSystem})
+ *
+ * It is essentially, at low resolution, the same as {@link LV95_RESOLUTIONS}, but with added steps
+ * at higher zoom level (further from the ground)
+ */
+export const SWISSTOPO_TILEGRID_RESOLUTIONS: number[] = [
+    4000.0,
+    3750.0,
+    3500.0,
+    3250.0,
+    3000.0,
+    2750.0,
+    2500.0,
+    2250.0,
+    2000.0,
+    1750.0,
+    1500.0,
+    1250.0,
+    1000.0,
+    750.0,
+    ...LV95_RESOLUTIONS.slice(0, 10),
+    // see table https://api3.geo.admin.ch/services/sdiservices.html#gettile
+    // LV95 doesn't support zoom level 10 at 1.5 resolution, so we need to split
+    // the resolution and add it here
+    1.5,
+    ...LV95_RESOLUTIONS.slice(10),
+]
+
+/**
+ * Conversion matrix from swisstopo LV95 zoom level to Web Mercator zoom level
+ *
+ * Indexes of the array are LV95 zoom levels
+ *
+ * Values are mercator equivalents
+ *
+ * @type {Number[]}
+ */
+export const SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX: number[] = [
+    7.35, // min: 0
+    7.75, // 1
+    8.75, // 2
+    10, // 3
+    11, // 4
+    12.5, // 5
+    13.5, // 6
+    14.5, // 7
+    STANDARD_ZOOM_LEVEL_1_25000_MAP, // 8
+    15.75, // 9
+    16.7, // 10
+    17.75, // 11
+    18.75, // 12
+    20, // 13
+    21, // max: 14
+]
+
+const SWISSTOPO_ZOOM_TO_PRODUCT_SCALE: string[] = [
+    "1:2'500'000", // zoom 0
+    "1:2'500'000", // 1
+    "1:1'000'000", // 2
+    "1:1'000'000", // 3
+    "1:500'000", // 4
+    "1:200'000", // 5
+    "1:100'000", // 6
+    "1:50'000", // 7
+    "1:25'000", // 8
+    "1:25'000", // 9
+    "1:10'000", // 10
+    "1:10'000", // 11
+    "1:10'000", // 12
+    "1:10'000", // 13
+    "1:10'000", // max zoom: 14
+]
+
+const swisstopoZoomLevels: number[] = SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX.map(
+    (_, index) => index
+)
+
+/**
+ * This specialization will be used to represent LV95 and LV03, that use a custom zoom/resolution
+ * pyramid to match all our printable products (in contrast to {@link StandardCoordinateSystem} which
+ * bases its zoom/resolution on the radius of the Earth at the equator and latitude positioning of
+ * the map).
+ *
+ * @abstract
+ * @see https://api3.geo.admin.ch/services/sdiservices.html#wmts
+ * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
+ */
+export default class SwissCoordinateSystem extends CustomCoordinateSystem {
+    getResolutionSteps(): ResolutionStep[] {
+        return SWISSTOPO_TILEGRID_RESOLUTIONS.map((resolution) => {
+            const zoom: number | undefined = LV95_RESOLUTIONS.indexOf(resolution) ?? undefined
+            let label: string | undefined
+            if (zoom) {
+                label = SWISSTOPO_ZOOM_TO_PRODUCT_SCALE[zoom]
+            }
+            return {
+                zoom,
+                label,
+                resolution: resolution,
+            }
+        })
+    }
+
+    get1_25000ZoomLevel(): number {
+        return SWISS_ZOOM_LEVEL_1_25000_MAP
+    }
+
+    getDefaultZoom(): number {
+        return 1
+    }
+
+    transformStandardZoomLevelToCustom(standardZoomLevel: number): number {
+        // checking first if the standard zoom level is within range of swiss zooms we have available
+        if (
+            typeof SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[0] === 'number' &&
+            typeof SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[14] === 'number' &&
+            standardZoomLevel >= SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[0] &&
+            standardZoomLevel <= SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[14]
+        ) {
+            return SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX.filter(
+                (zoom) => zoom < standardZoomLevel
+            ).length
+        }
+        if (
+            typeof SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[0] === 'number' &&
+            standardZoomLevel < SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[0]
+        ) {
+            return 0
+        }
+        if (
+            typeof SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[14] === 'number' &&
+            standardZoomLevel > SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[14]
+        ) {
+            return 14
+        }
+        // if no matching zoom level was found, we return the one for the 1:25'000 map
+        return this.get1_25000ZoomLevel()
+    }
+
+    /**
+     * Mapping between Swiss map zooms and standard zooms. Heavily inspired by
+     * {@link https://github.com/geoadmin/mf-geoadmin3/blob/ce885985e4af5e3e20c87321e67a650388af3602/src/components/map/MapUtilsService.js#L603-L631 MapUtilsService.js on mf-geoadmin3}
+     *
+     * @param customZoomLevel A zoom level as desribed in
+     *   {@link http://api3.geo.admin.ch/services/sdiservices.html#wmts our backend's doc}
+     * @returns A web-mercator zoom level (as described on
+     *   {@link https://wiki.openstreetmap.org/wiki/Zoom_levels | OpenStreetMap's wiki}) or the zoom
+     *   level to show the 1:25'000 map if the input is invalid
+     */
+    transformCustomZoomLevelToStandard(customZoomLevel: number): number {
+        const key = Math.floor(customZoomLevel)
+        if (SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX.length - 1 >= key) {
+            return (
+                SWISSTOPO_TILEGRID_ZOOM_TO_STANDARD_ZOOM_MATRIX[key] ??
+                STANDARD_ZOOM_LEVEL_1_25000_MAP
+            )
+        }
+        // if no matching zoom level was found, we return the one for the 1:25'000 map
+        return STANDARD_ZOOM_LEVEL_1_25000_MAP
+    }
+
+    getResolutionForZoomAndCenter(zoom: number): number {
+        const roundedZoom = Math.round(zoom)
+        if (typeof LV95_RESOLUTIONS[roundedZoom] !== 'number') {
+            return 0
+        }
+        // ignoring the center, as it won't have any effect on the chosen zoom level
+        return LV95_RESOLUTIONS[roundedZoom]
+    }
+
+    getZoomForResolutionAndCenter(resolution: number): number {
+        // ignoring the center, as it won't have any effect on the resolution
+        const matchingResolution = LV95_RESOLUTIONS.find(
+            (lv95Resolution) => lv95Resolution <= resolution
+        )
+        if (matchingResolution) {
+            return LV95_RESOLUTIONS.indexOf(matchingResolution)
+        }
+        // if no match was found, we have to decide if the resolution is too great,
+        // or too small to be matched and return the zoom accordingly
+        const smallestResolution = LV95_RESOLUTIONS.slice(-1)[0]
+        if (smallestResolution && smallestResolution > resolution) {
+            // if the resolution was smaller than the smallest available, we return the zoom level corresponding
+            // to the smallest available resolution
+            return LV95_RESOLUTIONS.indexOf(smallestResolution)
+        }
+        // otherwise, we return the zoom level corresponding to the greatest resolution available
+        return 0
+    }
+
+    roundCoordinateValue(value: number): number {
+        return round(value, 2)
+    }
+
+    /**
+     * Rounding to the zoom level
+     *
+     * @param customZoomLevel A zoom level, that could be a floating number
+     * @param normalize Normalize the zoom level to the closest swisstopo zoom level, by default it
+     *   only round the zoom level to 3 decimal
+     * @returns A zoom level matching one of our national maps
+     */
+    roundZoomLevel(customZoomLevel: number, normalize: boolean = false): number {
+        if (normalize) {
+            return closest(customZoomLevel, swisstopoZoomLevels)
+        }
+        return super.roundZoomLevel(customZoomLevel)
+    }
+}

package/src/proj/WGS84CoordinateSystem.ts

@@ -0,0 +1,97 @@
+import { round } from '@swissgeo/numbers'
+
+import type { SingleCoordinate } from '@/coordinatesUtils'
+
+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 WGS84CoordinateSystem extends StandardCoordinateSystem {
+    constructor() {
+        super({
+            epsgNumber: 4326,
+            label: 'WGS 84 (lat/lon)',
+            // matrix comes from https://epsg.io/4326.proj4
+            proj4transformationMatrix: '+proj=longlat +datum=WGS84 +no_defs +type=proj',
+            bounds: new CoordinateSystemBounds({
+                lowerX: -180.0,
+                upperX: 180.0,
+                lowerY: -90.0,
+                upperY: 90.0,
+                // center of LV95's extent transformed with epsg.io website
+                customCenter: [8.239436, 46.832259],
+            }),
+            usesMercatorPyramid: true,
+        })
+    }
+
+    roundCoordinateValue(value: number): number {
+        // a precision of 6 digits means we can track position with 0.111m accuracy
+        // see http://wiki.gis.com/wiki/index.php/Decimal_degrees
+        return round(value, 6)
+    }
+
+    /**
+     * 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 {
+        return round(
+            Math.abs(
+                (PIXEL_LENGTH_IN_KM_AT_ZOOM_ZERO_WITH_256PX_TILES *
+                    Math.cos((center[1] * Math.PI) / 180.0)) /
+                    Math.pow(2, zoom)
+            ),
+            2
+        )
+    }
+
+    /**
+     * Ensures an extent is in X,Y order (longitude, latitude). If coordinates are in Y,X order
+     * (latitude, longitude), swaps them. WGS84 traditionally uses latitude-first (Y,X) axis order
+     * [minY, minX, maxY, maxX] Some WGS84 implementations may use X,Y order therefore we need to
+     * check and swap if needed.
+     *
+     * TODO: This method works for the common coordinates in and around switzerland but will not
+     * work for the whole world. Therefore a better solution should be implemented if we want to
+     * support coordinates and extents of the whole world.
+     *
+     * @param extent - Input extent [minX, minY, maxX, maxY] or [minY, minX, maxY, maxX]
+     * @returns Extent guaranteed to be in [minX, minY, maxX, maxY] order
+     * @link Problem description https://docs.geotools.org/latest/userguide/library/referencing/order.html
+     */
+    getExtentInOrderXY(extent: [number, number, number, number]): [number, number, number, number] {
+        if (extent[0] > extent[1]) {
+            return [extent[1], extent[0], extent[3], extent[2]]
+        }
+        return extent
+    }
+
+    /**
+     * 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 {
+        return Math.abs(
+            Math.log2(
+                resolution /
+                    PIXEL_LENGTH_IN_KM_AT_ZOOM_ZERO_WITH_256PX_TILES /
+                    Math.cos((center[1] * Math.PI) / 180.0)
+            )
+        )
+    }
+}