ogcopenapis 0.0.12 → 1.0.1

package/src/OgcOpenApiMapsModel.ts

@@ -0,0 +1,128 @@
+import {RasterDataType} from "@luciad/ria/model/tileset/RasterDataType.js";
+import {RasterSamplingMode} from "@luciad/ria/model/tileset/RasterSamplingMode.js";
+import {WMSTileSetModel} from "@luciad/ria/model/tileset/WMSTileSetModel.js";
+import {OgcOpenApiCrsTools} from "./OgcOpenApiCrsTools.js";
+import {getReference} from "@luciad/ria/reference/ReferenceProvider.js";
+import type {TileCoordinate} from "@luciad/ria/model/tileset/TileCoordinate.js";
+import {Bounds} from "@luciad/ria/shape/Bounds.js";
+import {CoordinateReference} from "@luciad/ria/reference/CoordinateReference.js";
+import {createBounds} from "@luciad/ria/shape/ShapeFactory.js";
+import type {ProxifyFunction} from "./OgcOpenApiGetCapabilities.js";
+import {OgcOpenApiTileMatrixTools} from "./OgcOpenApiTileMatrixTools.js";
+
+// Half the extent of the Web Mercator world, in metres
+const WEB_MERCATOR_HALF_WORLD = 20037508.3427892;
+
+interface OgcOpenApiMapsModelConstructorOptions {
+    crs: string;
+    baseURL: string;
+    collection: string;
+    dataType?: RasterDataType;
+    samplingMode?: RasterSamplingMode;
+    credentials?: boolean;
+    requestHeaders?: { [p: string]: string };
+    format?: string;
+    reverseAxis?: boolean;
+    datetime?: string;
+    subset?: string[];
+    transparent?: boolean;
+    bgcolor?: string;
+    // The extent that is tiled, defaults to the Web Mercator world for EPSG:3857
+    bounds?: Bounds;
+
+    proxify?: ProxifyFunction
+}
+
+class OgcOpenApiMapsModel extends WMSTileSetModel {
+    private format: string | undefined;
+    private crs: string;
+    private reverseAxis: boolean | undefined;
+    private datetime: string | undefined;
+    private subset: string[] | undefined;
+    private bgcolor: string | undefined;
+    private proxy: ProxifyFunction;
+    // The query of the map link, such as f=png: servers advertise the f values they accept
+    private linkParameters: { [key: string]: string };
+
+    constructor(o: OgcOpenApiMapsModelConstructorOptions) {
+        const referenceName = OgcOpenApiCrsTools.getReferenceName(o.crs)
+        const reference = getReference(referenceName);
+        super({
+            reference,
+            bounds: o.bounds ? o.bounds : OgcOpenApiMapsModel.getDefaultBounds(reference),
+            getMapRoot: o.baseURL,
+            layers: [o.collection],
+            dataType: o.dataType,
+            samplingMode: o.samplingMode,
+            credentials: o.credentials,
+            requestHeaders: o.requestHeaders
+        });
+        this.crs = o.crs;
+        this.format = o.format;
+        this.reverseAxis = o.reverseAxis;
+
+        this.datetime = o.datetime;
+        this.subset = o.subset;
+        this.transparent = typeof o.transparent !== "undefined" ? o.transparent : true;
+        this.bgcolor = o.bgcolor;
+
+        this.proxy = o.proxify;
+        this.linkParameters = OgcOpenApiMapsModel.getQueryParameters(o.baseURL);
+
+        this.modelDescriptor = {
+            source: o.baseURL,
+            name: o.collection,
+            description: "OGC Open API Maps",
+            type: super.dataType
+        };
+    }
+
+    getTileURL(baseURL: string, tile: TileCoordinate): string | null {
+        let aURL = super.getTileURL(baseURL, tile);
+        if (aURL) {
+            const parts = aURL.split("?");
+            const queryString = parts.length>1 ? parts[1] : "";
+            const url = parts[0];
+            const urlParams = new URLSearchParams(queryString);
+            const bbox = urlParams.get('BBOX');
+            const urlParameters = {
+                ...this.linkParameters,
+                bbox:bbox,
+                "bbox-crs":this.crs,
+                crs:this.crs,
+                f: this.format ? this.format : this.linkParameters.f,
+                datetime: this.datetime ,
+                subset: this.subset ? this.subset.join(",") : undefined,
+                transparent: this.transparent,
+                bgcolor: this.transparent ? undefined : this.bgcolor
+            }
+            let transformedUrl = OgcOpenApiTileMatrixTools.appendQueryParameters(url, urlParameters);
+            if (typeof this.proxy === "function") {
+                const proxyfied = this.proxy(transformedUrl, {});
+                transformedUrl = proxyfied.url;
+            }
+            return transformedUrl;
+        } else {
+            return aURL
+        }
+    }
+
+    private static getQueryParameters(url: string) {
+        const parameters: { [key: string]: string } = {};
+        const query = url.split("?")[1];
+        if (query) new URLSearchParams(query).forEach((value, key) => parameters[key] = value);
+        return parameters;
+    }
+
+    // The reference's own bounds for EPSG:3857 are a little larger than the Web Mercator world (y up to 20048966),
+    // tiles cover exactly the Web Mercator world instead, the same bounds as LuciadRIA's OSM tiles
+    private static getDefaultBounds(reference: CoordinateReference): Bounds | undefined {
+        if (reference.identifier !== "EPSG:3857" && reference.identifier !== "EPSG:900913") return undefined;
+        return createBounds(reference, [-WEB_MERCATOR_HALF_WORLD, 2 * WEB_MERCATOR_HALF_WORLD, -WEB_MERCATOR_HALF_WORLD, 2 * WEB_MERCATOR_HALF_WORLD]);
+    }
+
+}
+
+export {
+    OgcOpenApiMapsModel
+}

