@npm9912/v-map 0.1.0

package/dist/collection/map-provider/geotiff/geotiff-source.js

@@ -0,0 +1,172 @@
+import { log, warn } from "../../utils/logger";
+//const DEFAULT_TO_PROJECTION = 'EPSG:3857';
+export async function loadGeoTIFFSource(url, options, deps) {
+    const { geotiff, proj4, geokeysToProj4 } = deps;
+    const { fromUrl } = geotiff;
+    const { toProj4 } = geokeysToProj4;
+    let tiff = null;
+    let lasterr = null;
+    for (let i = 0; i <= 2; i++) {
+        try {
+            tiff = await fromUrl(url, {
+                allowFullFile: true,
+                blockSize: 1024 * 1024, // 1MB blocks to reduce HTTP range-request count for non-COG files
+                cacheSize: 100,
+            });
+        }
+        catch (err) {
+            lasterr = err;
+        }
+        if (tiff != null) {
+            lasterr = null;
+            break;
+        }
+    }
+    if (lasterr != null) {
+        log(lasterr);
+        warn('Error - loadGeoTIFFSource - fromUrl: ', url);
+        throw lasterr;
+    }
+    const baseImage = await tiff.getImage(0);
+    const imageCount = await tiff.getImageCount();
+    const overviewImages = [];
+    for (let i = 1; i < imageCount; i++) {
+        overviewImages.push(await tiff.getImage(i));
+    }
+    const width = baseImage.getWidth();
+    const height = baseImage.getHeight();
+    const samplesPerPixel = Math.max(1, baseImage.getSamplesPerPixel?.() ?? 1);
+    let fromProjection = options.forceProjection && options.projection
+        ? options.projection
+        : options.projection ?? 'EPSG:4326';
+    let proj4String = null;
+    if (!options.forceProjection) {
+        const geoKeys = typeof baseImage.getGeoKeys === 'function'
+            ? baseImage.getGeoKeys() ?? null
+            : null;
+        if (geoKeys) {
+            try {
+                const projParams = toProj4(geoKeys);
+                const epsg = geoKeys.ProjectedCSTypeGeoKey ?? geoKeys.GeographicTypeGeoKey;
+                if (epsg) {
+                    fromProjection = `EPSG:${epsg}`;
+                }
+                if (projParams?.proj4) {
+                    proj4String = projParams.proj4;
+                    const numericCode = String(epsg);
+                    if (epsg && !proj4.defs(fromProjection)) {
+                        proj4.defs(fromProjection, projParams.proj4);
+                    }
+                    if (epsg && !proj4.defs(numericCode)) {
+                        proj4.defs(numericCode, projParams.proj4);
+                    }
+                }
+            }
+            catch (err) {
+                warn('v-map - geotiff - failed to parse GeoKeys', err);
+            }
+        }
+    }
+    if (!proj4String) {
+        switch (fromProjection) {
+            case 'EPSG:4326':
+                proj4String = '+proj=longlat +datum=WGS84 +no_defs';
+                break;
+            case 'EPSG:3857':
+                proj4String =
+                    '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs';
+                break;
+            case 'EPSG:32632':
+                proj4String = '+proj=utm +zone=32 +datum=WGS84 +units=m +no_defs';
+                break;
+        }
+    }
+    if (!fromProjection || fromProjection.trim() === '') {
+        fromProjection = 'EPSG:4326';
+    }
+    if (proj4String && !proj4.defs(fromProjection)) {
+        proj4.defs(fromProjection, proj4String);
+    }
+    const sourceBounds = baseImage.getBoundingBox();
+    const sourceRef = [sourceBounds[0], sourceBounds[1]];
+    const resolution = baseImage.getResolution()[0];
+    const rawNoData = options.nodata !== undefined && options.nodata !== null
+        ? Number(options.nodata)
+        : typeof baseImage.getGDALNoData === 'function'
+            ? baseImage.getGDALNoData()
+            : undefined;
+    const noDataValue = rawNoData !== undefined && rawNoData !== null
+        ? Number(rawNoData)
+        : undefined;
+    const clampLon = (lon) => Math.max(-180, Math.min(180, Number.isFinite(lon) ? lon : 0));
+    const clampLat = (lat) => Math.max(-90, Math.min(90, Number.isFinite(lat) ? lat : 0));
+    let transformToWgs84;
+    if (!fromProjection || fromProjection === 'EPSG:4326') {
+        transformToWgs84 = coord => coord;
+    }
+    else {
+        transformToWgs84 = (coord) => {
+            try {
+                const result = proj4(fromProjection, 'EPSG:4326', coord);
+                return [Number(result[0]), Number(result[1])];
+            }
+            catch (err) {
+                warn('v-map - geotiff - transform to WGS84 failed, falling back', err);
+                return coord;
+            }
+        };
+    }
+    const [minX, minY, maxX, maxY] = sourceBounds;
+    const corners = [
+        transformToWgs84([minX, minY]),
+        transformToWgs84([maxX, minY]),
+        transformToWgs84([maxX, maxY]),
+        transformToWgs84([minX, maxY]),
+    ];
+    const west = clampLon(Math.min(...corners.map(c => c[0])));
+    const east = clampLon(Math.max(...corners.map(c => c[0])));
+    const south = clampLat(Math.min(...corners.map(c => c[1])));
+    const north = clampLat(Math.max(...corners.map(c => c[1])));
+    log('v-map - geotiff - loaded source', {
+        url,
+        width,
+        height,
+        samplesPerPixel,
+        fromProjection,
+        bounds: sourceBounds,
+    });
+    return {
+        tiff,
+        baseImage,
+        overviewImages,
+        width,
+        height,
+        samplesPerPixel,
+        fromProjection,
+        //toProjection: DEFAULT_TO_PROJECTION,
+        sourceBounds,
+        sourceRef,
+        resolution,
+        proj4,
+        noDataValue,
+        wgs84Bounds: [west, south, east, north],
+        transformToWgs84,
+    };
+}
+export async function getGeoTIFFSource(url, projection, forceProjection, nodata) {
+    const [geotiffModule, { default: proj4 }, geokeysModule] = await Promise.all([
+        import('geotiff'),
+        import('proj4'),
+        import('geotiff-geokeys-to-proj4'),
+    ]);
+    const source = await loadGeoTIFFSource(url, {
+        projection: projection,
+        forceProjection: forceProjection,
+        nodata: nodata,
+    }, {
+        geotiff: geotiffModule,
+        proj4,
+        geokeysToProj4: geokeysModule,
+    });
+    return source;
+}

