@loaders.gl/raster 0.0.0-stage → 5.0.0-alpha.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +52 -0
- package/README.md +60 -2
- package/dist/geotiff/advanced.cjs +1955 -0
- package/dist/geotiff/advanced.cjs.map +7 -0
- package/dist/geotiff/advanced.d.ts +13 -0
- package/dist/geotiff/advanced.d.ts.map +1 -0
- package/dist/geotiff/advanced.js +12 -0
- package/dist/geotiff/advanced.js.map +1 -0
- package/dist/geotiff/bundled.d.ts +3 -0
- package/dist/geotiff/bundled.d.ts.map +1 -0
- package/dist/geotiff/bundled.js +5 -0
- package/dist/geotiff/bundled.js.map +1 -0
- package/dist/geotiff/discover-geotiff.d.ts +14 -0
- package/dist/geotiff/discover-geotiff.d.ts.map +1 -0
- package/dist/geotiff/discover-geotiff.js +63 -0
- package/dist/geotiff/discover-geotiff.js.map +1 -0
- package/dist/geotiff/geotiff-format.d.ts +21 -0
- package/dist/geotiff/geotiff-format.d.ts.map +1 -0
- package/dist/geotiff/geotiff-format.js +24 -0
- package/dist/geotiff/geotiff-format.js.map +1 -0
- package/dist/geotiff/geotiff-loader-types.d.ts +63 -0
- package/dist/geotiff/geotiff-loader-types.d.ts.map +1 -0
- package/dist/geotiff/geotiff-loader-types.js +26 -0
- package/dist/geotiff/geotiff-loader-types.js.map +1 -0
- package/dist/geotiff/geotiff-loader.d.ts +49 -0
- package/dist/geotiff/geotiff-loader.d.ts.map +1 -0
- package/dist/geotiff/geotiff-loader.js +70 -0
- package/dist/geotiff/geotiff-loader.js.map +1 -0
- package/dist/geotiff/geotiff-raster-loader-types.d.ts +37 -0
- package/dist/geotiff/geotiff-raster-loader-types.d.ts.map +1 -0
- package/dist/geotiff/geotiff-raster-loader-types.js +24 -0
- package/dist/geotiff/geotiff-raster-loader-types.js.map +1 -0
- package/dist/geotiff/geotiff-raster-loader.d.ts +22 -0
- package/dist/geotiff/geotiff-raster-loader.d.ts.map +1 -0
- package/dist/geotiff/geotiff-raster-loader.js +65 -0
- package/dist/geotiff/geotiff-raster-loader.js.map +1 -0
- package/dist/geotiff/geotiff-raster-types.d.ts +65 -0
- package/dist/geotiff/geotiff-raster-types.d.ts.map +1 -0
- package/dist/geotiff/geotiff-raster-types.js +5 -0
- package/dist/geotiff/geotiff-raster-types.js.map +1 -0
- package/dist/geotiff/geotiff-source-loader-types.d.ts +67 -0
- package/dist/geotiff/geotiff-source-loader-types.d.ts.map +1 -0
- package/dist/geotiff/geotiff-source-loader-types.js +43 -0
- package/dist/geotiff/geotiff-source-loader-types.js.map +1 -0
- package/dist/geotiff/geotiff-source-loader.d.ts +132 -0
- package/dist/geotiff/geotiff-source-loader.d.ts.map +1 -0
- package/dist/geotiff/geotiff-source-loader.js +1322 -0
- package/dist/geotiff/geotiff-source-loader.js.map +1 -0
- package/dist/geotiff/index.d.ts +3 -0
- package/dist/geotiff/index.d.ts.map +1 -0
- package/dist/geotiff/index.js +6 -0
- package/dist/geotiff/index.js.map +1 -0
- package/dist/geotiff/lib/load-geotiff.d.ts +28 -0
- package/dist/geotiff/lib/load-geotiff.d.ts.map +1 -0
- package/dist/geotiff/lib/load-geotiff.js +61 -0
- package/dist/geotiff/lib/load-geotiff.js.map +1 -0
- package/dist/geotiff/lib/ome/load-ome-tiff.d.ts +50 -0
- package/dist/geotiff/lib/ome/load-ome-tiff.d.ts.map +1 -0
- package/dist/geotiff/lib/ome/load-ome-tiff.js +42 -0
- package/dist/geotiff/lib/ome/load-ome-tiff.js.map +1 -0
- package/dist/geotiff/lib/ome/ome-indexers.d.ts +12 -0
- package/dist/geotiff/lib/ome/ome-indexers.d.ts.map +1 -0
- package/dist/geotiff/lib/ome/ome-indexers.js +109 -0
- package/dist/geotiff/lib/ome/ome-indexers.js.map +1 -0
- package/dist/geotiff/lib/ome/ome-utils.d.ts +32 -0
- package/dist/geotiff/lib/ome/ome-utils.d.ts.map +1 -0
- package/dist/geotiff/lib/ome/ome-utils.js +67 -0
- package/dist/geotiff/lib/ome/ome-utils.js.map +1 -0
- package/dist/geotiff/lib/ome/omexml.d.ts +49 -0
- package/dist/geotiff/lib/ome/omexml.d.ts.map +1 -0
- package/dist/geotiff/lib/ome/omexml.js +63 -0
- package/dist/geotiff/lib/ome/omexml.js.map +1 -0
- package/dist/geotiff/lib/ome/utils.d.ts +7 -0
- package/dist/geotiff/lib/ome/utils.d.ts.map +1 -0
- package/dist/geotiff/lib/ome/utils.js +29 -0
- package/dist/geotiff/lib/ome/utils.js.map +1 -0
- package/dist/geotiff/lib/tiff/decode-tiff-samples.d.ts +34 -0
- package/dist/geotiff/lib/tiff/decode-tiff-samples.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/decode-tiff-samples.js +150 -0
- package/dist/geotiff/lib/tiff/decode-tiff-samples.js.map +1 -0
- package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.d.ts +4 -0
- package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.js +88 -0
- package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.js.map +1 -0
- package/dist/geotiff/lib/tiff/geotiff-source-adapter.d.ts +4 -0
- package/dist/geotiff/lib/tiff/geotiff-source-adapter.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/geotiff-source-adapter.js +51 -0
- package/dist/geotiff/lib/tiff/geotiff-source-adapter.js.map +1 -0
- package/dist/geotiff/lib/tiff/plan-tiff-blocks.d.ts +10 -0
- package/dist/geotiff/lib/tiff/plan-tiff-blocks.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/plan-tiff-blocks.js +101 -0
- package/dist/geotiff/lib/tiff/plan-tiff-blocks.js.map +1 -0
- package/dist/geotiff/lib/tiff/read-tiff-directory.d.ts +8 -0
- package/dist/geotiff/lib/tiff/read-tiff-directory.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/read-tiff-directory.js +219 -0
- package/dist/geotiff/lib/tiff/read-tiff-directory.js.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-gdal-metadata.d.ts +8 -0
- package/dist/geotiff/lib/tiff/tiff-gdal-metadata.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-gdal-metadata.js +50 -0
- package/dist/geotiff/lib/tiff/tiff-gdal-metadata.js.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-metadata.d.ts +5 -0
- package/dist/geotiff/lib/tiff/tiff-metadata.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-metadata.js +188 -0
- package/dist/geotiff/lib/tiff/tiff-metadata.js.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-numeric-decoder.d.ts +40 -0
- package/dist/geotiff/lib/tiff/tiff-numeric-decoder.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-numeric-decoder.js +40 -0
- package/dist/geotiff/lib/tiff/tiff-numeric-decoder.js.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-source-decoder.d.ts +103 -0
- package/dist/geotiff/lib/tiff/tiff-source-decoder.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-source-decoder.js +5 -0
- package/dist/geotiff/lib/tiff/tiff-source-decoder.js.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-types.d.ts +49 -0
- package/dist/geotiff/lib/tiff/tiff-types.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff/tiff-types.js +5 -0
- package/dist/geotiff/lib/tiff/tiff-types.js.map +1 -0
- package/dist/geotiff/lib/tiff-pixel-source.d.ts +17 -0
- package/dist/geotiff/lib/tiff-pixel-source.d.ts.map +1 -0
- package/dist/geotiff/lib/tiff-pixel-source.js +71 -0
- package/dist/geotiff/lib/tiff-pixel-source.js.map +1 -0
- package/dist/geotiff/lib/utils/tiff-utils.d.ts +10 -0
- package/dist/geotiff/lib/utils/tiff-utils.d.ts.map +1 -0
- package/dist/geotiff/lib/utils/tiff-utils.js +41 -0
- package/dist/geotiff/lib/utils/tiff-utils.js.map +1 -0
- package/dist/geotiff/loaders.d.ts +30 -0
- package/dist/geotiff/loaders.d.ts.map +1 -0
- package/dist/geotiff/loaders.js +53 -0
- package/dist/geotiff/loaders.js.map +1 -0
- package/dist/geotiff/ometiff-source-loader-types.d.ts +67 -0
- package/dist/geotiff/ometiff-source-loader-types.d.ts.map +1 -0
- package/dist/geotiff/ometiff-source-loader-types.js +38 -0
- package/dist/geotiff/ometiff-source-loader-types.js.map +1 -0
- package/dist/geotiff/ometiff-source-loader.d.ts +152 -0
- package/dist/geotiff/ometiff-source-loader.d.ts.map +1 -0
- package/dist/geotiff/ometiff-source-loader.js +256 -0
- package/dist/geotiff/ometiff-source-loader.js.map +1 -0
- package/dist/geotiff/types.d.ts +75 -0
- package/dist/geotiff/types.d.ts.map +1 -0
- package/dist/geotiff/types.js +5 -0
- package/dist/geotiff/types.js.map +1 -0
- package/dist/geotiff/unbundled.d.ts +3 -0
- package/dist/geotiff/unbundled.d.ts.map +1 -0
- package/dist/geotiff/unbundled.js +5 -0
- package/dist/geotiff/unbundled.js.map +1 -0
- package/dist/index.cjs +523 -0
- package/dist/index.cjs.map +7 -0
- package/dist/index.d.ts +29 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +19 -0
- package/dist/index.js.map +1 -0
- package/dist/lerc/bundled.d.ts +3 -0
- package/dist/lerc/bundled.d.ts.map +1 -0
- package/dist/lerc/bundled.js +5 -0
- package/dist/lerc/bundled.js.map +1 -0
- package/dist/lerc/index.d.ts +6 -0
- package/dist/lerc/index.d.ts.map +1 -0
- package/dist/lerc/index.js +9 -0
- package/dist/lerc/index.js.map +1 -0
- package/dist/lerc/lerc-format.d.ts +11 -0
- package/dist/lerc/lerc-format.d.ts.map +1 -0
- package/dist/lerc/lerc-format.js +14 -0
- package/dist/lerc/lerc-format.js.map +1 -0
- package/dist/lerc/lerc-loader-types.d.ts +54 -0
- package/dist/lerc/lerc-loader-types.d.ts.map +1 -0
- package/dist/lerc/lerc-loader-types.js +31 -0
- package/dist/lerc/lerc-loader-types.js.map +1 -0
- package/dist/lerc/lerc-loader.d.ts +36 -0
- package/dist/lerc/lerc-loader.d.ts.map +1 -0
- package/dist/lerc/lerc-loader.js +22 -0
- package/dist/lerc/lerc-loader.js.map +1 -0
- package/dist/lerc/lerc-wasm-url.d.ts +3 -0
- package/dist/lerc/lerc-wasm-url.d.ts.map +1 -0
- package/dist/lerc/lerc-wasm-url.js +8 -0
- package/dist/lerc/lerc-wasm-url.js.map +1 -0
- package/dist/lerc/lib/parsers/lerc/lerc-types.d.ts +30 -0
- package/dist/lerc/lib/parsers/lerc/lerc-types.d.ts.map +1 -0
- package/dist/lerc/lib/parsers/lerc/lerc-types.js +5 -0
- package/dist/lerc/lib/parsers/lerc/lerc-types.js.map +1 -0
- package/dist/lerc/libs/lerc/LICENSE +101 -0
- package/dist/lerc/libs/lerc/NOTICE +23 -0
- package/dist/lerc/libs/lerc/lerc-wasm.wasm +0 -0
- package/dist/lerc/unbundled.d.ts +3 -0
- package/dist/lerc/unbundled.d.ts.map +1 -0
- package/dist/lerc/unbundled.js +5 -0
- package/dist/lerc/unbundled.js.map +1 -0
- package/dist/lerc/workers/lerc-worker.d.ts +2 -0
- package/dist/lerc/workers/lerc-worker.d.ts.map +1 -0
- package/dist/lerc/workers/lerc-worker.js +7 -0
- package/dist/lerc/workers/lerc-worker.js.map +1 -0
- package/dist/quantized-mesh-worker.js +17315 -0
- package/dist/quantized-mesh.d.ts +2 -0
- package/dist/quantized-mesh.d.ts.map +1 -0
- package/dist/quantized-mesh.js +5 -0
- package/dist/quantized-mesh.js.map +1 -0
- package/dist/terrain/bundled.d.ts +5 -0
- package/dist/terrain/bundled.d.ts.map +1 -0
- package/dist/terrain/bundled.js +6 -0
- package/dist/terrain/bundled.js.map +1 -0
- package/dist/terrain/heightmap.cjs +397 -0
- package/dist/terrain/heightmap.cjs.map +7 -0
- package/dist/terrain/heightmap.d.ts +8 -0
- package/dist/terrain/heightmap.d.ts.map +1 -0
- package/dist/terrain/heightmap.js +8 -0
- package/dist/terrain/heightmap.js.map +1 -0
- package/dist/terrain/index.cjs +1406 -0
- package/dist/terrain/index.cjs.map +7 -0
- package/dist/terrain/index.d.ts +18 -0
- package/dist/terrain/index.d.ts.map +1 -0
- package/dist/terrain/index.js +16 -0
- package/dist/terrain/index.js.map +1 -0
- package/dist/terrain/lib/decode-quantized-mesh.d.ts +59 -0
- package/dist/terrain/lib/decode-quantized-mesh.d.ts.map +1 -0
- package/dist/terrain/lib/decode-quantized-mesh.js +227 -0
- package/dist/terrain/lib/decode-quantized-mesh.js.map +1 -0
- package/dist/terrain/lib/decode-terrain-heightmap.d.ts +16 -0
- package/dist/terrain/lib/decode-terrain-heightmap.d.ts.map +1 -0
- package/dist/terrain/lib/decode-terrain-heightmap.js +52 -0
- package/dist/terrain/lib/decode-terrain-heightmap.js.map +1 -0
- package/dist/terrain/lib/delatin/index.d.ts +24 -0
- package/dist/terrain/lib/delatin/index.d.ts.map +1 -0
- package/dist/terrain/lib/delatin/index.js +409 -0
- package/dist/terrain/lib/delatin/index.js.map +1 -0
- package/dist/terrain/lib/helpers/skirt.d.ts +19 -0
- package/dist/terrain/lib/helpers/skirt.d.ts.map +1 -0
- package/dist/terrain/lib/helpers/skirt.js +127 -0
- package/dist/terrain/lib/helpers/skirt.js.map +1 -0
- package/dist/terrain/lib/parse-quantized-mesh.d.ts +15 -0
- package/dist/terrain/lib/parse-quantized-mesh.d.ts.map +1 -0
- package/dist/terrain/lib/parse-quantized-mesh.js +86 -0
- package/dist/terrain/lib/parse-quantized-mesh.js.map +1 -0
- package/dist/terrain/lib/parse-terrain.d.ts +32 -0
- package/dist/terrain/lib/parse-terrain.d.ts.map +1 -0
- package/dist/terrain/lib/parse-terrain.js +150 -0
- package/dist/terrain/lib/parse-terrain.js.map +1 -0
- package/dist/terrain/lib/terrain-contracts.d.ts +58 -0
- package/dist/terrain/lib/terrain-contracts.d.ts.map +1 -0
- package/dist/terrain/lib/terrain-contracts.js +5 -0
- package/dist/terrain/lib/terrain-contracts.js.map +1 -0
- package/dist/terrain/lib/terrain-height-field.d.ts +51 -0
- package/dist/terrain/lib/terrain-height-field.d.ts.map +1 -0
- package/dist/terrain/lib/terrain-height-field.js +260 -0
- package/dist/terrain/lib/terrain-height-field.js.map +1 -0
- package/dist/terrain/lib/terrain-height-grid.d.ts +14 -0
- package/dist/terrain/lib/terrain-height-grid.d.ts.map +1 -0
- package/dist/terrain/lib/terrain-height-grid.js +104 -0
- package/dist/terrain/lib/terrain-height-grid.js.map +1 -0
- package/dist/terrain/lib/terrain-heightmap-types.d.ts +30 -0
- package/dist/terrain/lib/terrain-heightmap-types.d.ts.map +1 -0
- package/dist/terrain/lib/terrain-heightmap-types.js +5 -0
- package/dist/terrain/lib/terrain-heightmap-types.js.map +1 -0
- package/dist/terrain/lib/terrain-neighborhood.d.ts +15 -0
- package/dist/terrain/lib/terrain-neighborhood.d.ts.map +1 -0
- package/dist/terrain/lib/terrain-neighborhood.js +58 -0
- package/dist/terrain/lib/terrain-neighborhood.js.map +1 -0
- package/dist/terrain/lib/utils/version.d.ts +2 -0
- package/dist/terrain/lib/utils/version.d.ts.map +1 -0
- package/dist/terrain/lib/utils/version.js +8 -0
- package/dist/terrain/lib/utils/version.js.map +1 -0
- package/dist/terrain/libs/README.md +10 -0
- package/dist/terrain/libs/martini-LICENSE +15 -0
- package/dist/terrain/libs/martini.d.mts +19 -0
- package/dist/terrain/libs/martini.mjs +164 -0
- package/dist/terrain/quantized-mesh-loader-types.d.ts +18 -0
- package/dist/terrain/quantized-mesh-loader-types.d.ts.map +1 -0
- package/dist/terrain/quantized-mesh-loader-types.js +26 -0
- package/dist/terrain/quantized-mesh-loader-types.js.map +1 -0
- package/dist/terrain/quantized-mesh-loader.d.ts +5 -0
- package/dist/terrain/quantized-mesh-loader.d.ts.map +1 -0
- package/dist/terrain/quantized-mesh-loader.js +31 -0
- package/dist/terrain/quantized-mesh-loader.js.map +1 -0
- package/dist/terrain/quantized-mesh-writer.d.ts +35 -0
- package/dist/terrain/quantized-mesh-writer.d.ts.map +1 -0
- package/dist/terrain/quantized-mesh-writer.js +251 -0
- package/dist/terrain/quantized-mesh-writer.js.map +1 -0
- package/dist/terrain/terrain-format.d.ts +22 -0
- package/dist/terrain/terrain-format.d.ts.map +1 -0
- package/dist/terrain/terrain-format.js +25 -0
- package/dist/terrain/terrain-format.js.map +1 -0
- package/dist/terrain/terrain-loader-types.d.ts +17 -0
- package/dist/terrain/terrain-loader-types.d.ts.map +1 -0
- package/dist/terrain/terrain-loader-types.js +33 -0
- package/dist/terrain/terrain-loader-types.js.map +1 -0
- package/dist/terrain/terrain-loader.d.ts +16 -0
- package/dist/terrain/terrain-loader.d.ts.map +1 -0
- package/dist/terrain/terrain-loader.js +58 -0
- package/dist/terrain/terrain-loader.js.map +1 -0
- package/dist/terrain/unbundled.d.ts +5 -0
- package/dist/terrain/unbundled.d.ts.map +1 -0
- package/dist/terrain/unbundled.js +6 -0
- package/dist/terrain/unbundled.js.map +1 -0
- package/dist/terrain/workers/quantized-mesh-worker.d.ts +2 -0
- package/dist/terrain/workers/quantized-mesh-worker.d.ts.map +1 -0
- package/dist/terrain/workers/quantized-mesh-worker.js +7 -0
- package/dist/terrain/workers/quantized-mesh-worker.js.map +1 -0
- package/dist/terrain/workers/terrain-worker.d.ts +2 -0
- package/dist/terrain/workers/terrain-worker.d.ts.map +1 -0
- package/dist/terrain/workers/terrain-worker.js +7 -0
- package/dist/terrain/workers/terrain-worker.js.map +1 -0
- package/dist/terrain-worker.js +18282 -0
- package/package.json +345 -4
- package/src/geotiff/advanced.ts +29 -0
- package/src/geotiff/bundled.ts +6 -0
- package/src/geotiff/discover-geotiff.ts +70 -0
- package/src/geotiff/geotiff-format.ts +27 -0
- package/src/geotiff/geotiff-loader-types.ts +50 -0
- package/src/geotiff/geotiff-loader.ts +107 -0
- package/src/geotiff/geotiff-raster-loader-types.ts +31 -0
- package/src/geotiff/geotiff-raster-loader.ts +85 -0
- package/src/geotiff/geotiff-raster-types.ts +72 -0
- package/src/geotiff/geotiff-source-loader-types.ts +55 -0
- package/src/geotiff/geotiff-source-loader.ts +1738 -0
- package/src/geotiff/index.ts +6 -0
- package/src/geotiff/lib/load-geotiff.ts +88 -0
- package/src/geotiff/lib/ome/load-ome-tiff.ts +55 -0
- package/src/geotiff/lib/ome/ome-indexers.ts +132 -0
- package/src/geotiff/lib/ome/ome-utils.ts +78 -0
- package/src/geotiff/lib/ome/omexml.ts +183 -0
- package/src/geotiff/lib/ome/utils.ts +43 -0
- package/src/geotiff/lib/tiff/decode-tiff-samples.ts +214 -0
- package/src/geotiff/lib/tiff/geotiff-decoder-adapter.ts +114 -0
- package/src/geotiff/lib/tiff/geotiff-source-adapter.ts +65 -0
- package/src/geotiff/lib/tiff/plan-tiff-blocks.ts +130 -0
- package/src/geotiff/lib/tiff/read-tiff-directory.ts +243 -0
- package/src/geotiff/lib/tiff/tiff-gdal-metadata.ts +59 -0
- package/src/geotiff/lib/tiff/tiff-metadata.ts +204 -0
- package/src/geotiff/lib/tiff/tiff-numeric-decoder.ts +87 -0
- package/src/geotiff/lib/tiff/tiff-source-decoder.ts +112 -0
- package/src/geotiff/lib/tiff/tiff-types.ts +56 -0
- package/src/geotiff/lib/tiff-pixel-source.ts +103 -0
- package/src/geotiff/lib/utils/Pool.ts.disabled +99 -0
- package/src/geotiff/lib/utils/decoder.worker.ts.disabled +21 -0
- package/src/geotiff/lib/utils/proxies.ts.disabled +96 -0
- package/src/geotiff/lib/utils/tiff-utils.ts +49 -0
- package/src/geotiff/loaders.ts +79 -0
- package/src/geotiff/ometiff-source-loader-types.ts +47 -0
- package/src/geotiff/ometiff-source-loader.ts +420 -0
- package/src/geotiff/types.ts +87 -0
- package/src/geotiff/unbundled.ts +6 -0
- package/src/index.ts +57 -0
- package/src/lerc/bundled.ts +6 -0
- package/src/lerc/index.ts +10 -0
- package/src/lerc/lerc-format.ts +16 -0
- package/src/lerc/lerc-loader-types.ts +51 -0
- package/src/lerc/lerc-loader.ts +41 -0
- package/src/lerc/lerc-wasm-url.ts +9 -0
- package/src/lerc/lib/parsers/lerc/lerc-types.ts +45 -0
- package/src/lerc/libs/lerc/LICENSE +101 -0
- package/src/lerc/libs/lerc/NOTICE +23 -0
- package/src/lerc/libs/lerc/lerc-wasm.wasm +0 -0
- package/src/lerc/unbundled.ts +6 -0
- package/src/lerc/workers/lerc-worker.ts +8 -0
- package/src/quantized-mesh.ts +5 -0
- package/src/terrain/bundled.ts +8 -0
- package/src/terrain/heightmap.ts +30 -0
- package/src/terrain/index.ts +41 -0
- package/src/terrain/lib/decode-quantized-mesh.ts +329 -0
- package/src/terrain/lib/decode-terrain-heightmap.ts +68 -0
- package/src/terrain/lib/delatin/index.ts +495 -0
- package/src/terrain/lib/helpers/skirt.ts +172 -0
- package/src/terrain/lib/parse-quantized-mesh.ts +122 -0
- package/src/terrain/lib/parse-terrain.ts +217 -0
- package/src/terrain/lib/terrain-contracts.ts +68 -0
- package/src/terrain/lib/terrain-height-field.ts +355 -0
- package/src/terrain/lib/terrain-height-grid.ts +157 -0
- package/src/terrain/lib/terrain-heightmap-types.ts +35 -0
- package/src/terrain/lib/terrain-neighborhood.ts +69 -0
- package/src/terrain/lib/utils/version.ts +8 -0
- package/src/terrain/libs/README.md +10 -0
- package/src/terrain/libs/martini-LICENSE +15 -0
- package/src/terrain/libs/martini.d.mts +19 -0
- package/src/terrain/libs/martini.mjs +164 -0
- package/src/terrain/quantized-mesh-loader-types.ts +44 -0
- package/src/terrain/quantized-mesh-loader.ts +46 -0
- package/src/terrain/quantized-mesh-writer.ts +380 -0
- package/src/terrain/terrain-format.ts +28 -0
- package/src/terrain/terrain-loader-types.ts +52 -0
- package/src/terrain/terrain-loader.ts +79 -0
- package/src/terrain/unbundled.ts +8 -0
- package/src/terrain/workers/quantized-mesh-worker.ts +8 -0
- package/src/terrain/workers/terrain-worker.ts +8 -0
|
@@ -0,0 +1,1738 @@
|
|
|
1
|
+
// loaders.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
import type {TiffSourceDecoder, TiffSourceImage} from './lib/tiff/tiff-source-decoder';
|
|
6
|
+
import {openGeoTIFFSourceDecoder} from './lib/tiff/geotiff-source-adapter';
|
|
7
|
+
|
|
8
|
+
import type {
|
|
9
|
+
SourceLoader,
|
|
10
|
+
DataSourceOptions,
|
|
11
|
+
TypedArray,
|
|
12
|
+
RasterRegionSource,
|
|
13
|
+
RasterRegionParameters,
|
|
14
|
+
RasterSourceMetadata,
|
|
15
|
+
GetRasterParameters,
|
|
16
|
+
RasterData,
|
|
17
|
+
NumericRasterData,
|
|
18
|
+
RasterMixedData,
|
|
19
|
+
RasterChannelDataType,
|
|
20
|
+
RasterBoundingBox,
|
|
21
|
+
RasterAffineTransform,
|
|
22
|
+
RasterBandMetadata,
|
|
23
|
+
RangeRequestSchedulerProps,
|
|
24
|
+
RangeRequestTransportResult,
|
|
25
|
+
RasterQueryCapabilities,
|
|
26
|
+
ScanQueryMetadata,
|
|
27
|
+
ScanQueryMetadataOptions,
|
|
28
|
+
ScanQueryMetadataProvider
|
|
29
|
+
} from '@loaders.gl/core/loader-utils';
|
|
30
|
+
import type {CRSIdentifier} from '@math.gl/geospatial/crs';
|
|
31
|
+
import {
|
|
32
|
+
createTileGrid,
|
|
33
|
+
createTileGridMatrix,
|
|
34
|
+
DataSource,
|
|
35
|
+
getRasterViewportBoundingBox,
|
|
36
|
+
RangeRequestScheduler,
|
|
37
|
+
RangeRequestCache,
|
|
38
|
+
waitForPromiseWithSignal,
|
|
39
|
+
waitForPromiseWithSignals,
|
|
40
|
+
sampleRaster,
|
|
41
|
+
validateRasterRegion,
|
|
42
|
+
createScanQueryMetadata
|
|
43
|
+
} from '@loaders.gl/core/loader-utils';
|
|
44
|
+
import {GeoTIFFFormat} from './geotiff-format';
|
|
45
|
+
|
|
46
|
+
// __VERSION__ is injected by babel-plugin-version-inline
|
|
47
|
+
// @ts-ignore TS2304: Cannot find name '__VERSION__'.
|
|
48
|
+
const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* Options for creating a GeoTIFF raster source.
|
|
52
|
+
*/
|
|
53
|
+
export type GeoTIFFSourceLoaderOptions = DataSourceOptions & {
|
|
54
|
+
geotiff?: {
|
|
55
|
+
/** Optional request headers forwarded to remote GeoTIFF fetches. */
|
|
56
|
+
headers?: Record<string, string>;
|
|
57
|
+
/** Reject HTTP 206 responses without an exposed Content-Range header; default false. */
|
|
58
|
+
requireContentRange?: boolean;
|
|
59
|
+
/** Settled byte-cache limits; defaults to 128 entries and 8 MiB. Zero disables retention. */
|
|
60
|
+
rangeCacheProps?: {
|
|
61
|
+
/** Maximum retained byte ranges. */
|
|
62
|
+
maxEntries?: number;
|
|
63
|
+
/** Maximum retained encoded bytes. */
|
|
64
|
+
maxBytes?: number;
|
|
65
|
+
};
|
|
66
|
+
/** Default interleave mode for raster reads. */
|
|
67
|
+
interleaved?: boolean;
|
|
68
|
+
/** Default resampling mode for viewport reads. */
|
|
69
|
+
resampleMethod?: 'nearest' | 'bilinear';
|
|
70
|
+
/** Maximum decoded output pixels, default 16 million. */
|
|
71
|
+
maxPixels?: number;
|
|
72
|
+
/** Maximum decoded output bytes, default 256 MiB. */
|
|
73
|
+
maxDecodedBytes?: number;
|
|
74
|
+
/** Optional shared scheduler used for byte-range requests against remote GeoTIFFs. */
|
|
75
|
+
rangeScheduler?: RangeRequestScheduler;
|
|
76
|
+
/** Optional scheduler configuration used when creating a per-source byte-range scheduler. */
|
|
77
|
+
rangeSchedulerProps?: RangeRequestSchedulerProps;
|
|
78
|
+
};
|
|
79
|
+
};
|
|
80
|
+
|
|
81
|
+
/** Common raster-query capabilities of GeoTIFF and COG sources. */
|
|
82
|
+
export const GEOTIFF_RASTER_QUERY_CAPABILITIES: RasterQueryCapabilities = Object.freeze({
|
|
83
|
+
bounds: 'pushdown',
|
|
84
|
+
level: 'pushdown',
|
|
85
|
+
variables: 'pushdown',
|
|
86
|
+
slices: 'unsupported',
|
|
87
|
+
streaming: false,
|
|
88
|
+
cancellation: true
|
|
89
|
+
});
|
|
90
|
+
|
|
91
|
+
/**
|
|
92
|
+
* Source factory for viewport-driven GeoTIFF datasets.
|
|
93
|
+
*/
|
|
94
|
+
export const GeoTIFFSourceLoader = {
|
|
95
|
+
dataType: null as unknown as GeoTIFFRasterSource,
|
|
96
|
+
batchType: null as never,
|
|
97
|
+
...GeoTIFFFormat,
|
|
98
|
+
name: 'GeoTIFFSourceLoader',
|
|
99
|
+
version: VERSION,
|
|
100
|
+
type: 'geotiff',
|
|
101
|
+
fromUrl: true,
|
|
102
|
+
fromBlob: true,
|
|
103
|
+
|
|
104
|
+
options: {
|
|
105
|
+
geotiff: {
|
|
106
|
+
headers: undefined!,
|
|
107
|
+
interleaved: false,
|
|
108
|
+
resampleMethod: 'nearest'
|
|
109
|
+
}
|
|
110
|
+
},
|
|
111
|
+
|
|
112
|
+
defaultOptions: {
|
|
113
|
+
geotiff: {
|
|
114
|
+
headers: undefined!,
|
|
115
|
+
interleaved: false,
|
|
116
|
+
resampleMethod: 'nearest'
|
|
117
|
+
}
|
|
118
|
+
},
|
|
119
|
+
|
|
120
|
+
testURL: (url: string): boolean => {
|
|
121
|
+
if (/\.ome\.tiff?(?:$|[?#])/i.test(url)) {
|
|
122
|
+
return false;
|
|
123
|
+
}
|
|
124
|
+
return /\.(?:geotiff?|tiff?)(?:$|[?#])/i.test(url);
|
|
125
|
+
},
|
|
126
|
+
createDataSource: (
|
|
127
|
+
data: string | Blob,
|
|
128
|
+
options: GeoTIFFSourceLoaderOptions
|
|
129
|
+
): GeoTIFFRasterSource => new GeoTIFFRasterSource(data, options)
|
|
130
|
+
} as const satisfies SourceLoader<GeoTIFFRasterSource>;
|
|
131
|
+
|
|
132
|
+
type GeoTIFFInit = {
|
|
133
|
+
tiff: TiffSourceDecoder;
|
|
134
|
+
images: TiffSourceImage[];
|
|
135
|
+
metadata: RasterSourceMetadata;
|
|
136
|
+
};
|
|
137
|
+
|
|
138
|
+
type GeoTIFFReadRasterResult = {width: number; height: number} & (
|
|
139
|
+
| RasterData['data']
|
|
140
|
+
| TypedArray[]
|
|
141
|
+
);
|
|
142
|
+
|
|
143
|
+
/**
|
|
144
|
+
* Viewport-driven raster source backed by a GeoTIFF dataset.
|
|
145
|
+
*/
|
|
146
|
+
export class GeoTIFFRasterSource
|
|
147
|
+
extends DataSource<string | Blob, GeoTIFFSourceLoaderOptions>
|
|
148
|
+
implements RasterRegionSource, ScanQueryMetadataProvider
|
|
149
|
+
{
|
|
150
|
+
/** Capabilities advertised by this viewport-driven raster source. */
|
|
151
|
+
readonly rasterQueryCapabilities = GEOTIFF_RASTER_QUERY_CAPABILITIES;
|
|
152
|
+
/** Explicit numeric region support without a viewport dependency. */
|
|
153
|
+
readonly supportsRegion = true;
|
|
154
|
+
private _initPromise: Promise<GeoTIFFInit> | null = null;
|
|
155
|
+
/** Shared metadata transport controller, with leases for concurrent callers. */
|
|
156
|
+
private _initialization: {
|
|
157
|
+
/** Transport shared by active initialization subscribers. */
|
|
158
|
+
controller: AbortController;
|
|
159
|
+
/** Number of active initialization subscribers. */
|
|
160
|
+
subscribers: number;
|
|
161
|
+
/** Whether directory discovery has completed or failed. */
|
|
162
|
+
settled: boolean;
|
|
163
|
+
} | null = null;
|
|
164
|
+
private _rangeScheduler: RangeRequestScheduler | null = null;
|
|
165
|
+
/** Bounded source-owned encoded byte cache with subscriber-aware cancellation. */
|
|
166
|
+
private _rangeCache: RangeRequestCache | null = null;
|
|
167
|
+
/** Cancellation shared by work owned by this source, including borrowed scheduler subscriptions. */
|
|
168
|
+
private readonly _finalizationController = new AbortController();
|
|
169
|
+
|
|
170
|
+
/** Creates a viewport-driven raster source backed by a GeoTIFF URL or Blob. */
|
|
171
|
+
constructor(data: string | Blob, options: GeoTIFFSourceLoaderOptions) {
|
|
172
|
+
super(data, options, GeoTIFFSourceLoader.defaultOptions);
|
|
173
|
+
|
|
174
|
+
if (options.geotiff?.rangeSchedulerProps) {
|
|
175
|
+
this.options.geotiff ||= {};
|
|
176
|
+
this.options.geotiff.rangeSchedulerProps = options.geotiff.rangeSchedulerProps;
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
if (options.geotiff?.rangeScheduler) {
|
|
180
|
+
this.options.geotiff ||= {};
|
|
181
|
+
this.options.geotiff.rangeScheduler = options.geotiff.rangeScheduler;
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
/**
|
|
186
|
+
* Returns normalized GeoTIFF metadata without loading raster samples.
|
|
187
|
+
*/
|
|
188
|
+
async getMetadata(
|
|
189
|
+
options: {/** Caller cancellation for metadata discovery. */ signal?: AbortSignal} = {}
|
|
190
|
+
): Promise<RasterSourceMetadata> {
|
|
191
|
+
return waitForPromiseWithSignals(
|
|
192
|
+
async signal => {
|
|
193
|
+
const {metadata} = await this._getInitPromise(signal);
|
|
194
|
+
signal.throwIfAborted();
|
|
195
|
+
return metadata;
|
|
196
|
+
},
|
|
197
|
+
[options.signal, this._finalizationController.signal]
|
|
198
|
+
);
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
/** Cancels transport owned by this source while preserving an injected shared scheduler. */
|
|
202
|
+
finalize(): void {
|
|
203
|
+
this._finalizationController.abort();
|
|
204
|
+
this._initialization?.controller.abort();
|
|
205
|
+
this._rangeScheduler?.finalize();
|
|
206
|
+
this._rangeCache?.clear();
|
|
207
|
+
this._rangeCache = null;
|
|
208
|
+
const initializationPromise = this._initPromise;
|
|
209
|
+
this._initPromise = null;
|
|
210
|
+
this._initialization = null;
|
|
211
|
+
void initializationPromise?.then(({tiff}) => tiff.close()).catch(() => {});
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
/** Returns raster-query capabilities without opening raster samples. */
|
|
215
|
+
getRasterQueryCapabilities(): RasterQueryCapabilities {
|
|
216
|
+
return this.rasterQueryCapabilities;
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
/** Discovers raster bands, bounds, and overview levels for the shared scan query panel. */
|
|
220
|
+
async getQueryMetadata(options: ScanQueryMetadataOptions = {}): Promise<ScanQueryMetadata> {
|
|
221
|
+
options.signal?.throwIfAborted();
|
|
222
|
+
const metadata = await this.getMetadata(options);
|
|
223
|
+
options.signal?.throwIfAborted();
|
|
224
|
+
const fields = Array.from({length: metadata.bandCount}, (_, index) => ({
|
|
225
|
+
name: `band_${index + 1}`,
|
|
226
|
+
type: metadata.bands?.[index]?.dtype ?? metadata.dtype,
|
|
227
|
+
nullable: metadata.noData !== null,
|
|
228
|
+
metadata: {}
|
|
229
|
+
}));
|
|
230
|
+
return createScanQueryMetadata({
|
|
231
|
+
sourceType: 'geotiff',
|
|
232
|
+
queryType: 'raster',
|
|
233
|
+
execution: {status: 'supported', method: 'getRaster'},
|
|
234
|
+
name: metadata.name,
|
|
235
|
+
schema: {fields, metadata: {}},
|
|
236
|
+
capabilities: {
|
|
237
|
+
bounds: this.rasterQueryCapabilities.bounds,
|
|
238
|
+
levelOfDetail: this.rasterQueryCapabilities.level
|
|
239
|
+
},
|
|
240
|
+
spatial: metadata.boundingBox
|
|
241
|
+
? {
|
|
242
|
+
bounds: {minimum: metadata.boundingBox[0], maximum: metadata.boundingBox[1]},
|
|
243
|
+
coordinateReferenceSystems:
|
|
244
|
+
typeof metadata.crs === 'string' ? [metadata.crs] : undefined
|
|
245
|
+
}
|
|
246
|
+
: undefined,
|
|
247
|
+
levels: metadata.overviews?.map(overview => ({
|
|
248
|
+
index: overview.index,
|
|
249
|
+
width: overview.width,
|
|
250
|
+
height: overview.height,
|
|
251
|
+
scale: [metadata.width / overview.width, metadata.height / overview.height] as [
|
|
252
|
+
number,
|
|
253
|
+
number
|
|
254
|
+
]
|
|
255
|
+
}))
|
|
256
|
+
});
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
/**
|
|
260
|
+
* Loads typed raster samples for the requested viewport.
|
|
261
|
+
*
|
|
262
|
+
* v1 requires the request CRS to match the source CRS and returns native-projection samples.
|
|
263
|
+
*/
|
|
264
|
+
async getRaster(parameters: GetRasterParameters): Promise<RasterData> {
|
|
265
|
+
parameters.signal?.throwIfAborted();
|
|
266
|
+
const metadata = await this.getMetadata({signal: parameters.signal});
|
|
267
|
+
const raster = await this._readRegion(
|
|
268
|
+
{
|
|
269
|
+
...parameters,
|
|
270
|
+
bounds: getRasterViewportBoundingBox(parameters.viewport),
|
|
271
|
+
crs: parameters.viewport.crs ?? metadata.crs!,
|
|
272
|
+
width: parameters.viewport.width,
|
|
273
|
+
height: parameters.viewport.height
|
|
274
|
+
},
|
|
275
|
+
false
|
|
276
|
+
);
|
|
277
|
+
if (raster.dtype === 'mixed')
|
|
278
|
+
throw new Error(
|
|
279
|
+
'Mixed-type GeoTIFF viewport reads require separate single-band requests; use getRasterForRegion for a mixed planar result'
|
|
280
|
+
);
|
|
281
|
+
return raster;
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
/** Reads an explicit region in the source CRS through the shared window pipeline. */
|
|
285
|
+
async getRasterForRegion(parameters: RasterRegionParameters): Promise<NumericRasterData> {
|
|
286
|
+
return this._readRegion(parameters, true);
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
/** Validates and decodes one source-coordinate window for both public entry points. */
|
|
290
|
+
private _readRegion(
|
|
291
|
+
parameters: RasterRegionParameters,
|
|
292
|
+
requireCrs: boolean
|
|
293
|
+
): Promise<NumericRasterData> {
|
|
294
|
+
return waitForPromiseWithSignals(
|
|
295
|
+
signal => this._decodeRegion({...parameters, signal}, requireCrs),
|
|
296
|
+
[parameters.signal, this._finalizationController.signal]
|
|
297
|
+
);
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
/** Runs the native decode pipeline; callers observe cancellation even for noninterruptible codecs. */
|
|
301
|
+
private async _decodeRegion(
|
|
302
|
+
parameters: RasterRegionParameters,
|
|
303
|
+
requireCrs: boolean
|
|
304
|
+
): Promise<NumericRasterData> {
|
|
305
|
+
parameters.signal?.throwIfAborted();
|
|
306
|
+
const {tiff, images, metadata} = await this._getInitPromise(parameters.signal);
|
|
307
|
+
parameters.signal?.throwIfAborted();
|
|
308
|
+
const viewportBoundingBox = parameters.bounds;
|
|
309
|
+
if (
|
|
310
|
+
(requireCrs && (!metadata.crs || !parameters.crs)) ||
|
|
311
|
+
(parameters.crs && metadata.crs !== parameters.crs)
|
|
312
|
+
)
|
|
313
|
+
throw new Error(
|
|
314
|
+
'GeoTIFFRasterSource does not support reprojection; source and request CRS must match'
|
|
315
|
+
);
|
|
316
|
+
if (!metadata.boundingBox) throw new Error('GeoTIFFRasterSource requires source bounds');
|
|
317
|
+
const bandCount = parameters.bands?.length ?? metadata.bandCount;
|
|
318
|
+
if (
|
|
319
|
+
!bandCount ||
|
|
320
|
+
parameters.bands?.some(
|
|
321
|
+
band => !Number.isInteger(band) || band < 0 || band >= metadata.bandCount
|
|
322
|
+
)
|
|
323
|
+
)
|
|
324
|
+
throw new Error('Invalid raster bands');
|
|
325
|
+
const selectedBands = parameters.bands ?? Array.from({length: bandCount}, (_, index) => index);
|
|
326
|
+
const outputDtype = metadata.bands?.[selectedBands[0]]?.dtype ?? metadata.dtype;
|
|
327
|
+
const mixed = selectedBands.some(
|
|
328
|
+
index => metadata.bands?.[index] && metadata.bands[index].dtype !== outputDtype
|
|
329
|
+
);
|
|
330
|
+
const interleaved = parameters.interleaved ?? this.options.geotiff?.interleaved ?? false;
|
|
331
|
+
if (mixed && !requireCrs)
|
|
332
|
+
throw new Error('Mixed-type GeoTIFF viewport reads require separate single-band requests');
|
|
333
|
+
if (mixed && interleaved) throw new Error('Mixed-type GeoTIFF regions require planar arrays');
|
|
334
|
+
const bytesPerPixel = selectedBands.reduce(
|
|
335
|
+
(bytes, index) =>
|
|
336
|
+
bytes +
|
|
337
|
+
Number((metadata.bands?.[index]?.dtype ?? metadata.dtype).match(/\d+/)?.[0] ?? 64) / 8,
|
|
338
|
+
0
|
|
339
|
+
);
|
|
340
|
+
const maxPixels = parameters.maxPixels ?? this.options.geotiff?.maxPixels ?? 16_000_000;
|
|
341
|
+
const maxDecodedBytes =
|
|
342
|
+
parameters.maxDecodedBytes ?? this.options.geotiff?.maxDecodedBytes ?? 256 * 1024 * 1024;
|
|
343
|
+
const pixels = validateRasterRegion(
|
|
344
|
+
viewportBoundingBox,
|
|
345
|
+
parameters.width,
|
|
346
|
+
parameters.height,
|
|
347
|
+
bytesPerPixel,
|
|
348
|
+
maxPixels,
|
|
349
|
+
maxDecodedBytes
|
|
350
|
+
);
|
|
351
|
+
const clippedBoundingBox = intersectBoundingBoxes(viewportBoundingBox, metadata.boundingBox);
|
|
352
|
+
if (!clippedBoundingBox) {
|
|
353
|
+
if (pixels * (bytesPerPixel + 1) > maxDecodedBytes)
|
|
354
|
+
throw new Error('Empty raster mask exceeds decoded-byte budget');
|
|
355
|
+
if (mixed) {
|
|
356
|
+
return {
|
|
357
|
+
data: selectedBands.map(index =>
|
|
358
|
+
createFilledTypedArray(
|
|
359
|
+
metadata.bands![index].dtype,
|
|
360
|
+
pixels,
|
|
361
|
+
metadata.bands![index].noData ?? 0
|
|
362
|
+
)
|
|
363
|
+
),
|
|
364
|
+
dtype: 'mixed',
|
|
365
|
+
interleaved: false,
|
|
366
|
+
bands: selectedBands.map(index => metadata.bands![index]),
|
|
367
|
+
width: parameters.width,
|
|
368
|
+
height: parameters.height,
|
|
369
|
+
bandCount,
|
|
370
|
+
crs: metadata.crs,
|
|
371
|
+
boundingBox: parameters.bounds,
|
|
372
|
+
transform: createRegionTransform(parameters.bounds, parameters.width, parameters.height),
|
|
373
|
+
pixelRegistration: 'area',
|
|
374
|
+
provenance: {sourceType: 'geotiff'},
|
|
375
|
+
ownership: 'owned',
|
|
376
|
+
validityMasks: [
|
|
377
|
+
{data: new Uint8Array(pixels), width: parameters.width, height: parameters.height}
|
|
378
|
+
]
|
|
379
|
+
};
|
|
380
|
+
}
|
|
381
|
+
const empty = createEmptyRaster(parameters, {...metadata, dtype: outputDtype});
|
|
382
|
+
empty.validityMasks = [
|
|
383
|
+
{data: new Uint8Array(pixels), width: parameters.width, height: parameters.height}
|
|
384
|
+
];
|
|
385
|
+
return empty;
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
const targetSize = getClippedTargetSize(viewportBoundingBox, clippedBoundingBox, parameters);
|
|
389
|
+
const fillValue = metadata.noData ?? undefined;
|
|
390
|
+
const requestedResolution: [number, number] = [
|
|
391
|
+
(clippedBoundingBox[1][0] - clippedBoundingBox[0][0]) / targetSize.width,
|
|
392
|
+
(clippedBoundingBox[1][1] - clippedBoundingBox[0][1]) / targetSize.height
|
|
393
|
+
];
|
|
394
|
+
let overview = 0;
|
|
395
|
+
let transform: RasterAffineTransform | undefined;
|
|
396
|
+
let actualBoundingBox = clippedBoundingBox;
|
|
397
|
+
let raster: GeoTIFFReadRasterResult;
|
|
398
|
+
let validityMasks: RasterData['validityMasks'];
|
|
399
|
+
const readOptions = {
|
|
400
|
+
width: targetSize.width,
|
|
401
|
+
height: targetSize.height,
|
|
402
|
+
samples: parameters.bands,
|
|
403
|
+
interleave: interleaved,
|
|
404
|
+
resampleMethod: parameters.resampleMethod ?? this.options.geotiff?.resampleMethod,
|
|
405
|
+
fillValue,
|
|
406
|
+
signal: parameters.signal
|
|
407
|
+
};
|
|
408
|
+
if (images.length) {
|
|
409
|
+
for (let index = 1; index < images.length; index++) {
|
|
410
|
+
const image = images[index];
|
|
411
|
+
const directory = image.fileDirectory;
|
|
412
|
+
if (directory.NewSubfileType & 4) continue;
|
|
413
|
+
if (!(directory.NewSubfileType & 1) && directory.SubfileType !== 2) continue;
|
|
414
|
+
if (
|
|
415
|
+
images.some(candidate => candidate.fileDirectory?.NewSubfileType & 4) &&
|
|
416
|
+
!images.some(
|
|
417
|
+
candidate =>
|
|
418
|
+
candidate.fileDirectory?.NewSubfileType & 4 &&
|
|
419
|
+
candidate.getWidth() === image.getWidth() &&
|
|
420
|
+
candidate.getHeight() === image.getHeight()
|
|
421
|
+
)
|
|
422
|
+
)
|
|
423
|
+
continue;
|
|
424
|
+
const registration = image.getGeoKeys?.()?.GTRasterTypeGeoKey;
|
|
425
|
+
if (
|
|
426
|
+
(registration === 2 ? 'point' : 'area') !== (metadata.pixelRegistration ?? 'area') &&
|
|
427
|
+
registration !== undefined
|
|
428
|
+
)
|
|
429
|
+
continue;
|
|
430
|
+
if (
|
|
431
|
+
typeof image.getSamplesPerPixel === 'function' &&
|
|
432
|
+
selectedBands.some(band => band >= image.getSamplesPerPixel())
|
|
433
|
+
)
|
|
434
|
+
continue;
|
|
435
|
+
if (
|
|
436
|
+
typeof image.getBitsPerSample === 'function' &&
|
|
437
|
+
typeof image.getSampleFormat === 'function'
|
|
438
|
+
) {
|
|
439
|
+
try {
|
|
440
|
+
if (
|
|
441
|
+
selectedBands.some(
|
|
442
|
+
band =>
|
|
443
|
+
getImageDataType(image, band) !==
|
|
444
|
+
(metadata.bands?.[band]?.dtype ?? metadata.dtype)
|
|
445
|
+
)
|
|
446
|
+
)
|
|
447
|
+
continue;
|
|
448
|
+
} catch {
|
|
449
|
+
continue;
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
const resolution = getImageResolution(image, images[0]);
|
|
453
|
+
if (
|
|
454
|
+
resolution &&
|
|
455
|
+
Math.abs(resolution[0]) <= requestedResolution[0] &&
|
|
456
|
+
Math.abs(resolution[1]) <= requestedResolution[1] &&
|
|
457
|
+
image.getWidth() < images[overview].getWidth()
|
|
458
|
+
)
|
|
459
|
+
overview = index;
|
|
460
|
+
}
|
|
461
|
+
const image = images[overview];
|
|
462
|
+
const affine = getImageTransform(image, images[0]);
|
|
463
|
+
if (!affine) throw new Error('GeoTIFF source has no usable affine transform');
|
|
464
|
+
const [columnScale, rowShear, originX, columnShear, rowScale, originY] = affine;
|
|
465
|
+
const determinant = columnScale * rowScale - rowShear * columnShear;
|
|
466
|
+
if (!affine.every(Number.isFinite) || !Number.isFinite(determinant) || determinant === 0)
|
|
467
|
+
throw new Error('Singular GeoTIFF affine transform');
|
|
468
|
+
const corners = [
|
|
469
|
+
clippedBoundingBox[0],
|
|
470
|
+
clippedBoundingBox[1],
|
|
471
|
+
[clippedBoundingBox[0][0], clippedBoundingBox[1][1]],
|
|
472
|
+
[clippedBoundingBox[1][0], clippedBoundingBox[0][1]]
|
|
473
|
+
];
|
|
474
|
+
const grid = corners.map(([coordinateX, coordinateY]) => [
|
|
475
|
+
(rowScale * (coordinateX - originX) - rowShear * (coordinateY - originY)) / determinant,
|
|
476
|
+
(columnScale * (coordinateY - originY) - columnShear * (coordinateX - originX)) /
|
|
477
|
+
determinant
|
|
478
|
+
]);
|
|
479
|
+
const window = [
|
|
480
|
+
Math.max(0, Math.floor(Math.min(...grid.map(point => point[0])))),
|
|
481
|
+
Math.max(0, Math.floor(Math.min(...grid.map(point => point[1])))),
|
|
482
|
+
Math.min(image.getWidth(), Math.ceil(Math.max(...grid.map(point => point[0])))),
|
|
483
|
+
Math.min(image.getHeight(), Math.ceil(Math.max(...grid.map(point => point[1]))))
|
|
484
|
+
];
|
|
485
|
+
const maskImages = images.filter(
|
|
486
|
+
candidate =>
|
|
487
|
+
candidate.fileDirectory?.NewSubfileType & 4 &&
|
|
488
|
+
candidate.getWidth() === image.getWidth() &&
|
|
489
|
+
candidate.getHeight() === image.getHeight()
|
|
490
|
+
);
|
|
491
|
+
if (maskImages.length > 1) throw new Error('Ambiguous GeoTIFF validity mask');
|
|
492
|
+
const nativePixelCount = (window[2] - window[0]) * (window[3] - window[1]);
|
|
493
|
+
const nativeBytes = nativePixelCount * bytesPerPixel;
|
|
494
|
+
const maskBytes = maskImages.length
|
|
495
|
+
? nativePixelCount * 3 + estimateImageTileBytes(maskImages[0], window, 2)
|
|
496
|
+
: 0;
|
|
497
|
+
const sourceBytesPerPixel =
|
|
498
|
+
image.fileDirectory?.PlanarConfiguration === 2
|
|
499
|
+
? bytesPerPixel
|
|
500
|
+
: metadata.bands
|
|
501
|
+
? metadata.bands.reduce(
|
|
502
|
+
(bytes, band) => bytes + Number(band.dtype.match(/\d+/)?.[0] ?? 64) / 8,
|
|
503
|
+
0
|
|
504
|
+
)
|
|
505
|
+
: (metadata.bandCount * Number(metadata.dtype.match(/\d+/)?.[0] ?? 64)) / 8;
|
|
506
|
+
const tileBytes = estimateImageTileBytes(image, window, sourceBytesPerPixel);
|
|
507
|
+
if (
|
|
508
|
+
nativeBytes * 2 + maskBytes + pixels * (bytesPerPixel + bandCount) + tileBytes >
|
|
509
|
+
maxDecodedBytes
|
|
510
|
+
)
|
|
511
|
+
throw new Error('Native decode window exceeds decoded-byte budget');
|
|
512
|
+
if (window[2] <= window[0] || window[3] <= window[1])
|
|
513
|
+
throw new Error('Region does not intersect the source grid');
|
|
514
|
+
const scaleX = (window[2] - window[0]) / targetSize.width;
|
|
515
|
+
const scaleY = (window[3] - window[1]) / targetSize.height;
|
|
516
|
+
const pointShift = metadata.pixelRegistration === 'point' ? 0.5 : 0;
|
|
517
|
+
transform = [
|
|
518
|
+
columnScale * scaleX,
|
|
519
|
+
rowShear * scaleY,
|
|
520
|
+
columnScale * (window[0] - pointShift) + rowShear * (window[1] - pointShift) + originX,
|
|
521
|
+
columnShear * scaleX,
|
|
522
|
+
rowScale * scaleY,
|
|
523
|
+
columnShear * (window[0] - pointShift) + rowScale * (window[1] - pointShift) + originY
|
|
524
|
+
];
|
|
525
|
+
const sourceCorners = [
|
|
526
|
+
[window[0], window[1]],
|
|
527
|
+
[window[2], window[1]],
|
|
528
|
+
[window[0], window[3]],
|
|
529
|
+
[window[2], window[3]]
|
|
530
|
+
].map(([column, row]) => [
|
|
531
|
+
columnScale * (column - pointShift) + rowShear * (row - pointShift) + originX,
|
|
532
|
+
columnShear * (column - pointShift) + rowScale * (row - pointShift) + originY
|
|
533
|
+
]);
|
|
534
|
+
actualBoundingBox = [
|
|
535
|
+
[
|
|
536
|
+
Math.min(...sourceCorners.map(point => point[0])),
|
|
537
|
+
Math.min(...sourceCorners.map(point => point[1]))
|
|
538
|
+
],
|
|
539
|
+
[
|
|
540
|
+
Math.max(...sourceCorners.map(point => point[0])),
|
|
541
|
+
Math.max(...sourceCorners.map(point => point[1]))
|
|
542
|
+
]
|
|
543
|
+
];
|
|
544
|
+
const nativeRaster = (await image.readRasters({
|
|
545
|
+
...readOptions,
|
|
546
|
+
// geotiff.js interleaving chooses a type from every source band, including unselected bands.
|
|
547
|
+
interleave: false,
|
|
548
|
+
width: window[2] - window[0],
|
|
549
|
+
height: window[3] - window[1],
|
|
550
|
+
window,
|
|
551
|
+
resampleMethod: 'nearest'
|
|
552
|
+
})) as unknown as GeoTIFFReadRasterResult;
|
|
553
|
+
if (
|
|
554
|
+
nativeRaster.width !== window[2] - window[0] ||
|
|
555
|
+
nativeRaster.height !== window[3] - window[1]
|
|
556
|
+
)
|
|
557
|
+
throw new Error('Invalid native raster dimensions');
|
|
558
|
+
const nativeArrays = Array.isArray(nativeRaster) ? nativeRaster : [nativeRaster];
|
|
559
|
+
if (
|
|
560
|
+
nativeArrays.reduce((length, array) => length + array.length, 0) !==
|
|
561
|
+
nativeRaster.width * nativeRaster.height * bandCount ||
|
|
562
|
+
nativeArrays.reduce((length, array) => length + array.byteLength, 0) > maxDecodedBytes
|
|
563
|
+
)
|
|
564
|
+
throw new Error('Invalid or oversized native raster');
|
|
565
|
+
if (
|
|
566
|
+
nativeArrays.length !== bandCount ||
|
|
567
|
+
nativeArrays.some(
|
|
568
|
+
(array, index) =>
|
|
569
|
+
array.constructor !==
|
|
570
|
+
createFilledTypedArray(
|
|
571
|
+
metadata.bands?.[selectedBands[index]]?.dtype ?? metadata.dtype,
|
|
572
|
+
0,
|
|
573
|
+
0
|
|
574
|
+
).constructor
|
|
575
|
+
)
|
|
576
|
+
)
|
|
577
|
+
throw new Error('Native raster representation does not match selected band metadata');
|
|
578
|
+
let nativeValidityMasks: RasterData['validityMasks'];
|
|
579
|
+
if (maskImages.length) {
|
|
580
|
+
parameters.signal?.throwIfAborted();
|
|
581
|
+
const maskRaster = (await maskImages[0].readRasters({
|
|
582
|
+
window,
|
|
583
|
+
samples: [0],
|
|
584
|
+
interleave: true,
|
|
585
|
+
signal: parameters.signal
|
|
586
|
+
})) as unknown as TypedArray;
|
|
587
|
+
if (maskRaster.length !== nativePixelCount || maskRaster.byteLength > nativePixelCount * 2)
|
|
588
|
+
throw new Error('Invalid GeoTIFF validity mask');
|
|
589
|
+
nativeValidityMasks = [
|
|
590
|
+
{
|
|
591
|
+
data: Uint8Array.from(maskRaster, value =>
|
|
592
|
+
Number.isFinite(value) && value !== 0 ? 1 : 0
|
|
593
|
+
),
|
|
594
|
+
width: nativeRaster.width,
|
|
595
|
+
height: nativeRaster.height,
|
|
596
|
+
pixelStride: 1,
|
|
597
|
+
rowStride: nativeRaster.width
|
|
598
|
+
}
|
|
599
|
+
];
|
|
600
|
+
}
|
|
601
|
+
const resized = await resizeRasterWindow(
|
|
602
|
+
nativeRaster,
|
|
603
|
+
selectedBands.map(index =>
|
|
604
|
+
metadata.bands?.[index]
|
|
605
|
+
? {...metadata.bands[index]}
|
|
606
|
+
: {index, dtype: outputDtype, noData: metadata.noData}
|
|
607
|
+
),
|
|
608
|
+
interleaved,
|
|
609
|
+
targetSize,
|
|
610
|
+
readOptions.resampleMethod ?? 'nearest',
|
|
611
|
+
parameters.signal,
|
|
612
|
+
nativeValidityMasks
|
|
613
|
+
);
|
|
614
|
+
raster = resized.raster;
|
|
615
|
+
validityMasks = resized.validityMasks;
|
|
616
|
+
} else {
|
|
617
|
+
raster = (await tiff.readRasters({
|
|
618
|
+
...readOptions,
|
|
619
|
+
bbox: flattenBoundingBox(clippedBoundingBox)
|
|
620
|
+
})) as unknown as GeoTIFFReadRasterResult;
|
|
621
|
+
}
|
|
622
|
+
|
|
623
|
+
const data = normalizeRasterReadResult(raster, interleaved);
|
|
624
|
+
parameters.signal?.throwIfAborted();
|
|
625
|
+
const arrays = Array.isArray(data) ? data : [data];
|
|
626
|
+
const expectedLength = raster.width * raster.height * bandCount;
|
|
627
|
+
if (
|
|
628
|
+
!Number.isSafeInteger(raster.width) ||
|
|
629
|
+
!Number.isSafeInteger(raster.height) ||
|
|
630
|
+
raster.width <= 0 ||
|
|
631
|
+
raster.height <= 0 ||
|
|
632
|
+
raster.width * raster.height >
|
|
633
|
+
(parameters.maxPixels ?? this.options.geotiff?.maxPixels ?? 16_000_000)
|
|
634
|
+
)
|
|
635
|
+
throw new Error('Invalid decoded raster dimensions');
|
|
636
|
+
if (
|
|
637
|
+
arrays.reduce((length, array) => length + array.length, 0) !== expectedLength ||
|
|
638
|
+
arrays.reduce((length, array) => length + array.byteLength, 0) >
|
|
639
|
+
(parameters.maxDecodedBytes ?? this.options.geotiff?.maxDecodedBytes ?? 256 * 1024 * 1024)
|
|
640
|
+
)
|
|
641
|
+
throw new Error('Invalid or oversized decoded raster');
|
|
642
|
+
|
|
643
|
+
const result = {
|
|
644
|
+
data,
|
|
645
|
+
width: raster.width,
|
|
646
|
+
height: raster.height,
|
|
647
|
+
bandCount,
|
|
648
|
+
dtype: outputDtype,
|
|
649
|
+
interleaved,
|
|
650
|
+
noData: metadata.noData,
|
|
651
|
+
boundingBox: actualBoundingBox,
|
|
652
|
+
crs: metadata.crs,
|
|
653
|
+
metadata: metadata.metadata,
|
|
654
|
+
bands: (parameters.bands ?? Array.from({length: bandCount}, (_, index) => index)).map(
|
|
655
|
+
index =>
|
|
656
|
+
metadata.bands?.[index]
|
|
657
|
+
? {...metadata.bands[index]}
|
|
658
|
+
: {index, dtype: metadata.dtype, noData: metadata.noData}
|
|
659
|
+
),
|
|
660
|
+
transform,
|
|
661
|
+
pixelRegistration: 'area',
|
|
662
|
+
validityMasks,
|
|
663
|
+
overview,
|
|
664
|
+
resolution: transform
|
|
665
|
+
? [Math.hypot(transform[0], transform[3]), Math.hypot(transform[1], transform[4])]
|
|
666
|
+
: requestedResolution,
|
|
667
|
+
nativeResolution: metadata.overviews
|
|
668
|
+
?.find(level => level.index === overview)
|
|
669
|
+
?.resolution?.map(Math.abs) as [number, number] | undefined,
|
|
670
|
+
overzoom: metadata.overviews
|
|
671
|
+
?.find(level => level.index === overview)
|
|
672
|
+
?.resolution?.some((resolution, axis) => Math.abs(resolution) > requestedResolution[axis]),
|
|
673
|
+
provenance: {sourceType: 'geotiff'},
|
|
674
|
+
ownership: 'owned'
|
|
675
|
+
};
|
|
676
|
+
if (mixed)
|
|
677
|
+
return {
|
|
678
|
+
...result,
|
|
679
|
+
data: arrays,
|
|
680
|
+
dtype: 'mixed',
|
|
681
|
+
interleaved: false,
|
|
682
|
+
bands: result.bands
|
|
683
|
+
} as RasterMixedData;
|
|
684
|
+
return result as RasterData;
|
|
685
|
+
}
|
|
686
|
+
|
|
687
|
+
/** Opens the GeoTIFF once and resolves its overview images and normalized metadata. */
|
|
688
|
+
private async _initialize(signal?: AbortSignal): Promise<GeoTIFFInit> {
|
|
689
|
+
signal?.throwIfAborted();
|
|
690
|
+
const tiff = await this._openGeoTIFF(signal);
|
|
691
|
+
signal?.throwIfAborted();
|
|
692
|
+
const imageCount = await tiff.getImageCount();
|
|
693
|
+
signal?.throwIfAborted();
|
|
694
|
+
const images = await Promise.all(
|
|
695
|
+
Array.from({length: imageCount}, (_, index) => tiff.getImage(index))
|
|
696
|
+
);
|
|
697
|
+
|
|
698
|
+
signal?.throwIfAborted();
|
|
699
|
+
if (!images.length) {
|
|
700
|
+
throw new Error('GeoTIFFRasterSource could not load any images.');
|
|
701
|
+
}
|
|
702
|
+
|
|
703
|
+
const referenceImage = images[0];
|
|
704
|
+
const metadata = this._getMetadata(referenceImage, images);
|
|
705
|
+
|
|
706
|
+
return {tiff, images, metadata};
|
|
707
|
+
}
|
|
708
|
+
|
|
709
|
+
/** Returns the shared initialization promise for this source instance. */
|
|
710
|
+
private _getInitPromise(signal?: AbortSignal): Promise<GeoTIFFInit> {
|
|
711
|
+
signal?.throwIfAborted();
|
|
712
|
+
if (!this._initPromise) {
|
|
713
|
+
const initialization = {controller: new AbortController(), subscribers: 0, settled: false};
|
|
714
|
+
this._initialization = initialization;
|
|
715
|
+
const promise = this._initialize(initialization.controller.signal);
|
|
716
|
+
this._initPromise = promise;
|
|
717
|
+
void promise.then(
|
|
718
|
+
() => {
|
|
719
|
+
initialization.settled = true;
|
|
720
|
+
},
|
|
721
|
+
() => {
|
|
722
|
+
initialization.settled = true;
|
|
723
|
+
if (this._initPromise === promise) this._initPromise = null;
|
|
724
|
+
}
|
|
725
|
+
);
|
|
726
|
+
}
|
|
727
|
+
const promise = this._initPromise;
|
|
728
|
+
const initialization = this._initialization;
|
|
729
|
+
if (initialization) initialization.subscribers++;
|
|
730
|
+
const release = () => {
|
|
731
|
+
if (!initialization) return;
|
|
732
|
+
initialization.subscribers--;
|
|
733
|
+
if (!initialization.settled && initialization.subscribers === 0) {
|
|
734
|
+
initialization.controller.abort(signal?.reason);
|
|
735
|
+
if (this._initPromise === promise) this._initPromise = null;
|
|
736
|
+
}
|
|
737
|
+
};
|
|
738
|
+
if (!signal) {
|
|
739
|
+
void promise.then(release, release);
|
|
740
|
+
return promise;
|
|
741
|
+
}
|
|
742
|
+
return new Promise((resolve, reject) => {
|
|
743
|
+
let released = false;
|
|
744
|
+
const cleanup = () => {
|
|
745
|
+
if (released) return;
|
|
746
|
+
released = true;
|
|
747
|
+
signal.removeEventListener('abort', abort);
|
|
748
|
+
release();
|
|
749
|
+
};
|
|
750
|
+
const abort = () => {
|
|
751
|
+
cleanup();
|
|
752
|
+
reject(signal.reason);
|
|
753
|
+
};
|
|
754
|
+
signal.addEventListener('abort', abort, {once: true});
|
|
755
|
+
if (signal.aborted) abort();
|
|
756
|
+
void promise.then(
|
|
757
|
+
value => {
|
|
758
|
+
cleanup();
|
|
759
|
+
resolve(value);
|
|
760
|
+
},
|
|
761
|
+
error => {
|
|
762
|
+
cleanup();
|
|
763
|
+
reject(error);
|
|
764
|
+
}
|
|
765
|
+
);
|
|
766
|
+
});
|
|
767
|
+
}
|
|
768
|
+
|
|
769
|
+
/** Opens the underlying GeoTIFF using Blob reads or range-scheduled HTTP access. */
|
|
770
|
+
private async _openGeoTIFF(signal?: AbortSignal): Promise<TiffSourceDecoder> {
|
|
771
|
+
const initialization = this._initialization;
|
|
772
|
+
if (typeof this.data === 'string') {
|
|
773
|
+
const maxEntries = this.options.geotiff?.rangeCacheProps?.maxEntries ?? 128;
|
|
774
|
+
const maxBytes = this.options.geotiff?.rangeCacheProps?.maxBytes ?? 8 * 1024 * 1024;
|
|
775
|
+
if (![maxEntries, maxBytes].every(value => Number.isSafeInteger(value) && value >= 0))
|
|
776
|
+
throw new Error('Invalid GeoTIFF cache limits');
|
|
777
|
+
this._rangeCache?.clear();
|
|
778
|
+
this._rangeCache = new RangeRequestCache({maxEntries, maxBytes});
|
|
779
|
+
const headers = Object.fromEntries(new Headers(this.options.geotiff?.headers));
|
|
780
|
+
const rangeScheduler = this._getRangeScheduler();
|
|
781
|
+
const rangeCache = this._rangeCache;
|
|
782
|
+
const client = new GeoTIFFRangeSchedulerClient({
|
|
783
|
+
url: this.url,
|
|
784
|
+
fetch: this.fetch,
|
|
785
|
+
requireContentRange: this.options.geotiff?.requireContentRange,
|
|
786
|
+
sourceId: 'geotiff',
|
|
787
|
+
headers,
|
|
788
|
+
rangeCache,
|
|
789
|
+
maxPendingRequests: rangeScheduler.props.maxQueueSize,
|
|
790
|
+
rangeScheduler,
|
|
791
|
+
getInitializationSignal: () => (initialization?.settled ? undefined : signal),
|
|
792
|
+
onRevisionChange: error => {
|
|
793
|
+
this._finalizationController.abort(error);
|
|
794
|
+
rangeCache.clear();
|
|
795
|
+
}
|
|
796
|
+
});
|
|
797
|
+
// The library's BlockedSource retries interrupted shared blocks without a signal.
|
|
798
|
+
// Adapt its buffer-source protocol directly; loaders.gl owns bounded caching and cancellation.
|
|
799
|
+
return await openGeoTIFFSourceDecoder(
|
|
800
|
+
{
|
|
801
|
+
/** Reads independently owned buffers in source request order. */
|
|
802
|
+
fetch: (slices: GeoTIFFRangeSlice[], requestSignal?: AbortSignal) =>
|
|
803
|
+
client.readRanges(slices, requestSignal),
|
|
804
|
+
/** Reflects the validated remote object length discovered by transport. */
|
|
805
|
+
get fileSize() {
|
|
806
|
+
return client.getFileSize();
|
|
807
|
+
},
|
|
808
|
+
/** Releases only this source's owned byte cache. */
|
|
809
|
+
close: () => rangeCache.clear()
|
|
810
|
+
},
|
|
811
|
+
signal
|
|
812
|
+
);
|
|
813
|
+
}
|
|
814
|
+
|
|
815
|
+
return await openGeoTIFFSourceDecoder(this.data, signal);
|
|
816
|
+
}
|
|
817
|
+
|
|
818
|
+
/** Returns the configured shared scheduler or lazily creates a per-source scheduler. */
|
|
819
|
+
private _getRangeScheduler(): RangeRequestScheduler {
|
|
820
|
+
if (this.options.geotiff?.rangeScheduler) {
|
|
821
|
+
return this.options.geotiff.rangeScheduler;
|
|
822
|
+
}
|
|
823
|
+
|
|
824
|
+
if (!this._rangeScheduler) {
|
|
825
|
+
this._rangeScheduler = new RangeRequestScheduler({
|
|
826
|
+
batchDelayMs: 0,
|
|
827
|
+
...this.options.geotiff?.rangeSchedulerProps
|
|
828
|
+
});
|
|
829
|
+
}
|
|
830
|
+
|
|
831
|
+
return this._rangeScheduler;
|
|
832
|
+
}
|
|
833
|
+
|
|
834
|
+
/** Normalizes one GeoTIFF image hierarchy into public raster-source metadata. */
|
|
835
|
+
private _getMetadata(
|
|
836
|
+
referenceImage: TiffSourceImage,
|
|
837
|
+
images: TiffSourceImage[]
|
|
838
|
+
): RasterSourceMetadata {
|
|
839
|
+
if (
|
|
840
|
+
![
|
|
841
|
+
referenceImage.getWidth(),
|
|
842
|
+
referenceImage.getHeight(),
|
|
843
|
+
referenceImage.getSamplesPerPixel()
|
|
844
|
+
].every(value => Number.isSafeInteger(value) && value > 0)
|
|
845
|
+
)
|
|
846
|
+
throw new Error('Invalid GeoTIFF image dimensions or band count');
|
|
847
|
+
const boundingBox = getImageBoundingBox(referenceImage);
|
|
848
|
+
const geoKeys = referenceImage.getGeoKeys?.() || undefined;
|
|
849
|
+
const gdalMetadata = referenceImage.getGDALMetadata?.() || undefined;
|
|
850
|
+
const noData = referenceImage.getGDALNoData?.() ?? null;
|
|
851
|
+
|
|
852
|
+
return {
|
|
853
|
+
name: getGeoTIFFName(this.data),
|
|
854
|
+
keywords: [],
|
|
855
|
+
attributions: this.options.core?.attributions || [],
|
|
856
|
+
crs: getImageCRS(referenceImage),
|
|
857
|
+
boundingBox,
|
|
858
|
+
tileGrid: getImageTileGrid(images, referenceImage),
|
|
859
|
+
width: referenceImage.getWidth(),
|
|
860
|
+
height: referenceImage.getHeight(),
|
|
861
|
+
bandCount: referenceImage.getSamplesPerPixel(),
|
|
862
|
+
dtype: getImageDataType(referenceImage),
|
|
863
|
+
bands: Array.from({length: referenceImage.getSamplesPerPixel()}, (_, index) =>
|
|
864
|
+
getImageBandMetadata(referenceImage, index, noData)
|
|
865
|
+
),
|
|
866
|
+
transform: getImageTransform(referenceImage, referenceImage),
|
|
867
|
+
pixelRegistration:
|
|
868
|
+
geoKeys?.GTRasterTypeGeoKey === 2
|
|
869
|
+
? 'point'
|
|
870
|
+
: geoKeys?.GTRasterTypeGeoKey === 1
|
|
871
|
+
? 'area'
|
|
872
|
+
: undefined,
|
|
873
|
+
supportsRegion: true,
|
|
874
|
+
tileSize: {
|
|
875
|
+
width: referenceImage.getTileWidth(),
|
|
876
|
+
height: referenceImage.getTileHeight()
|
|
877
|
+
},
|
|
878
|
+
overviews: images
|
|
879
|
+
.map((image, index) => ({
|
|
880
|
+
index,
|
|
881
|
+
width: image.getWidth(),
|
|
882
|
+
height: image.getHeight(),
|
|
883
|
+
resolution: getImageResolution(image, referenceImage)
|
|
884
|
+
}))
|
|
885
|
+
.filter(overview => !(images[overview.index].fileDirectory?.NewSubfileType & 4)),
|
|
886
|
+
noData,
|
|
887
|
+
metadata: {
|
|
888
|
+
geoKeys,
|
|
889
|
+
gdalMetadata,
|
|
890
|
+
bandMetadata: Array.from(
|
|
891
|
+
{length: referenceImage.getSamplesPerPixel()},
|
|
892
|
+
(_, index) => referenceImage.getGDALMetadata?.(index) || undefined
|
|
893
|
+
)
|
|
894
|
+
}
|
|
895
|
+
};
|
|
896
|
+
}
|
|
897
|
+
}
|
|
898
|
+
|
|
899
|
+
/** Flattens the internal tuple bounding box to GeoTIFF's `[minX, minY, maxX, maxY]` form. */
|
|
900
|
+
function flattenBoundingBox(boundingBox: RasterBoundingBox): [number, number, number, number] {
|
|
901
|
+
return [...boundingBox[0], ...boundingBox[1]];
|
|
902
|
+
}
|
|
903
|
+
|
|
904
|
+
/** Computes the overlap between two source-coordinate bounding boxes. */
|
|
905
|
+
function intersectBoundingBoxes(
|
|
906
|
+
leftBoundingBox: RasterBoundingBox,
|
|
907
|
+
rightBoundingBox: RasterBoundingBox
|
|
908
|
+
): RasterBoundingBox | null {
|
|
909
|
+
const minX = Math.max(leftBoundingBox[0][0], rightBoundingBox[0][0]);
|
|
910
|
+
const minY = Math.max(leftBoundingBox[0][1], rightBoundingBox[0][1]);
|
|
911
|
+
const maxX = Math.min(leftBoundingBox[1][0], rightBoundingBox[1][0]);
|
|
912
|
+
const maxY = Math.min(leftBoundingBox[1][1], rightBoundingBox[1][1]);
|
|
913
|
+
|
|
914
|
+
if (maxX <= minX || maxY <= minY) {
|
|
915
|
+
return null;
|
|
916
|
+
}
|
|
917
|
+
|
|
918
|
+
return [
|
|
919
|
+
[minX, minY],
|
|
920
|
+
[maxX, maxY]
|
|
921
|
+
];
|
|
922
|
+
}
|
|
923
|
+
|
|
924
|
+
/** Scales the output raster size to the portion of the viewport that intersects the source. */
|
|
925
|
+
function getClippedTargetSize(
|
|
926
|
+
viewportBoundingBox: RasterBoundingBox,
|
|
927
|
+
clippedBoundingBox: RasterBoundingBox,
|
|
928
|
+
parameters: RasterRegionParameters
|
|
929
|
+
): {width: number; height: number} {
|
|
930
|
+
const viewportWidth = Math.abs(viewportBoundingBox[1][0] - viewportBoundingBox[0][0]);
|
|
931
|
+
const viewportHeight = Math.abs(viewportBoundingBox[1][1] - viewportBoundingBox[0][1]);
|
|
932
|
+
const clippedWidth = Math.abs(clippedBoundingBox[1][0] - clippedBoundingBox[0][0]);
|
|
933
|
+
const clippedHeight = Math.abs(clippedBoundingBox[1][1] - clippedBoundingBox[0][1]);
|
|
934
|
+
|
|
935
|
+
return {
|
|
936
|
+
width: Math.max(
|
|
937
|
+
1,
|
|
938
|
+
Math.min(
|
|
939
|
+
parameters.width,
|
|
940
|
+
Math.round((clippedWidth / Math.max(viewportWidth, Number.EPSILON)) * parameters.width)
|
|
941
|
+
)
|
|
942
|
+
),
|
|
943
|
+
height: Math.max(
|
|
944
|
+
1,
|
|
945
|
+
Math.min(
|
|
946
|
+
parameters.height,
|
|
947
|
+
Math.round((clippedHeight / Math.max(viewportHeight, Number.EPSILON)) * parameters.height)
|
|
948
|
+
)
|
|
949
|
+
)
|
|
950
|
+
};
|
|
951
|
+
}
|
|
952
|
+
|
|
953
|
+
/** Creates a no-data raster payload when the viewport does not overlap the dataset. */
|
|
954
|
+
function createEmptyRaster(
|
|
955
|
+
parameters: RasterRegionParameters,
|
|
956
|
+
metadata: RasterSourceMetadata
|
|
957
|
+
): RasterData {
|
|
958
|
+
const length = parameters.width * parameters.height;
|
|
959
|
+
const bandCount = parameters.bands?.length ?? metadata.bandCount;
|
|
960
|
+
const interleaved = parameters.interleaved ?? false;
|
|
961
|
+
const noData = metadata.noData ?? 0;
|
|
962
|
+
const data = interleaved
|
|
963
|
+
? createFilledTypedArray(metadata.dtype, length * bandCount, noData)
|
|
964
|
+
: bandCount === 1
|
|
965
|
+
? createFilledTypedArray(metadata.dtype, length, noData)
|
|
966
|
+
: Array.from({length: bandCount}, () =>
|
|
967
|
+
createFilledTypedArray(metadata.dtype, length, noData)
|
|
968
|
+
);
|
|
969
|
+
|
|
970
|
+
return {
|
|
971
|
+
data,
|
|
972
|
+
width: parameters.width,
|
|
973
|
+
height: parameters.height,
|
|
974
|
+
bandCount,
|
|
975
|
+
dtype: metadata.dtype,
|
|
976
|
+
interleaved,
|
|
977
|
+
noData: metadata.noData,
|
|
978
|
+
boundingBox: parameters.bounds,
|
|
979
|
+
crs: metadata.crs,
|
|
980
|
+
metadata: metadata.metadata,
|
|
981
|
+
bands: (parameters.bands ?? Array.from({length: bandCount}, (_, index) => index)).map(index =>
|
|
982
|
+
metadata.bands?.[index]
|
|
983
|
+
? {...metadata.bands[index]}
|
|
984
|
+
: {index, dtype: metadata.dtype, noData: metadata.noData}
|
|
985
|
+
),
|
|
986
|
+
transform: createRegionTransform(parameters.bounds, parameters.width, parameters.height),
|
|
987
|
+
pixelRegistration: 'area',
|
|
988
|
+
provenance: {sourceType: 'geotiff'},
|
|
989
|
+
ownership: 'owned'
|
|
990
|
+
};
|
|
991
|
+
}
|
|
992
|
+
|
|
993
|
+
/** Allocates a typed array for the requested raster channel type and fills it with one value. */
|
|
994
|
+
function createFilledTypedArray(
|
|
995
|
+
dtype: RasterChannelDataType,
|
|
996
|
+
length: number,
|
|
997
|
+
fillValue: number
|
|
998
|
+
): TypedArray {
|
|
999
|
+
switch (dtype) {
|
|
1000
|
+
case 'uint8':
|
|
1001
|
+
return new Uint8Array(length).fill(fillValue);
|
|
1002
|
+
case 'uint16':
|
|
1003
|
+
return new Uint16Array(length).fill(fillValue);
|
|
1004
|
+
case 'uint32':
|
|
1005
|
+
return new Uint32Array(length).fill(fillValue);
|
|
1006
|
+
case 'int8':
|
|
1007
|
+
return new Int8Array(length).fill(fillValue);
|
|
1008
|
+
case 'int16':
|
|
1009
|
+
return new Int16Array(length).fill(fillValue);
|
|
1010
|
+
case 'int32':
|
|
1011
|
+
return new Int32Array(length).fill(fillValue);
|
|
1012
|
+
case 'float32':
|
|
1013
|
+
return new Float32Array(length).fill(fillValue);
|
|
1014
|
+
case 'float64':
|
|
1015
|
+
return new Float64Array(length).fill(fillValue);
|
|
1016
|
+
default:
|
|
1017
|
+
return new Uint8Array(length).fill(fillValue);
|
|
1018
|
+
}
|
|
1019
|
+
}
|
|
1020
|
+
|
|
1021
|
+
/** Converts GeoTIFF `readRasters()` output into the public `RasterData.data` union shape. */
|
|
1022
|
+
function normalizeRasterReadResult(
|
|
1023
|
+
raster: GeoTIFFReadRasterResult,
|
|
1024
|
+
interleaved: boolean
|
|
1025
|
+
): RasterData['data'] {
|
|
1026
|
+
if (interleaved) {
|
|
1027
|
+
return raster as unknown as RasterData['data'];
|
|
1028
|
+
}
|
|
1029
|
+
|
|
1030
|
+
if (Array.isArray(raster)) {
|
|
1031
|
+
return raster.length === 1 ? raster[0] : raster;
|
|
1032
|
+
}
|
|
1033
|
+
|
|
1034
|
+
return [raster as unknown as TypedArray];
|
|
1035
|
+
}
|
|
1036
|
+
|
|
1037
|
+
/** Resolves a human-readable dataset name from the source input when possible. */
|
|
1038
|
+
function getGeoTIFFName(data: string | Blob): string | undefined {
|
|
1039
|
+
if (typeof data !== 'string') {
|
|
1040
|
+
return undefined;
|
|
1041
|
+
}
|
|
1042
|
+
|
|
1043
|
+
const [path] = data.split(/[?#]/);
|
|
1044
|
+
return path.split('/').pop() || undefined;
|
|
1045
|
+
}
|
|
1046
|
+
|
|
1047
|
+
/** Returns the source-coordinate bounds advertised by a GeoTIFF image. */
|
|
1048
|
+
function getImageBoundingBox(image: TiffSourceImage): RasterBoundingBox | undefined {
|
|
1049
|
+
try {
|
|
1050
|
+
const [minX, minY, maxX, maxY] = image.getBoundingBox();
|
|
1051
|
+
return [
|
|
1052
|
+
[minX, minY],
|
|
1053
|
+
[maxX, maxY]
|
|
1054
|
+
];
|
|
1055
|
+
} catch {
|
|
1056
|
+
return undefined;
|
|
1057
|
+
}
|
|
1058
|
+
}
|
|
1059
|
+
|
|
1060
|
+
/** Estimates overview resolution relative to the full-resolution reference image. */
|
|
1061
|
+
function getImageResolution(
|
|
1062
|
+
image: TiffSourceImage,
|
|
1063
|
+
referenceImage: TiffSourceImage
|
|
1064
|
+
): [number, number] | undefined {
|
|
1065
|
+
const transform = getImageTransform(image, referenceImage);
|
|
1066
|
+
if (transform) {
|
|
1067
|
+
return [
|
|
1068
|
+
transform[3] === 0 ? transform[0] : Math.hypot(transform[0], transform[3]),
|
|
1069
|
+
transform[1] === 0 ? transform[4] : Math.hypot(transform[1], transform[4])
|
|
1070
|
+
];
|
|
1071
|
+
}
|
|
1072
|
+
try {
|
|
1073
|
+
const resolution = image.getResolution(referenceImage);
|
|
1074
|
+
return [resolution[0], resolution[1]];
|
|
1075
|
+
} catch {
|
|
1076
|
+
return undefined;
|
|
1077
|
+
}
|
|
1078
|
+
}
|
|
1079
|
+
|
|
1080
|
+
/** Returns a normalized CRS string for the GeoTIFF image when one is available. */
|
|
1081
|
+
function getImageCRS(image: TiffSourceImage): CRSIdentifier | undefined {
|
|
1082
|
+
const geoKeys = image.getGeoKeys?.();
|
|
1083
|
+
const projectedCrs = geoKeys?.ProjectedCSTypeGeoKey;
|
|
1084
|
+
if (projectedCrs || geoKeys?.GTModelTypeGeoKey === 1) {
|
|
1085
|
+
return projectedCrs && projectedCrs !== 32767 ? `EPSG:${projectedCrs}` : undefined;
|
|
1086
|
+
}
|
|
1087
|
+
|
|
1088
|
+
const geographicCrs = geoKeys?.GeographicTypeGeoKey;
|
|
1089
|
+
if (geographicCrs && geographicCrs !== 32767) {
|
|
1090
|
+
return `EPSG:${geographicCrs}`;
|
|
1091
|
+
}
|
|
1092
|
+
|
|
1093
|
+
return undefined;
|
|
1094
|
+
}
|
|
1095
|
+
|
|
1096
|
+
/** Converts GeoTIFF sample-format metadata to a public raster channel data type. */
|
|
1097
|
+
function getImageDataType(image: TiffSourceImage, index = 0): RasterChannelDataType {
|
|
1098
|
+
const bitsPerSample = normalizeSampleValue(image.getBitsPerSample(index));
|
|
1099
|
+
const sampleFormat = normalizeSampleValue(image.getSampleFormat(index));
|
|
1100
|
+
|
|
1101
|
+
switch (sampleFormat) {
|
|
1102
|
+
case 1:
|
|
1103
|
+
switch (bitsPerSample) {
|
|
1104
|
+
case 8:
|
|
1105
|
+
return 'uint8';
|
|
1106
|
+
case 16:
|
|
1107
|
+
return 'uint16';
|
|
1108
|
+
case 32:
|
|
1109
|
+
return 'uint32';
|
|
1110
|
+
default:
|
|
1111
|
+
break;
|
|
1112
|
+
}
|
|
1113
|
+
break;
|
|
1114
|
+
|
|
1115
|
+
case 2:
|
|
1116
|
+
switch (bitsPerSample) {
|
|
1117
|
+
case 8:
|
|
1118
|
+
return 'int8';
|
|
1119
|
+
case 16:
|
|
1120
|
+
return 'int16';
|
|
1121
|
+
case 32:
|
|
1122
|
+
return 'int32';
|
|
1123
|
+
default:
|
|
1124
|
+
break;
|
|
1125
|
+
}
|
|
1126
|
+
break;
|
|
1127
|
+
|
|
1128
|
+
case 3:
|
|
1129
|
+
switch (bitsPerSample) {
|
|
1130
|
+
case 32:
|
|
1131
|
+
return 'float32';
|
|
1132
|
+
case 64:
|
|
1133
|
+
return 'float64';
|
|
1134
|
+
default:
|
|
1135
|
+
break;
|
|
1136
|
+
}
|
|
1137
|
+
break;
|
|
1138
|
+
|
|
1139
|
+
default:
|
|
1140
|
+
break;
|
|
1141
|
+
}
|
|
1142
|
+
|
|
1143
|
+
throw new Error(
|
|
1144
|
+
`GeoTIFFRasterSource does not support sample format ${sampleFormat} with ${bitsPerSample} bits.`
|
|
1145
|
+
);
|
|
1146
|
+
}
|
|
1147
|
+
|
|
1148
|
+
/** Normalizes single-value or per-sample TIFF metadata arrays to the first sample value. */
|
|
1149
|
+
function normalizeSampleValue(value: number | number[]): number {
|
|
1150
|
+
return Array.isArray(value) ? value[0] : value;
|
|
1151
|
+
}
|
|
1152
|
+
|
|
1153
|
+
/** Encoded byte slice requested by TIFF directory and sample readers. */
|
|
1154
|
+
type GeoTIFFRangeSlice = {
|
|
1155
|
+
/** Starting byte offset. */
|
|
1156
|
+
offset: number;
|
|
1157
|
+
/** Requested byte length. */
|
|
1158
|
+
length: number;
|
|
1159
|
+
};
|
|
1160
|
+
|
|
1161
|
+
type GeoTIFFRangeSchedulerClientProps = {
|
|
1162
|
+
url: string;
|
|
1163
|
+
fetch: (url: string, options?: RequestInit) => Promise<Response>;
|
|
1164
|
+
sourceId: string;
|
|
1165
|
+
/** Requires readable range placement and authoritative EOF metadata. */
|
|
1166
|
+
requireContentRange?: boolean;
|
|
1167
|
+
headers?: HeadersInit;
|
|
1168
|
+
rangeScheduler: RangeRequestScheduler;
|
|
1169
|
+
/** Source-owned encoded byte cache. */
|
|
1170
|
+
rangeCache: RangeRequestCache;
|
|
1171
|
+
/** Maximum concurrent logical client requests, including shared cache subscribers. */
|
|
1172
|
+
maxPendingRequests: number;
|
|
1173
|
+
/** Invalidates only the source owning this client when remote revision metadata changes. */
|
|
1174
|
+
onRevisionChange?: (error: Error) => void;
|
|
1175
|
+
/** Supplies the shared discovery signal only while initialization is active. */
|
|
1176
|
+
getInitializationSignal?: () => AbortSignal | undefined;
|
|
1177
|
+
};
|
|
1178
|
+
|
|
1179
|
+
/** Minimal geotiff.js client backed by loaders.gl fetch and range scheduling. */
|
|
1180
|
+
class GeoTIFFRangeSchedulerClient {
|
|
1181
|
+
readonly url: string;
|
|
1182
|
+
|
|
1183
|
+
private readonly fetch: GeoTIFFRangeSchedulerClientProps['fetch'];
|
|
1184
|
+
/** Strict browser profiles require the server to expose range placement metadata. */
|
|
1185
|
+
private readonly requireContentRange: boolean;
|
|
1186
|
+
private readonly sourceId: string;
|
|
1187
|
+
private readonly defaultHeaders?: HeadersInit;
|
|
1188
|
+
private readonly rangeScheduler: RangeRequestScheduler;
|
|
1189
|
+
private readonly schedulerIsolationKey = {};
|
|
1190
|
+
/** Source-owned cache; never shared across authorization or source instances. */
|
|
1191
|
+
private readonly rangeCache: RangeRequestCache;
|
|
1192
|
+
/** Admission limit includes every logical cache subscriber. */
|
|
1193
|
+
private readonly maxPendingRequests: number;
|
|
1194
|
+
/** Number of logical requests awaiting transfer or a cache entry. */
|
|
1195
|
+
private pendingRequests = 0;
|
|
1196
|
+
private fileSize: number | null = null;
|
|
1197
|
+
/** Remote object revision headers remain private to cache identity. */
|
|
1198
|
+
private entityTag: string | null = null;
|
|
1199
|
+
/** Optional fallback revision hint, compared only when both responses declare it. */
|
|
1200
|
+
private lastModified: string | null = null;
|
|
1201
|
+
/** Invalidates owned source work without disposing a borrowed scheduler. */
|
|
1202
|
+
private readonly onRevisionChange?: (error: Error) => void;
|
|
1203
|
+
/** Discovery cancellation for geotiff.js directory reads without their own signal. */
|
|
1204
|
+
private readonly getInitializationSignal?: () => AbortSignal | undefined;
|
|
1205
|
+
|
|
1206
|
+
/** Creates a new range-scheduled GeoTIFF client. */
|
|
1207
|
+
constructor(props: GeoTIFFRangeSchedulerClientProps) {
|
|
1208
|
+
this.url = props.url;
|
|
1209
|
+
this.fetch = props.fetch;
|
|
1210
|
+
this.requireContentRange = props.requireContentRange ?? false;
|
|
1211
|
+
this.sourceId = props.sourceId;
|
|
1212
|
+
this.defaultHeaders = new Headers(props.headers);
|
|
1213
|
+
this.rangeCache = props.rangeCache;
|
|
1214
|
+
this.maxPendingRequests = props.maxPendingRequests;
|
|
1215
|
+
this.rangeScheduler = props.rangeScheduler;
|
|
1216
|
+
this.getInitializationSignal = props.getInitializationSignal;
|
|
1217
|
+
this.onRevisionChange = props.onRevisionChange;
|
|
1218
|
+
}
|
|
1219
|
+
|
|
1220
|
+
/** Returns the validated remote file size, when available. */
|
|
1221
|
+
getFileSize(): number | null {
|
|
1222
|
+
return this.fileSize;
|
|
1223
|
+
}
|
|
1224
|
+
|
|
1225
|
+
/** Returns standalone buffers in the order required by geotiff.js's source protocol. */
|
|
1226
|
+
async readRanges(slices: GeoTIFFRangeSlice[], signal?: AbortSignal): Promise<ArrayBuffer[]> {
|
|
1227
|
+
return Promise.all(
|
|
1228
|
+
slices.map(slice =>
|
|
1229
|
+
this.request({
|
|
1230
|
+
headers: createRangeRequestHeaders(new Headers(), slice.offset, slice.length),
|
|
1231
|
+
signal
|
|
1232
|
+
})
|
|
1233
|
+
)
|
|
1234
|
+
);
|
|
1235
|
+
}
|
|
1236
|
+
|
|
1237
|
+
/** Executes one geotiff.js byte-range request through the shared scheduler. */
|
|
1238
|
+
async request({
|
|
1239
|
+
headers,
|
|
1240
|
+
signal
|
|
1241
|
+
}: {
|
|
1242
|
+
headers?: HeadersInit;
|
|
1243
|
+
signal?: AbortSignal;
|
|
1244
|
+
} = {}): Promise<ArrayBuffer> {
|
|
1245
|
+
signal ??= this.getInitializationSignal?.();
|
|
1246
|
+
signal?.throwIfAborted();
|
|
1247
|
+
if (this.pendingRequests >= this.maxPendingRequests)
|
|
1248
|
+
throw new Error('GeoTIFF request queue limit exceeded');
|
|
1249
|
+
this.pendingRequests++;
|
|
1250
|
+
try {
|
|
1251
|
+
const mergedHeaders = new Headers(this.defaultHeaders);
|
|
1252
|
+
new Headers(headers).forEach((value, key) => mergedHeaders.set(key, value));
|
|
1253
|
+
const {offset, length} = parseSingleRangeHeader(mergedHeaders.get('Range'));
|
|
1254
|
+
const requestHeaders = new Headers(mergedHeaders);
|
|
1255
|
+
requestHeaders.delete('Range');
|
|
1256
|
+
const readRange = (rangeOffset: number, rangeLength: number, rangeSignal?: AbortSignal) =>
|
|
1257
|
+
this.rangeScheduler.scheduleRequest({
|
|
1258
|
+
sourceId: this.sourceId,
|
|
1259
|
+
isolationKey: this.schedulerIsolationKey,
|
|
1260
|
+
offset: rangeOffset,
|
|
1261
|
+
length: rangeLength,
|
|
1262
|
+
signal: rangeSignal,
|
|
1263
|
+
fetchRange: (transportOffset, transportLength, transportSignal) =>
|
|
1264
|
+
this._fetchRange(transportOffset, transportLength, requestHeaders, transportSignal)
|
|
1265
|
+
});
|
|
1266
|
+
let arrayBuffer: ArrayBuffer;
|
|
1267
|
+
if (this.fileSize === null) {
|
|
1268
|
+
// The first read can be shorter at EOF; it discovers the immutable file size.
|
|
1269
|
+
arrayBuffer = await readRange(offset, length, signal);
|
|
1270
|
+
this.rangeCache.set(this.sourceId, offset, arrayBuffer);
|
|
1271
|
+
} else {
|
|
1272
|
+
const boundedLength =
|
|
1273
|
+
offset < this.fileSize ? Math.min(length, this.fileSize - offset) : length;
|
|
1274
|
+
arrayBuffer = await this.rangeCache.read({
|
|
1275
|
+
sourceId: this.sourceId,
|
|
1276
|
+
offset,
|
|
1277
|
+
length: boundedLength,
|
|
1278
|
+
signal,
|
|
1279
|
+
fetchRange: readRange
|
|
1280
|
+
});
|
|
1281
|
+
}
|
|
1282
|
+
signal?.throwIfAborted();
|
|
1283
|
+
|
|
1284
|
+
return arrayBuffer;
|
|
1285
|
+
} finally {
|
|
1286
|
+
this.pendingRequests--;
|
|
1287
|
+
}
|
|
1288
|
+
}
|
|
1289
|
+
|
|
1290
|
+
/** Fetches one transport range from the remote GeoTIFF. */
|
|
1291
|
+
private async _fetchRange(
|
|
1292
|
+
offset: number,
|
|
1293
|
+
length: number,
|
|
1294
|
+
headers: Headers,
|
|
1295
|
+
signal?: AbortSignal
|
|
1296
|
+
): Promise<RangeRequestTransportResult> {
|
|
1297
|
+
let response = await this.fetch(this.url, {
|
|
1298
|
+
headers: createRangeRequestHeaders(headers, offset, length),
|
|
1299
|
+
signal
|
|
1300
|
+
});
|
|
1301
|
+
|
|
1302
|
+
if (response.status === 416 && offset === 0) {
|
|
1303
|
+
const actualLength = parseUnsatisfiedContentRange(response.headers.get('Content-Range'));
|
|
1304
|
+
if (!actualLength || !Number.isSafeInteger(actualLength) || actualLength > length) {
|
|
1305
|
+
throw new Error('Missing content-length on 416 response');
|
|
1306
|
+
}
|
|
1307
|
+
await response.body?.cancel().catch(() => {});
|
|
1308
|
+
response = await this.fetch(this.url, {
|
|
1309
|
+
headers: createRangeRequestHeaders(headers, 0, actualLength),
|
|
1310
|
+
signal
|
|
1311
|
+
});
|
|
1312
|
+
}
|
|
1313
|
+
|
|
1314
|
+
if (response.status === 200) {
|
|
1315
|
+
await response.body?.cancel().catch(() => {});
|
|
1316
|
+
throw new Error('Byte-range request failed: server returned 200 instead of 206');
|
|
1317
|
+
}
|
|
1318
|
+
|
|
1319
|
+
if (response.status !== 206) {
|
|
1320
|
+
await response.body?.cancel().catch(() => {});
|
|
1321
|
+
throw new Error(`Bad response code: ${response.status}`);
|
|
1322
|
+
}
|
|
1323
|
+
|
|
1324
|
+
let total: number | null;
|
|
1325
|
+
try {
|
|
1326
|
+
const contentRange = response.headers.get('Content-Range');
|
|
1327
|
+
if (this.requireContentRange && !contentRange)
|
|
1328
|
+
throw new Error(
|
|
1329
|
+
'GeoTIFF range responses require an exposed Content-Range header; configure Access-Control-Expose-Headers: Content-Range.'
|
|
1330
|
+
);
|
|
1331
|
+
total = validateGeoTIFFContentRange(contentRange, offset, length);
|
|
1332
|
+
const entityTag = response.headers.get('ETag');
|
|
1333
|
+
const lastModified = response.headers.get('Last-Modified');
|
|
1334
|
+
if (
|
|
1335
|
+
(this.fileSize !== null && total !== null && this.fileSize !== total) ||
|
|
1336
|
+
(this.entityTag && entityTag && this.entityTag !== entityTag) ||
|
|
1337
|
+
(this.lastModified && lastModified && this.lastModified !== lastModified)
|
|
1338
|
+
) {
|
|
1339
|
+
const error = new Error('Remote GeoTIFF revision changed; recreate the source');
|
|
1340
|
+
this.onRevisionChange?.(error);
|
|
1341
|
+
throw error;
|
|
1342
|
+
}
|
|
1343
|
+
if (total !== null) this.fileSize = total;
|
|
1344
|
+
this.entityTag ??= entityTag;
|
|
1345
|
+
this.lastModified ??= lastModified;
|
|
1346
|
+
} catch (error) {
|
|
1347
|
+
await response.body?.cancel().catch(() => {});
|
|
1348
|
+
throw error;
|
|
1349
|
+
}
|
|
1350
|
+
const arrayBuffer = await readGeoTIFFRangeResponse(response, length, signal);
|
|
1351
|
+
return {
|
|
1352
|
+
arrayBuffer,
|
|
1353
|
+
status: response.status,
|
|
1354
|
+
sourceByteLength: this.fileSize ?? undefined,
|
|
1355
|
+
transportBytes: arrayBuffer.byteLength
|
|
1356
|
+
};
|
|
1357
|
+
}
|
|
1358
|
+
}
|
|
1359
|
+
|
|
1360
|
+
/** Creates the HTTP headers for one byte-range request. */
|
|
1361
|
+
function createRangeRequestHeaders(headers: Headers, offset: number, length: number): Headers {
|
|
1362
|
+
const requestHeaders = new Headers(headers);
|
|
1363
|
+
requestHeaders.set('Range', `bytes=${offset}-${offset + length - 1}`);
|
|
1364
|
+
return requestHeaders;
|
|
1365
|
+
}
|
|
1366
|
+
|
|
1367
|
+
/** Parses one single-range `Range` header into offset and byte length. */
|
|
1368
|
+
function parseSingleRangeHeader(rangeHeader: string | null): {offset: number; length: number} {
|
|
1369
|
+
const match = rangeHeader?.match(/^bytes=(\d+)-(\d+)$/);
|
|
1370
|
+
if (!match) {
|
|
1371
|
+
throw new Error(`GeoTIFF range request requires a single byte range. Received: ${rangeHeader}`);
|
|
1372
|
+
}
|
|
1373
|
+
|
|
1374
|
+
const offset = Number(match[1]);
|
|
1375
|
+
const endOffset = Number(match[2]);
|
|
1376
|
+
if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(endOffset) || endOffset < offset)
|
|
1377
|
+
throw new Error('Invalid GeoTIFF byte range');
|
|
1378
|
+
return {offset, length: endOffset - offset + 1};
|
|
1379
|
+
}
|
|
1380
|
+
|
|
1381
|
+
/** Validates response placement and optional object length before any encoded bytes are buffered. */
|
|
1382
|
+
function validateGeoTIFFContentRange(
|
|
1383
|
+
contentRange: string | null,
|
|
1384
|
+
offset: number,
|
|
1385
|
+
length: number
|
|
1386
|
+
): number | null {
|
|
1387
|
+
if (!contentRange) return null; // CORS may hide this response header.
|
|
1388
|
+
const match = contentRange.match(/^bytes (\d+)-(\d+)\/(\d+|\*)$/);
|
|
1389
|
+
if (!match) throw new Error('Invalid GeoTIFF Content-Range');
|
|
1390
|
+
const start = Number(match[1]);
|
|
1391
|
+
const end = Number(match[2]);
|
|
1392
|
+
const total = match[3] === '*' ? null : Number(match[3]);
|
|
1393
|
+
if (
|
|
1394
|
+
![start, end].every(Number.isSafeInteger) ||
|
|
1395
|
+
start !== offset ||
|
|
1396
|
+
end < start ||
|
|
1397
|
+
(total !== null && (!Number.isSafeInteger(total) || total <= end)) ||
|
|
1398
|
+
end !== Math.min(offset + length - 1, total === null ? Infinity : total - 1)
|
|
1399
|
+
)
|
|
1400
|
+
throw new Error('Contradictory GeoTIFF Content-Range');
|
|
1401
|
+
return total;
|
|
1402
|
+
}
|
|
1403
|
+
|
|
1404
|
+
/** Reads at most one requested range, canceling lying or obsolete streams without buffering a whole asset. */
|
|
1405
|
+
async function readGeoTIFFRangeResponse(
|
|
1406
|
+
response: Response,
|
|
1407
|
+
maximumBytes: number,
|
|
1408
|
+
signal?: AbortSignal
|
|
1409
|
+
): Promise<ArrayBuffer> {
|
|
1410
|
+
if (!response.body) return new ArrayBuffer(0);
|
|
1411
|
+
const reader = response.body.getReader();
|
|
1412
|
+
const bytes = new Uint8Array(maximumBytes);
|
|
1413
|
+
let writtenBytes = 0;
|
|
1414
|
+
try {
|
|
1415
|
+
while (true) {
|
|
1416
|
+
const chunk = await waitForPromiseWithSignal(reader.read(), signal);
|
|
1417
|
+
if (chunk.done) break;
|
|
1418
|
+
if (writtenBytes + chunk.value.byteLength > maximumBytes)
|
|
1419
|
+
throw new Error('GeoTIFF range response exceeds byte budget');
|
|
1420
|
+
bytes.set(chunk.value, writtenBytes);
|
|
1421
|
+
writtenBytes += chunk.value.byteLength;
|
|
1422
|
+
}
|
|
1423
|
+
signal?.throwIfAborted();
|
|
1424
|
+
return writtenBytes === maximumBytes ? bytes.buffer : bytes.buffer.slice(0, writtenBytes);
|
|
1425
|
+
} finally {
|
|
1426
|
+
await reader.cancel().catch(() => {});
|
|
1427
|
+
reader.releaseLock();
|
|
1428
|
+
}
|
|
1429
|
+
}
|
|
1430
|
+
|
|
1431
|
+
/** Parses the file length from a `416 Range Not Satisfiable` `Content-Range` header. */
|
|
1432
|
+
function parseUnsatisfiedContentRange(contentRange: string | null): number | null {
|
|
1433
|
+
const match = contentRange?.match(/^bytes \*\/(\d+)$/);
|
|
1434
|
+
return match ? Number(match[1]) : null;
|
|
1435
|
+
}
|
|
1436
|
+
|
|
1437
|
+
/** Preserves TIFF rotation/shear, or resolves the explicit origin and signed pixel spacing. */
|
|
1438
|
+
function getImageTransform(
|
|
1439
|
+
image: TiffSourceImage,
|
|
1440
|
+
referenceImage: TiffSourceImage
|
|
1441
|
+
): RasterAffineTransform | undefined {
|
|
1442
|
+
const matrix = image.fileDirectory?.ModelTransformation;
|
|
1443
|
+
if (matrix) return [matrix[0], matrix[1], matrix[3], matrix[4], matrix[5], matrix[7]];
|
|
1444
|
+
if (
|
|
1445
|
+
image !== referenceImage &&
|
|
1446
|
+
!image.fileDirectory?.ModelTiepoint &&
|
|
1447
|
+
!image.fileDirectory?.ModelPixelScale
|
|
1448
|
+
) {
|
|
1449
|
+
const referenceTransform = getImageTransform(referenceImage, referenceImage);
|
|
1450
|
+
if (referenceTransform) {
|
|
1451
|
+
const scaleX = referenceImage.getWidth() / image.getWidth();
|
|
1452
|
+
const scaleY = referenceImage.getHeight() / image.getHeight();
|
|
1453
|
+
return [
|
|
1454
|
+
referenceTransform[0] * scaleX,
|
|
1455
|
+
referenceTransform[1] * scaleY,
|
|
1456
|
+
referenceTransform[2],
|
|
1457
|
+
referenceTransform[3] * scaleX,
|
|
1458
|
+
referenceTransform[4] * scaleY,
|
|
1459
|
+
referenceTransform[5]
|
|
1460
|
+
];
|
|
1461
|
+
}
|
|
1462
|
+
}
|
|
1463
|
+
try {
|
|
1464
|
+
const resolution = image.getResolution(referenceImage);
|
|
1465
|
+
let origin: number[];
|
|
1466
|
+
try {
|
|
1467
|
+
origin = image.getOrigin();
|
|
1468
|
+
} catch {
|
|
1469
|
+
origin = referenceImage.getOrigin();
|
|
1470
|
+
}
|
|
1471
|
+
const tiepoint = image.fileDirectory?.ModelTiepoint;
|
|
1472
|
+
return [
|
|
1473
|
+
resolution[0],
|
|
1474
|
+
0,
|
|
1475
|
+
origin[0] - (tiepoint?.[0] ?? 0) * resolution[0],
|
|
1476
|
+
0,
|
|
1477
|
+
resolution[1],
|
|
1478
|
+
origin[1] - (tiepoint?.[1] ?? 0) * resolution[1]
|
|
1479
|
+
];
|
|
1480
|
+
} catch {
|
|
1481
|
+
return undefined;
|
|
1482
|
+
}
|
|
1483
|
+
}
|
|
1484
|
+
|
|
1485
|
+
/** Parses finite numeric metadata without interpreting empty content as zero. */
|
|
1486
|
+
function parseFiniteMetadataValue(value: unknown): number | undefined {
|
|
1487
|
+
if (typeof value !== 'number' && typeof value !== 'string') return undefined;
|
|
1488
|
+
if (typeof value === 'string' && !value.trim()) return undefined;
|
|
1489
|
+
const numericValue = Number(value);
|
|
1490
|
+
return Number.isFinite(numericValue) ? numericValue : undefined;
|
|
1491
|
+
}
|
|
1492
|
+
|
|
1493
|
+
/** Interprets optional GDAL band attributes while retaining samples in the raw domain. */
|
|
1494
|
+
function getImageBandMetadata(
|
|
1495
|
+
image: TiffSourceImage,
|
|
1496
|
+
index: number,
|
|
1497
|
+
noData: number | null
|
|
1498
|
+
): RasterBandMetadata {
|
|
1499
|
+
const metadata = image.getGDALMetadata?.(index) || {};
|
|
1500
|
+
const scale = parseFiniteMetadataValue(metadata.SCALE);
|
|
1501
|
+
const offset = parseFiniteMetadataValue(metadata.OFFSET);
|
|
1502
|
+
if (
|
|
1503
|
+
(metadata.SCALE !== undefined && scale === undefined) ||
|
|
1504
|
+
(metadata.OFFSET !== undefined && offset === undefined)
|
|
1505
|
+
)
|
|
1506
|
+
throw new Error('Invalid GDAL band scale or offset');
|
|
1507
|
+
const minimumValue = parseFiniteMetadataValue(metadata.STATISTICS_MINIMUM);
|
|
1508
|
+
const maximumValue = parseFiniteMetadataValue(metadata.STATISTICS_MAXIMUM);
|
|
1509
|
+
const hasMinimum = minimumValue !== undefined;
|
|
1510
|
+
const hasMaximum = maximumValue !== undefined;
|
|
1511
|
+
const hasDeclaredRange =
|
|
1512
|
+
(hasMinimum || hasMaximum) && !(hasMinimum && hasMaximum && minimumValue > maximumValue);
|
|
1513
|
+
return {
|
|
1514
|
+
index,
|
|
1515
|
+
declaredStatistics: hasDeclaredRange
|
|
1516
|
+
? {
|
|
1517
|
+
band: index,
|
|
1518
|
+
domain: 'unknown',
|
|
1519
|
+
scope: 'source',
|
|
1520
|
+
method: 'declared',
|
|
1521
|
+
min: hasMinimum ? minimumValue : undefined,
|
|
1522
|
+
max: hasMaximum ? maximumValue : undefined
|
|
1523
|
+
}
|
|
1524
|
+
: undefined,
|
|
1525
|
+
dtype: getImageDataType(image, index),
|
|
1526
|
+
categorical:
|
|
1527
|
+
index === 0 && image.fileDirectory?.PhotometricInterpretation === 3 ? true : undefined,
|
|
1528
|
+
name: typeof metadata.DESCRIPTION === 'string' ? metadata.DESCRIPTION : undefined,
|
|
1529
|
+
units: typeof metadata.UNITTYPE === 'string' ? metadata.UNITTYPE : undefined,
|
|
1530
|
+
scale,
|
|
1531
|
+
offset,
|
|
1532
|
+
noData
|
|
1533
|
+
};
|
|
1534
|
+
}
|
|
1535
|
+
|
|
1536
|
+
/** Resamples native windows with shared raw-domain validity; yields between row groups for cancellation. */
|
|
1537
|
+
async function resizeRasterWindow(
|
|
1538
|
+
nativeRaster: GeoTIFFReadRasterResult,
|
|
1539
|
+
bands: RasterBandMetadata[],
|
|
1540
|
+
interleaved: boolean,
|
|
1541
|
+
targetSize: {width: number; height: number},
|
|
1542
|
+
method: 'nearest' | 'bilinear',
|
|
1543
|
+
signal?: AbortSignal,
|
|
1544
|
+
nativeValidityMasks?: RasterData['validityMasks']
|
|
1545
|
+
): Promise<{raster: GeoTIFFReadRasterResult; validityMasks?: RasterData['validityMasks']}> {
|
|
1546
|
+
signal?.throwIfAborted();
|
|
1547
|
+
if (nativeRaster.width === targetSize.width && nativeRaster.height === targetSize.height) {
|
|
1548
|
+
const raster = interleaved
|
|
1549
|
+
? await interleaveRasterBands(nativeRaster, bands[0].dtype, signal)
|
|
1550
|
+
: nativeRaster;
|
|
1551
|
+
return {raster, validityMasks: nativeValidityMasks};
|
|
1552
|
+
}
|
|
1553
|
+
const data = normalizeRasterReadResult(nativeRaster, false);
|
|
1554
|
+
const mixed = bands.some(band => band.dtype !== bands[0].dtype);
|
|
1555
|
+
const input = {
|
|
1556
|
+
data,
|
|
1557
|
+
dtype: mixed ? 'mixed' : bands[0].dtype,
|
|
1558
|
+
interleaved: false,
|
|
1559
|
+
width: nativeRaster.width,
|
|
1560
|
+
height: nativeRaster.height,
|
|
1561
|
+
bandCount: bands.length,
|
|
1562
|
+
bands,
|
|
1563
|
+
validityMasks: nativeValidityMasks
|
|
1564
|
+
} as NumericRasterData;
|
|
1565
|
+
const pixelCount = targetSize.width * targetSize.height;
|
|
1566
|
+
const output = interleaved
|
|
1567
|
+
? createFilledTypedArray(bands[0].dtype, pixelCount * bands.length, 0)
|
|
1568
|
+
: bands.map(band => createFilledTypedArray(band.dtype, pixelCount, band.noData ?? 0));
|
|
1569
|
+
const validityMasks = bands.map((_band, band) => ({
|
|
1570
|
+
data: new Uint8Array(pixelCount),
|
|
1571
|
+
band,
|
|
1572
|
+
width: targetSize.width,
|
|
1573
|
+
height: targetSize.height,
|
|
1574
|
+
pixelStride: 1,
|
|
1575
|
+
rowStride: targetSize.width
|
|
1576
|
+
}));
|
|
1577
|
+
for (let row = 0; row < targetSize.height; row++) {
|
|
1578
|
+
for (let column = 0; column < targetSize.width; column++) {
|
|
1579
|
+
const pixelIndex = row * targetSize.width + column;
|
|
1580
|
+
if (pixelIndex % 32768 === 0) {
|
|
1581
|
+
signal?.throwIfAborted();
|
|
1582
|
+
if (pixelIndex > 0) await new Promise<void>(resolve => setTimeout(resolve, 0));
|
|
1583
|
+
signal?.throwIfAborted();
|
|
1584
|
+
}
|
|
1585
|
+
const sample = sampleRaster(
|
|
1586
|
+
input,
|
|
1587
|
+
[
|
|
1588
|
+
((column + 0.5) * nativeRaster.width) / targetSize.width - 0.5,
|
|
1589
|
+
((row + 0.5) * nativeRaster.height) / targetSize.height - 0.5
|
|
1590
|
+
],
|
|
1591
|
+
{method}
|
|
1592
|
+
);
|
|
1593
|
+
for (let band = 0; band < bands.length; band++) {
|
|
1594
|
+
const value = sample.values[band];
|
|
1595
|
+
if (value === undefined || !Number.isFinite(value)) continue;
|
|
1596
|
+
if (Array.isArray(output)) output[band][pixelIndex] = value;
|
|
1597
|
+
else output[pixelIndex * bands.length + band] = value;
|
|
1598
|
+
validityMasks[band].data[pixelIndex] = 1;
|
|
1599
|
+
}
|
|
1600
|
+
}
|
|
1601
|
+
}
|
|
1602
|
+
signal?.throwIfAborted();
|
|
1603
|
+
const raster = Object.assign(output, {
|
|
1604
|
+
width: targetSize.width,
|
|
1605
|
+
height: targetSize.height
|
|
1606
|
+
}) as GeoTIFFReadRasterResult;
|
|
1607
|
+
return {raster, validityMasks};
|
|
1608
|
+
}
|
|
1609
|
+
|
|
1610
|
+
/** Packs native planar bands without widening, scaling, or replacing invalid raw values. */
|
|
1611
|
+
async function interleaveRasterBands(
|
|
1612
|
+
raster: GeoTIFFReadRasterResult,
|
|
1613
|
+
dtype: RasterChannelDataType,
|
|
1614
|
+
signal?: AbortSignal
|
|
1615
|
+
): Promise<GeoTIFFReadRasterResult> {
|
|
1616
|
+
const arrays = Array.isArray(raster) ? raster : [raster];
|
|
1617
|
+
const pixelCount = raster.width * raster.height;
|
|
1618
|
+
const output = createFilledTypedArray(dtype, pixelCount * arrays.length, 0);
|
|
1619
|
+
for (let pixel = 0; pixel < pixelCount; pixel++) {
|
|
1620
|
+
if (pixel % 32768 === 0) {
|
|
1621
|
+
signal?.throwIfAborted();
|
|
1622
|
+
if (pixel > 0) await new Promise<void>(resolve => setTimeout(resolve, 0));
|
|
1623
|
+
signal?.throwIfAborted();
|
|
1624
|
+
}
|
|
1625
|
+
for (let band = 0; band < arrays.length; band++)
|
|
1626
|
+
output[pixel * arrays.length + band] = arrays[band][pixel];
|
|
1627
|
+
}
|
|
1628
|
+
signal?.throwIfAborted();
|
|
1629
|
+
return Object.assign(output, {
|
|
1630
|
+
width: raster.width,
|
|
1631
|
+
height: raster.height
|
|
1632
|
+
}) as GeoTIFFReadRasterResult;
|
|
1633
|
+
}
|
|
1634
|
+
|
|
1635
|
+
/** Describes an explicitly invalid output grid in the caller's declared source CRS. */
|
|
1636
|
+
function createRegionTransform(
|
|
1637
|
+
bounds: RasterBoundingBox,
|
|
1638
|
+
width: number,
|
|
1639
|
+
height: number
|
|
1640
|
+
): RasterAffineTransform {
|
|
1641
|
+
return [
|
|
1642
|
+
(bounds[1][0] - bounds[0][0]) / width,
|
|
1643
|
+
0,
|
|
1644
|
+
bounds[0][0],
|
|
1645
|
+
0,
|
|
1646
|
+
-(bounds[1][1] - bounds[0][1]) / height,
|
|
1647
|
+
bounds[1][1]
|
|
1648
|
+
];
|
|
1649
|
+
}
|
|
1650
|
+
|
|
1651
|
+
/** Estimates all concurrently decoded tiles intersecting a native window, including unselected channels. */
|
|
1652
|
+
function estimateImageTileBytes(
|
|
1653
|
+
image: TiffSourceImage,
|
|
1654
|
+
window: number[],
|
|
1655
|
+
bytesPerPixel: number
|
|
1656
|
+
): number {
|
|
1657
|
+
const tileWidth = image.getTileWidth?.() ?? window[2] - window[0];
|
|
1658
|
+
const tileHeight = image.getTileHeight?.() ?? window[3] - window[1];
|
|
1659
|
+
if (![tileWidth, tileHeight].every(value => Number.isSafeInteger(value) && value > 0))
|
|
1660
|
+
throw new Error('Invalid GeoTIFF tile dimensions');
|
|
1661
|
+
const columns = Math.ceil(window[2] / tileWidth) - Math.floor(window[0] / tileWidth);
|
|
1662
|
+
const rows = Math.ceil(window[3] / tileHeight) - Math.floor(window[1] / tileHeight);
|
|
1663
|
+
return columns * rows * tileWidth * tileHeight * bytesPerPixel;
|
|
1664
|
+
}
|
|
1665
|
+
|
|
1666
|
+
/** Builds native storage-tile geometry without decoding samples or treating strips as tiles. */
|
|
1667
|
+
export function getImageTileGrid(images: TiffSourceImage[], referenceImage: TiffSourceImage) {
|
|
1668
|
+
const coordinateReferenceSystem = getImageCRS(referenceImage);
|
|
1669
|
+
if (!coordinateReferenceSystem) return undefined;
|
|
1670
|
+
const matrices = images.flatMap((image, index) => {
|
|
1671
|
+
if (image.fileDirectory?.NewSubfileType & 4) return [];
|
|
1672
|
+
if (
|
|
1673
|
+
image !== referenceImage &&
|
|
1674
|
+
!(image.fileDirectory?.NewSubfileType & 1) &&
|
|
1675
|
+
image.fileDirectory?.SubfileType !== 2
|
|
1676
|
+
)
|
|
1677
|
+
return [];
|
|
1678
|
+
const transform = getImageTransform(image, referenceImage);
|
|
1679
|
+
const imageCoordinateReferenceSystem = getImageCRS(image);
|
|
1680
|
+
const imageCoordinateMetadata = image.getGeoKeys?.() || {};
|
|
1681
|
+
const hasDeclaredCoordinateReferenceSystem = Object.entries(imageCoordinateMetadata).some(
|
|
1682
|
+
([key, value]) => key !== 'GTRasterTypeGeoKey' && value !== undefined && value !== null
|
|
1683
|
+
);
|
|
1684
|
+
if (
|
|
1685
|
+
(hasDeclaredCoordinateReferenceSystem && !imageCoordinateReferenceSystem) ||
|
|
1686
|
+
(imageCoordinateReferenceSystem &&
|
|
1687
|
+
imageCoordinateReferenceSystem !== coordinateReferenceSystem) ||
|
|
1688
|
+
!image.fileDirectory?.TileWidth ||
|
|
1689
|
+
!image.fileDirectory?.TileLength ||
|
|
1690
|
+
!transform ||
|
|
1691
|
+
transform[1] !== 0 ||
|
|
1692
|
+
transform[3] !== 0 ||
|
|
1693
|
+
transform[0] <= 0 ||
|
|
1694
|
+
transform[4] === 0
|
|
1695
|
+
) {
|
|
1696
|
+
return [undefined];
|
|
1697
|
+
}
|
|
1698
|
+
const pointRegistration =
|
|
1699
|
+
(imageCoordinateMetadata.GTRasterTypeGeoKey ??
|
|
1700
|
+
referenceImage.getGeoKeys()?.GTRasterTypeGeoKey) === 2;
|
|
1701
|
+
const inheritedTransform =
|
|
1702
|
+
image !== referenceImage &&
|
|
1703
|
+
!image.fileDirectory.ModelTransformation &&
|
|
1704
|
+
!image.fileDirectory.ModelTiepoint &&
|
|
1705
|
+
!image.fileDirectory.ModelPixelScale;
|
|
1706
|
+
const cornerPointRegistration = inheritedTransform
|
|
1707
|
+
? referenceImage.getGeoKeys()?.GTRasterTypeGeoKey === 2
|
|
1708
|
+
: pointRegistration;
|
|
1709
|
+
const cornerTransform = inheritedTransform
|
|
1710
|
+
? getImageTransform(referenceImage, referenceImage)!
|
|
1711
|
+
: transform;
|
|
1712
|
+
return [
|
|
1713
|
+
createTileGridMatrix({
|
|
1714
|
+
id: String(index),
|
|
1715
|
+
resolution: transform[0],
|
|
1716
|
+
resolutionY: Math.abs(transform[4]),
|
|
1717
|
+
point: cornerPointRegistration
|
|
1718
|
+
? [
|
|
1719
|
+
cornerTransform[2] - cornerTransform[0] / 2,
|
|
1720
|
+
cornerTransform[5] - cornerTransform[4] / 2
|
|
1721
|
+
]
|
|
1722
|
+
: [cornerTransform[2], cornerTransform[5]],
|
|
1723
|
+
swapAxes: false,
|
|
1724
|
+
cornerOfOrigin: transform[4] < 0 ? 'topLeft' : 'bottomLeft',
|
|
1725
|
+
tileWidth: image.getTileWidth(),
|
|
1726
|
+
tileHeight: image.getTileHeight(),
|
|
1727
|
+
matrixWidth: Math.ceil(image.getWidth() / image.getTileWidth()),
|
|
1728
|
+
matrixHeight: Math.ceil(image.getHeight() / image.getTileHeight())
|
|
1729
|
+
})
|
|
1730
|
+
];
|
|
1731
|
+
});
|
|
1732
|
+
if (!matrices.length || matrices.some(matrix => !matrix)) return undefined;
|
|
1733
|
+
const grid = createTileGrid(
|
|
1734
|
+
coordinateReferenceSystem,
|
|
1735
|
+
matrices.filter(matrix => matrix !== undefined)
|
|
1736
|
+
);
|
|
1737
|
+
return grid.tileMatrixSet ? grid : undefined;
|
|
1738
|
+
}
|