package/src/OgcOpenApiMvtTools.ts

@@ -0,0 +1,104 @@
+import type {TileSetLayer} from "./OgcOpenApiGetCapabilities.js";
+
+/**
+ * Reads the layers of a Mapbox Vector Tile: their names, and the geometryDimension of their features (0 points,
+ * 1 lines, 2 surfaces). Only what is needed to style a tileset that does not describe its layers.
+ * See https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ */
+const LAYER = 3;
+const LAYER_NAME = 1;
+const LAYER_FEATURE = 2;
+const FEATURE_TYPE = 3;
+// MVT GeomType POINT, LINESTRING, POLYGON
+const GEOMETRY_DIMENSION = {1: 0, 2: 1, 3: 2};
+
+const WIRE_VARINT = 0;
+const WIRE_64BIT = 1;
+const WIRE_LENGTH = 2;
+const WIRE_32BIT = 5;
+
+interface Field {
+    field: number;
+    value: number | Uint8Array;
+}
+
+class OgcOpenApiMvtTools {
+
+    /**
+     * The layers of a tile, a layer has geometryDimension when all its features have the same geometry type.
+     * The tile may be gzip compressed.
+     */
+    public static async getLayers(content: ArrayBuffer): Promise<TileSetLayer[]> {
+        const bytes = await OgcOpenApiMvtTools.decompress(new Uint8Array(content));
+        const layers: TileSetLayer[] = [];
+        for (const layer of OgcOpenApiMvtTools.readFields(bytes)) {
+            if (layer.field !== LAYER || typeof layer.value === "number") continue;
+            let id: string | undefined;
+            const dimensions = new Set<number>();
+            for (const property of OgcOpenApiMvtTools.readFields(layer.value)) {
+                if (property.field === LAYER_NAME && typeof property.value !== "number") {
+                    id = new TextDecoder().decode(property.value);
+                } else if (property.field === LAYER_FEATURE && typeof property.value !== "number") {
+                    for (const feature of OgcOpenApiMvtTools.readFields(property.value)) {
+                        if (feature.field === FEATURE_TYPE && typeof feature.value === "number" && feature.value in GEOMETRY_DIMENSION) {
+                            dimensions.add(GEOMETRY_DIMENSION[feature.value]);
+                        }
+                    }
+                }
+            }
+            if (id !== undefined && dimensions.size > 0) {
+                layers.push(dimensions.size === 1 ? {id, geometryDimension: dimensions.values().next().value} : {id});
+            }
+        }
+        return layers;
+    }
+
+    private static async decompress(bytes: Uint8Array): Promise<Uint8Array> {
+        if (bytes.length < 2 || bytes[0] !== 0x1f || bytes[1] !== 0x8b) return bytes;
+        // DecompressionStream is in all current browsers and Node 18
+        if (typeof DecompressionStream === "undefined") throw new Error("A gzip compressed vector tile needs DecompressionStream");
+        // A copy, as Response takes a Uint8Array over an ArrayBuffer only, not over a SharedArrayBuffer
+        const stream = new Response(new Uint8Array(bytes)).body.pipeThrough(new DecompressionStream("gzip"));
+        return new Uint8Array(await new Response(stream).arrayBuffer());
+    }
+
+    // The fields of a protobuf message, nested messages are returned as bytes
+    private static* readFields(bytes: Uint8Array): Generator<Field> {
+        let position = 0;
+        const readVarint = () => {
+            let result = 0;
+            let shift = 0;
+            let byte: number;
+            do {
+                if (position >= bytes.length) throw new Error("Invalid vector tile");
+                byte = bytes[position++];
+                result += (byte & 0x7f) * Math.pow(2, shift);
+                shift += 7;
+            } while (byte >= 0x80);
+            return result;
+        };
+        while (position < bytes.length) {
+            const key = readVarint();
+            const field = Math.floor(key / 8);
+            const wireType = key % 8;
+            if (wireType === WIRE_VARINT) {
+                yield {field, value: readVarint()};
+            } else if (wireType === WIRE_LENGTH) {
+                const length = readVarint();
+                if (position + length > bytes.length) throw new Error("Invalid vector tile");
+                yield {field, value: bytes.subarray(position, position + length)};
+                position += length;
+            } else if (wireType === WIRE_64BIT) {
+                position += 8;
+            } else if (wireType === WIRE_32BIT) {
+                position += 4;
+            } else {
+                throw new Error("Invalid vector tile");
+            }
+        }
+    }
+}
+
+export {
+    OgcOpenApiMvtTools
+}