package/dist/collection/map-provider/geotiff/utils/AABB2D.js

@@ -0,0 +1,24 @@
+export class AABB2D {
+    min;
+    max;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+    }
+    contains(point) {
+        return (point.x >= this.min.x &&
+            point.x <= this.max.x &&
+            point.y >= this.min.y &&
+            point.y <= this.max.y);
+    }
+    static fromTriangle(triangle) {
+        const minX = Math.min(triangle.a.x, triangle.b.x, triangle.c.x);
+        const minY = Math.min(triangle.a.y, triangle.b.y, triangle.c.y);
+        const maxX = Math.max(triangle.a.x, triangle.b.x, triangle.c.x);
+        const maxY = Math.max(triangle.a.y, triangle.b.y, triangle.c.y);
+        return new AABB2D({ x: minX, y: minY }, { x: maxX, y: maxY });
+    }
+    static union(a, b) {
+        return new AABB2D({ x: Math.min(a.min.x, b.min.x), y: Math.min(a.min.y, b.min.y) }, { x: Math.max(a.max.x, b.max.x), y: Math.max(a.max.y, b.max.y) });
+    }
+}

package/dist/collection/map-provider/geotiff/utils/BVHNode2D.js

@@ -0,0 +1,166 @@
+import { AABB2D } from "./AABB2D";
+export class BVHNode2D {
+    bbox;
+    triangles;
+    left;
+    right;
+    constructor(bbox, triangles = [], left = null, right = null) {
+        this.bbox = bbox;
+        this.triangles = triangles;
+        this.left = left;
+        this.right = right;
+    }
+    static build(triangles, depth = 0, maxDepth = 10) {
+        if (triangles.length <= 2 || depth >= maxDepth) {
+            let bbox = AABB2D.fromTriangle(triangles[0]);
+            for (let i = 1; i < triangles.length; i++) {
+                bbox = AABB2D.union(bbox, AABB2D.fromTriangle(triangles[i]));
+            }
+            return new BVHNode2D(bbox, triangles);
+        }
+        const centroids = triangles.map(t => ({
+            x: (t.a.x + t.b.x + t.c.x) / 3,
+            y: (t.a.y + t.b.y + t.c.y) / 3,
+        }));
+        const { min, max } = centroids.reduce((acc, c) => ({
+            min: { x: Math.min(acc.min.x, c.x), y: Math.min(acc.min.y, c.y) },
+            max: { x: Math.max(acc.max.x, c.x), y: Math.max(acc.max.y, c.y) },
+        }), { min: centroids[0], max: centroids[0] });
+        const axis = max.x - min.x > max.y - min.y ? 'x' : 'y';
+        centroids.sort((a, b) => a[axis] - b[axis]);
+        const mid = Math.floor(centroids.length / 2);
+        const leftTriangles = [];
+        const rightTriangles = [];
+        for (let i = 0; i < triangles.length; i++) {
+            (i < mid ? leftTriangles : rightTriangles).push(triangles[i]);
+        }
+        const left = BVHNode2D.build(leftTriangles, depth + 1, maxDepth);
+        const right = BVHNode2D.build(rightTriangles, depth + 1, maxDepth);
+        const bbox = AABB2D.union(left.bbox, right.bbox);
+        return new BVHNode2D(bbox, [], left, right);
+    }
+    /**
+     * Finds the triangle containing the given point.
+     * @param point The point to test.
+     * @returns The containing triangle or `null`.
+     */
+    findContainingTriangle(point) {
+        if (!this.bbox.contains(point)) {
+            return null;
+        }
+        if (this.triangles.length > 0) {
+            for (const triangle of this.triangles) {
+                if (BVHNode2D.punktInDreieck2D(point, triangle)) {
+                    return triangle;
+                }
+            }
+            return null;
+        }
+        return (this.left?.findContainingTriangle(point) ||
+            this.right?.findContainingTriangle(point) ||
+            null);
+    }
+    static punktInDreieck2D(p, triangle) {
+        const { a, b, c } = triangle;
+        const v0 = { x: c.x - a.x, y: c.y - a.y };
+        const v1 = { x: b.x - a.x, y: b.y - a.y };
+        const v2 = { x: p.x - a.x, y: p.y - a.y };
+        const dot00 = v0.x * v0.x + v0.y * v0.y;
+        const dot01 = v0.x * v1.x + v0.y * v1.y;
+        const dot02 = v0.x * v2.x + v0.y * v2.y;
+        const dot11 = v1.x * v1.x + v1.y * v1.y;
+        const dot12 = v1.x * v2.x + v1.y * v2.y;
+        const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
+        const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+        const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+        return u >= 0 && v >= 0 && u + v <= 1;
+        //return u >= 0 && v >= 0 && u + v < 1;
+    }
+    static toTriangle2D(triangle) {
+        return {
+            a: { x: triangle.target[0][0], y: triangle.target[0][1] },
+            b: { x: triangle.target[1][0], y: triangle.target[1][1] },
+            c: { x: triangle.target[2][0], y: triangle.target[2][1] },
+            triangle: triangle,
+            transform: null,
+        };
+    }
+    /**
+     * Returns a string representation of the BVH tree structure
+     * @param indent - Internal parameter for recursive formatting
+     * @returns Formatted string showing tree structure
+     */
+    toString(indent = '') {
+        const isLeaf = this.triangles.length > 0;
+        const nodeType = isLeaf ? 'LEAF' : 'NODE';
+        const bboxStr = `[${this.bbox.min.x.toFixed(2)}, ${this.bbox.min.y.toFixed(2)}, ${this.bbox.max.x.toFixed(2)}, ${this.bbox.max.y.toFixed(2)}]`;
+        let result = `${indent}${nodeType} bbox=${bboxStr}`;
+        if (isLeaf) {
+            const triArray = this.triangles.map(t2D => t2D.a.x.toFixed(2) +
+                ',' +
+                t2D.a.y.toFixed(2) +
+                ' ' +
+                t2D.b.x.toFixed(2) +
+                ',' +
+                t2D.b.y.toFixed(2) +
+                ' ' +
+                t2D.c.x.toFixed(2) +
+                ',' +
+                t2D.c.y.toFixed(2));
+            const triArrayStr = triArray.toString();
+            result += ` triangles=${this.triangles.length} - ${triArrayStr}`;
+        }
+        else {
+            result += '\n';
+            if (this.left) {
+                result += `${indent}├─ left:\n${this.left.toString(indent + '│  ')}`;
+            }
+            if (this.right) {
+                result += `${indent}└─ right:\n${this.right.toString(indent + '   ')}`;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get statistics about the BVH tree
+     * @returns Object with tree statistics
+     */
+    getStats() {
+        const stats = {
+            depth: 1,
+            nodeCount: 1,
+            leafCount: 0,
+            triangleCount: this.triangles.length,
+            minTrianglesPerLeaf: Infinity,
+            maxTrianglesPerLeaf: 0,
+        };
+        if (this.triangles.length > 0) {
+            // This is a leaf
+            stats.leafCount = 1;
+            stats.minTrianglesPerLeaf = this.triangles.length;
+            stats.maxTrianglesPerLeaf = this.triangles.length;
+        }
+        else {
+            // This is an internal node
+            if (this.left) {
+                const leftStats = this.left.getStats();
+                stats.depth = Math.max(stats.depth, leftStats.depth + 1);
+                stats.nodeCount += leftStats.nodeCount;
+                stats.leafCount += leftStats.leafCount;
+                stats.triangleCount += leftStats.triangleCount;
+                stats.minTrianglesPerLeaf = Math.min(stats.minTrianglesPerLeaf, leftStats.minTrianglesPerLeaf);
+                stats.maxTrianglesPerLeaf = Math.max(stats.maxTrianglesPerLeaf, leftStats.maxTrianglesPerLeaf);
+            }
+            if (this.right) {
+                const rightStats = this.right.getStats();
+                stats.depth = Math.max(stats.depth, rightStats.depth + 1);
+                stats.nodeCount += rightStats.nodeCount;
+                stats.leafCount += rightStats.leafCount;
+                stats.triangleCount += rightStats.triangleCount;
+                stats.minTrianglesPerLeaf = Math.min(stats.minTrianglesPerLeaf, rightStats.minTrianglesPerLeaf);
+                stats.maxTrianglesPerLeaf = Math.max(stats.maxTrianglesPerLeaf, rightStats.maxTrianglesPerLeaf);
+            }
+        }
+        return stats;
+    }
+}