package/src/OgcOpenApiStyleTools.ts

@@ -0,0 +1,187 @@
+import {
+    CollectionLinkType,
+    type LinkType,
+    type OgcOpenApiCapabilitiesCollection,
+    type OgcOpenApiCapabilitiesObject,
+    OgcOpenApiGetCapabilities,
+    type TileSetLayer
+} from "./OgcOpenApiGetCapabilities.js";
+import {OgcOpenApiFetchTools} from "./OgcOpenApiFetchTools.js";
+
+export const MAPBOX_STYLE_TYPE = "application/vnd.mapbox.style+json";
+
+type RequestHeaders = {[headerName: string]: string;} | null
+
+export interface OgcOpenApiStyle {
+    id: string;
+    title: string;
+    // The stylesheets of this style in the Mapbox GL encoding, the only one LuciadRIA reads
+    mapboxStylesheets: LinkType[];
+}
+
+const DEFAULT_COLORS = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"];
+
+class OgcOpenApiStyleTools {
+
+    /**
+     * Lists the styles of a collection (OGC API Styles) that are available as a Mapbox GL style, or with collection
+     * null the styles of the dataset, for its dataset tilesets.
+     */
+    public static fetchStyles(
+        capabilities: OgcOpenApiCapabilitiesObject | null,
+        collection: OgcOpenApiCapabilitiesCollection | null,
+        options?: {credentials?: boolean, requestHeaders?: RequestHeaders}
+    ) {
+        return new Promise<OgcOpenApiStyle[]>((resolve, reject) => {
+            if (capabilities === null) {
+                reject();
+                return;
+            }
+            const href = OgcOpenApiStyleTools.withJsonFormat(OgcOpenApiStyleTools.getStylesHref(capabilities, collection));
+            OgcOpenApiFetchTools.fetch(href, {
+                method: "GET",
+                credentials: options?.credentials ? "same-origin" : "omit",
+                headers: {...(options?.requestHeaders ? options.requestHeaders : {}), Accept: "application/json"}
+            }, capabilities.serverOptions).then(response => {
+                // A collection without styles
+                if (response.status === 404) {
+                    resolve([]);
+                    return;
+                }
+                if (response.status !== 200) {
+                    reject({error: true, message: "Invalid response: " + response.status});
+                    return;
+                }
+                response.json().then(data => {
+                    const styles = data.styles ? data.styles : [];
+                    resolve(styles.map(style => ({
+                        id: style.id,
+                        title: style.title ? style.title : style.id,
+                        mapboxStylesheets: (style.links ? style.links : [])
+                            .filter(l => l.rel === "stylesheet" && typeof l.type === "string" && l.type.indexOf(MAPBOX_STYLE_TYPE) === 0)
+                            // Relative to the styles document
+                            .map(l => ({...l, href: OgcOpenApiFetchTools.resolveUrl(l.href, href, capabilities.serverOptions)}))
+                    })).filter(style => style.mapboxStylesheets.length > 0));
+                }, () => reject({error: true, message: "Not JSON data"}));
+            }, err => reject({error: true, message: err.message}));
+        });
+    }
+
+    /**
+     * The styles for a tile matrix set. Zoom levels are tile matrix set specific, so a server can have a style per
+     * tile matrix set and name it after it (PDOK: bgt_standaardvisualisatie__netherlandsrdnewquad). A style named after
+     * another of tileMatrixSetIds, and not after tileMatrixSetId, is left out. Other styles have a stylesheet per tile
+     * matrix set or serve all of them (pickStylesheet).
+     */
+    public static getStylesForTileMatrixSet(styles: OgcOpenApiStyle[], tileMatrixSetId: string, tileMatrixSetIds: string[]) {
+        const names = (style: OgcOpenApiStyle, id: string) => (style.id + " " + style.title).toLowerCase().indexOf(id.toLowerCase()) > -1;
+        const others = tileMatrixSetIds.filter(id => id.toLowerCase() !== tileMatrixSetId.toLowerCase());
+        return styles.filter(style => names(style, tileMatrixSetId) || !others.some(id => names(style, id)));
+    }
+
+    /**
+     * A style can have one stylesheet per tile matrix set, because zoom levels are tile matrix set specific.
+     * Prefers the stylesheet for tileMatrixSetId, then the one without a tile matrix set.
+     */
+    public static pickStylesheet(style: OgcOpenApiStyle, tileMatrixSetId: string): LinkType | undefined {
+        const forTileMatrixSet = style.mapboxStylesheets.find(l => l.href.indexOf("tile-matrix-set=" + tileMatrixSetId) > -1);
+        if (forTileMatrixSet) return forTileMatrixSet;
+        const generic = style.mapboxStylesheets.find(l => l.href.indexOf("tile-matrix-set=") === -1);
+        return generic ? generic : style.mapboxStylesheets[0];
+    }
+
+    /**
+     * Fetches a Mapbox GL style. Properties without a value, as in `"filter" : ,`, are removed so that styles
+     * that are not valid JSON can still be used.
+     */
+    public static fetchMapboxStyle(
+        capabilities: OgcOpenApiCapabilitiesObject,
+        stylesheet: LinkType,
+        options?: {credentials?: boolean, requestHeaders?: RequestHeaders}
+    ) {
+        return OgcOpenApiFetchTools.fetch(stylesheet.href, {
+            method: "GET",
+            credentials: options?.credentials ? "same-origin" : "omit",
+            headers: {...(options?.requestHeaders ? options.requestHeaders : {}), Accept: MAPBOX_STYLE_TYPE}
+        }, capabilities.serverOptions).then(response => {
+            if (response.status !== 200) throw new Error("Invalid response: " + response.status);
+            return response.text();
+        }).then(text => OgcOpenApiStyleTools.parseMapboxStyle(text));
+    }
+
+    public static parseMapboxStyle(text: string): any {
+        try {
+            return JSON.parse(text);
+        } catch (e) {
+            const repaired = text
+                .replace(/"[^"\\]*"\s*:\s*(?=[,}\]])/g, "")
+                .replace(/,(\s*[,}\]])/g, "$1")
+                .replace(/,(\s*[,}\]])/g, "$1")
+                .replace(/([{\[])(\s*),/g, "$1$2");
+            return JSON.parse(repaired);
+        }
+    }
+
+    /**
+     * A Mapbox GL style that paints every layer of a vector tileset, by geometryDimension: points as dots,
+     * lines as lines and surfaces as filled polygons. Layers without geometryDimension get all three, filtered
+     * by geometry type.
+     */
+    public static createDefaultStyle(layers: TileSetLayer[], name?: string): any {
+        const styleLayers = [];
+        layers.forEach((layer, index) => {
+            const color = DEFAULT_COLORS[index % DEFAULT_COLORS.length];
+            const dimension = layer.geometryDimension;
+            const known = typeof dimension === "number";
+            if (!known || dimension === 2) {
+                styleLayers.push({
+                    id: layer.id + "_fill", type: "fill", "source-layer": layer.id,
+                    ...(known ? {} : {filter: ["==", ["geometry-type"], "Polygon"]}),
+                    paint: {"fill-color": color, "fill-opacity": 0.4, "fill-outline-color": color}
+                });
+            }
+            if (!known || dimension === 1 || dimension === 2) {
+                styleLayers.push({
+                    id: layer.id + "_line", type: "line", "source-layer": layer.id,
+                    ...(known ? {} : {filter: ["!=", ["geometry-type"], "Point"]}),
+                    paint: {"line-color": color, "line-width": dimension === 2 ? 1 : 2}
+                });
+            }
+            if (!known || dimension === 0) {
+                // A text dot rather than a circle layer: LuciadRIA 2026.1.1 does not paint circle layers
+                styleLayers.push({
+                    id: layer.id + "_point", type: "symbol", "source-layer": layer.id,
+                    ...(known ? {} : {filter: ["==", ["geometry-type"], "Point"]}),
+                    layout: {"text-field": "\u25CF", "text-size": 16, "text-allow-overlap": true},
+                    paint: {"text-color": color, "text-halo-color": "#ffffff", "text-halo-width": 1}
+                });
+            }
+        });
+        return {version: 8, name: name ? name : "default", sources: {}, layers: styleLayers};
+    }
+
+    // Some servers (ldproxy) list the styles link only in the collection document, not in /collections.
+    // The styles of the dataset are linked from the landing page.
+    private static getStylesHref(capabilities: OgcOpenApiCapabilitiesObject, collection: OgcOpenApiCapabilitiesCollection | null) {
+        if (!collection) {
+            const datasetLinks = OgcOpenApiGetCapabilities.filterCollectionLinks(capabilities.links ? capabilities.links : [], CollectionLinkType.Styles);
+            const datasetLink = datasetLinks.find(l => l.type === "application/json") || datasetLinks.find(l => !l.type);
+            return datasetLink ? datasetLink.href : capabilities.baseUrl + "styles";
+        }
+        const stylesLinks = OgcOpenApiGetCapabilities.filterCollectionLinks(collection.links, CollectionLinkType.Styles);
+        const link = stylesLinks.find(l => l.type === "application/json") || stylesLinks.find(l => !l.type);
+        if (link) return link.href;
+        const self = collection.links.find(l => l.rel === "self");
+        const collectionHref = self ? self.href : capabilities.baseUrl + "collections/" + collection.id;
+        return OgcOpenApiFetchTools.cleanUrl(collectionHref) + "styles";
+    }
+
+    private static withJsonFormat(href: string) {
+        if (/[?&]f=/.test(href)) return href;
+        return href + (href.indexOf("?") > -1 ? "&" : "?") + "f=json";
+    }
+}
+
+export {
+    OgcOpenApiStyleTools
+}

package/src/OgcOpenApiTileMatrixTools.ts

@@ -0,0 +1,111 @@
+import {Bounds} from "@luciad/ria/shape/Bounds.js";
+import {CoordinateReference} from "@luciad/ria/reference/CoordinateReference.js";
+import type {TileCoordinate} from "@luciad/ria/model/tileset/TileCoordinate.js";
+import {getReference} from "@luciad/ria/reference/ReferenceProvider.js";
+import {createBounds} from "@luciad/ria/shape/ShapeFactory.js";
+import {OgcOpenApiCrsTools} from "./OgcOpenApiCrsTools.js";
+import {OgcOpenApiGetCapabilities, type TileMatrix, type TileSetData} from "./OgcOpenApiGetCapabilities.js";
+
+/**
+ * The part of an OGC TileMatrixSet that LuciadRIA can address as a quad-tree:
+ * LuciadRIA level 0 maps to tileMatrices[levelOffset].
+ */
+export interface OgcOpenApiTileGrid {
+    reference: CoordinateReference;
+    bounds: Bounds;
+    levelOffset: number;
+    levelCount: number;
+    level0Columns: number;
+    level0Rows: number;
+    tileWidth: number;
+    tileHeight: number;
+    tileMatrices: TileMatrix[];
+}
+
+class OgcOpenApiTileMatrixTools {
+
+    public static createTileGrid(tileSet: TileSetData): OgcOpenApiTileGrid {
+        if (!tileSet.tileMatrices || tileSet.tileMatrices.length === 0) {
+            throw new Error("TileMatrixSet " + tileSet.id + " has no tileMatrices");
+        }
+        const reference = getReference(OgcOpenApiCrsTools.getReferenceName(tileSet.crs));
+        const levelOffset = OgcOpenApiGetCapabilities.getQuadTreeCompatibleLevelOffset(tileSet);
+        const tileMatrices = tileSet.tileMatrices.slice(levelOffset);
+        const tm0 = tileMatrices[0];
+        return {
+            reference,
+            bounds: OgcOpenApiTileMatrixTools.getTileMatrixBounds(reference, tileSet, tm0),
+            levelOffset,
+            levelCount: tileMatrices.length,
+            level0Columns: tm0.matrixWidth,
+            level0Rows: tm0.matrixHeight,
+            tileWidth: tm0.tileWidth,
+            tileHeight: tm0.tileHeight,
+            tileMatrices
+        };
+    }
+
+    /**
+     * Resolves {tileMatrix}, {tileRow} and {tileCol} for a LuciadRIA tile. LuciadRIA counts rows
+     * bottom-up, OGC counts them from the cornerOfOrigin (topLeft by default).
+     */
+    public static resolveTileTemplate(template: string, grid: OgcOpenApiTileGrid, tile: TileCoordinate): string | null {
+        const ogcTile = OgcOpenApiTileMatrixTools.getOgcTile(grid, tile);
+        if (ogcTile === null) return null;
+        return template
+            .replace("{tileMatrix}", ogcTile.tileMatrix)
+            .replace("{tileRow}", ogcTile.tileRow.toString())
+            .replace("{tileCol}", ogcTile.tileCol.toString());
+    }
+
+    public static getOgcTile(grid: OgcOpenApiTileGrid, tile: TileCoordinate): { tileMatrix: string, tileRow: number, tileCol: number } | null {
+        const tileMatrix = grid.tileMatrices[tile.level];
+        if (!tileMatrix) return null;
+        const tileRow = OgcOpenApiTileMatrixTools.isBottomLeft(tileMatrix) ? tile.y : tileMatrix.matrixHeight - 1 - tile.y;
+        return {tileMatrix: tileMatrix.id, tileRow, tileCol: tile.x};
+    }
+
+    // The inverse of getOgcTile, null when the tile matrix is not part of the grid
+    public static getLuciadTile(grid: OgcOpenApiTileGrid, tileMatrixId: string, tileRow: number, tileCol: number): TileCoordinate | null {
+        const level = grid.tileMatrices.findIndex(m => m.id === tileMatrixId);
+        if (level < 0) return null;
+        const tileMatrix = grid.tileMatrices[level];
+        const y = OgcOpenApiTileMatrixTools.isBottomLeft(tileMatrix) ? tileRow : tileMatrix.matrixHeight - 1 - tileRow;
+        return {level, x: tileCol, y};
+    }
+
+    public static appendQueryParameters(url: string, parameters: { [key: string]: string | number | boolean | undefined }): string {
+        const query = Object.keys(parameters)
+            .filter(k => parameters[k] !== undefined && parameters[k] !== null)
+            .map(k => encodeURIComponent(k) + "=" + encodeURIComponent(String(parameters[k])))
+            .join("&");
+        if (query === "") return url;
+        return url + (url.indexOf("?") > -1 ? "&" : "?") + query;
+    }
+
+    private static isBottomLeft(tileMatrix: TileMatrix) {
+        return typeof tileMatrix.cornerOfOrigin === "string" && tileMatrix.cornerOfOrigin.toUpperCase() === "BOTTOMLEFT";
+    }
+
+    // The grid extent follows from the origin and cell size, pointOfOrigin is given in orderedAxes order.
+    private static getTileMatrixBounds(reference: CoordinateReference, tileSet: TileSetData, tileMatrix: TileMatrix): Bounds {
+        const swap = OgcOpenApiTileMatrixTools.isFirstAxisNorthing(tileSet.orderedAxes);
+        const originX = tileMatrix.pointOfOrigin[swap ? 1 : 0];
+        const originY = tileMatrix.pointOfOrigin[swap ? 0 : 1];
+        const width = tileMatrix.cellSize * tileMatrix.tileWidth * tileMatrix.matrixWidth;
+        const height = tileMatrix.cellSize * tileMatrix.tileHeight * tileMatrix.matrixHeight;
+        const minY = OgcOpenApiTileMatrixTools.isBottomLeft(tileMatrix) ? originY : originY - height;
+        return createBounds(reference, [originX, width, minY, height]);
+    }
+
+    private static isFirstAxisNorthing(orderedAxes: string[] | undefined) {
+        if (!orderedAxes || orderedAxes.length === 0) return false;
+        const axis = orderedAxes[0].toUpperCase();
+        // EPSG:3035 names its northing Y and its easting X, with Y first
+        return ["LAT", "LATITUDE", "N", "S", "Y", "NORTHING"].indexOf(axis) > -1;
+    }
+}
+
+export {
+    OgcOpenApiTileMatrixTools
+}