@loaders.gl/raster 0.0.0-stage → 5.0.0-alpha.13
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/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 +17271 -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 +18238 -0
- package/package.json +344 -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,1322 @@
|
|
|
1
|
+
// loaders.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
import { openGeoTIFFSourceDecoder } from "./lib/tiff/geotiff-source-adapter.js";
|
|
5
|
+
import { createTileGrid, createTileGridMatrix, DataSource, getRasterViewportBoundingBox, RangeRequestScheduler, RangeRequestCache, waitForPromiseWithSignal, waitForPromiseWithSignals, sampleRaster, validateRasterRegion, createScanQueryMetadata } from '@loaders.gl/core/loader-utils';
|
|
6
|
+
import { GeoTIFFFormat } from "./geotiff-format.js";
|
|
7
|
+
// __VERSION__ is injected by babel-plugin-version-inline
|
|
8
|
+
// @ts-ignore TS2304: Cannot find name '__VERSION__'.
|
|
9
|
+
const VERSION = typeof "5.0.0-alpha.13" !== 'undefined' ? "5.0.0-alpha.13" : 'latest';
|
|
10
|
+
/** Common raster-query capabilities of GeoTIFF and COG sources. */
|
|
11
|
+
export const GEOTIFF_RASTER_QUERY_CAPABILITIES = Object.freeze({
|
|
12
|
+
bounds: 'pushdown',
|
|
13
|
+
level: 'pushdown',
|
|
14
|
+
variables: 'pushdown',
|
|
15
|
+
slices: 'unsupported',
|
|
16
|
+
streaming: false,
|
|
17
|
+
cancellation: true
|
|
18
|
+
});
|
|
19
|
+
/**
|
|
20
|
+
* Source factory for viewport-driven GeoTIFF datasets.
|
|
21
|
+
*/
|
|
22
|
+
export const GeoTIFFSourceLoader = {
|
|
23
|
+
dataType: null,
|
|
24
|
+
batchType: null,
|
|
25
|
+
...GeoTIFFFormat,
|
|
26
|
+
name: 'GeoTIFFSourceLoader',
|
|
27
|
+
version: VERSION,
|
|
28
|
+
type: 'geotiff',
|
|
29
|
+
fromUrl: true,
|
|
30
|
+
fromBlob: true,
|
|
31
|
+
options: {
|
|
32
|
+
geotiff: {
|
|
33
|
+
headers: undefined,
|
|
34
|
+
interleaved: false,
|
|
35
|
+
resampleMethod: 'nearest'
|
|
36
|
+
}
|
|
37
|
+
},
|
|
38
|
+
defaultOptions: {
|
|
39
|
+
geotiff: {
|
|
40
|
+
headers: undefined,
|
|
41
|
+
interleaved: false,
|
|
42
|
+
resampleMethod: 'nearest'
|
|
43
|
+
}
|
|
44
|
+
},
|
|
45
|
+
testURL: (url) => {
|
|
46
|
+
if (/\.ome\.tiff?(?:$|[?#])/i.test(url)) {
|
|
47
|
+
return false;
|
|
48
|
+
}
|
|
49
|
+
return /\.(?:geotiff?|tiff?)(?:$|[?#])/i.test(url);
|
|
50
|
+
},
|
|
51
|
+
createDataSource: (data, options) => new GeoTIFFRasterSource(data, options)
|
|
52
|
+
};
|
|
53
|
+
/**
|
|
54
|
+
* Viewport-driven raster source backed by a GeoTIFF dataset.
|
|
55
|
+
*/
|
|
56
|
+
export class GeoTIFFRasterSource extends DataSource {
|
|
57
|
+
/** Capabilities advertised by this viewport-driven raster source. */
|
|
58
|
+
rasterQueryCapabilities = GEOTIFF_RASTER_QUERY_CAPABILITIES;
|
|
59
|
+
/** Explicit numeric region support without a viewport dependency. */
|
|
60
|
+
supportsRegion = true;
|
|
61
|
+
_initPromise = null;
|
|
62
|
+
/** Shared metadata transport controller, with leases for concurrent callers. */
|
|
63
|
+
_initialization = null;
|
|
64
|
+
_rangeScheduler = null;
|
|
65
|
+
/** Bounded source-owned encoded byte cache with subscriber-aware cancellation. */
|
|
66
|
+
_rangeCache = null;
|
|
67
|
+
/** Cancellation shared by work owned by this source, including borrowed scheduler subscriptions. */
|
|
68
|
+
_finalizationController = new AbortController();
|
|
69
|
+
/** Creates a viewport-driven raster source backed by a GeoTIFF URL or Blob. */
|
|
70
|
+
constructor(data, options) {
|
|
71
|
+
super(data, options, GeoTIFFSourceLoader.defaultOptions);
|
|
72
|
+
if (options.geotiff?.rangeSchedulerProps) {
|
|
73
|
+
this.options.geotiff ||= {};
|
|
74
|
+
this.options.geotiff.rangeSchedulerProps = options.geotiff.rangeSchedulerProps;
|
|
75
|
+
}
|
|
76
|
+
if (options.geotiff?.rangeScheduler) {
|
|
77
|
+
this.options.geotiff ||= {};
|
|
78
|
+
this.options.geotiff.rangeScheduler = options.geotiff.rangeScheduler;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
/**
|
|
82
|
+
* Returns normalized GeoTIFF metadata without loading raster samples.
|
|
83
|
+
*/
|
|
84
|
+
async getMetadata(options = {}) {
|
|
85
|
+
return waitForPromiseWithSignals(async (signal) => {
|
|
86
|
+
const { metadata } = await this._getInitPromise(signal);
|
|
87
|
+
signal.throwIfAborted();
|
|
88
|
+
return metadata;
|
|
89
|
+
}, [options.signal, this._finalizationController.signal]);
|
|
90
|
+
}
|
|
91
|
+
/** Cancels transport owned by this source while preserving an injected shared scheduler. */
|
|
92
|
+
finalize() {
|
|
93
|
+
this._finalizationController.abort();
|
|
94
|
+
this._initialization?.controller.abort();
|
|
95
|
+
this._rangeScheduler?.finalize();
|
|
96
|
+
this._rangeCache?.clear();
|
|
97
|
+
this._rangeCache = null;
|
|
98
|
+
const initializationPromise = this._initPromise;
|
|
99
|
+
this._initPromise = null;
|
|
100
|
+
this._initialization = null;
|
|
101
|
+
void initializationPromise?.then(({ tiff }) => tiff.close()).catch(() => { });
|
|
102
|
+
}
|
|
103
|
+
/** Returns raster-query capabilities without opening raster samples. */
|
|
104
|
+
getRasterQueryCapabilities() {
|
|
105
|
+
return this.rasterQueryCapabilities;
|
|
106
|
+
}
|
|
107
|
+
/** Discovers raster bands, bounds, and overview levels for the shared scan query panel. */
|
|
108
|
+
async getQueryMetadata(options = {}) {
|
|
109
|
+
options.signal?.throwIfAborted();
|
|
110
|
+
const metadata = await this.getMetadata(options);
|
|
111
|
+
options.signal?.throwIfAborted();
|
|
112
|
+
const fields = Array.from({ length: metadata.bandCount }, (_, index) => ({
|
|
113
|
+
name: `band_${index + 1}`,
|
|
114
|
+
type: metadata.bands?.[index]?.dtype ?? metadata.dtype,
|
|
115
|
+
nullable: metadata.noData !== null,
|
|
116
|
+
metadata: {}
|
|
117
|
+
}));
|
|
118
|
+
return createScanQueryMetadata({
|
|
119
|
+
sourceType: 'geotiff',
|
|
120
|
+
queryType: 'raster',
|
|
121
|
+
execution: { status: 'supported', method: 'getRaster' },
|
|
122
|
+
name: metadata.name,
|
|
123
|
+
schema: { fields, metadata: {} },
|
|
124
|
+
capabilities: {
|
|
125
|
+
bounds: this.rasterQueryCapabilities.bounds,
|
|
126
|
+
levelOfDetail: this.rasterQueryCapabilities.level
|
|
127
|
+
},
|
|
128
|
+
spatial: metadata.boundingBox
|
|
129
|
+
? {
|
|
130
|
+
bounds: { minimum: metadata.boundingBox[0], maximum: metadata.boundingBox[1] },
|
|
131
|
+
coordinateReferenceSystems: typeof metadata.crs === 'string' ? [metadata.crs] : undefined
|
|
132
|
+
}
|
|
133
|
+
: undefined,
|
|
134
|
+
levels: metadata.overviews?.map(overview => ({
|
|
135
|
+
index: overview.index,
|
|
136
|
+
width: overview.width,
|
|
137
|
+
height: overview.height,
|
|
138
|
+
scale: [metadata.width / overview.width, metadata.height / overview.height]
|
|
139
|
+
}))
|
|
140
|
+
});
|
|
141
|
+
}
|
|
142
|
+
/**
|
|
143
|
+
* Loads typed raster samples for the requested viewport.
|
|
144
|
+
*
|
|
145
|
+
* v1 requires the request CRS to match the source CRS and returns native-projection samples.
|
|
146
|
+
*/
|
|
147
|
+
async getRaster(parameters) {
|
|
148
|
+
parameters.signal?.throwIfAborted();
|
|
149
|
+
const metadata = await this.getMetadata({ signal: parameters.signal });
|
|
150
|
+
const raster = await this._readRegion({
|
|
151
|
+
...parameters,
|
|
152
|
+
bounds: getRasterViewportBoundingBox(parameters.viewport),
|
|
153
|
+
crs: parameters.viewport.crs ?? metadata.crs,
|
|
154
|
+
width: parameters.viewport.width,
|
|
155
|
+
height: parameters.viewport.height
|
|
156
|
+
}, false);
|
|
157
|
+
if (raster.dtype === 'mixed')
|
|
158
|
+
throw new Error('Mixed-type GeoTIFF viewport reads require separate single-band requests; use getRasterForRegion for a mixed planar result');
|
|
159
|
+
return raster;
|
|
160
|
+
}
|
|
161
|
+
/** Reads an explicit region in the source CRS through the shared window pipeline. */
|
|
162
|
+
async getRasterForRegion(parameters) {
|
|
163
|
+
return this._readRegion(parameters, true);
|
|
164
|
+
}
|
|
165
|
+
/** Validates and decodes one source-coordinate window for both public entry points. */
|
|
166
|
+
_readRegion(parameters, requireCrs) {
|
|
167
|
+
return waitForPromiseWithSignals(signal => this._decodeRegion({ ...parameters, signal }, requireCrs), [parameters.signal, this._finalizationController.signal]);
|
|
168
|
+
}
|
|
169
|
+
/** Runs the native decode pipeline; callers observe cancellation even for noninterruptible codecs. */
|
|
170
|
+
async _decodeRegion(parameters, requireCrs) {
|
|
171
|
+
parameters.signal?.throwIfAborted();
|
|
172
|
+
const { tiff, images, metadata } = await this._getInitPromise(parameters.signal);
|
|
173
|
+
parameters.signal?.throwIfAborted();
|
|
174
|
+
const viewportBoundingBox = parameters.bounds;
|
|
175
|
+
if ((requireCrs && (!metadata.crs || !parameters.crs)) ||
|
|
176
|
+
(parameters.crs && metadata.crs !== parameters.crs))
|
|
177
|
+
throw new Error('GeoTIFFRasterSource does not support reprojection; source and request CRS must match');
|
|
178
|
+
if (!metadata.boundingBox)
|
|
179
|
+
throw new Error('GeoTIFFRasterSource requires source bounds');
|
|
180
|
+
const bandCount = parameters.bands?.length ?? metadata.bandCount;
|
|
181
|
+
if (!bandCount ||
|
|
182
|
+
parameters.bands?.some(band => !Number.isInteger(band) || band < 0 || band >= metadata.bandCount))
|
|
183
|
+
throw new Error('Invalid raster bands');
|
|
184
|
+
const selectedBands = parameters.bands ?? Array.from({ length: bandCount }, (_, index) => index);
|
|
185
|
+
const outputDtype = metadata.bands?.[selectedBands[0]]?.dtype ?? metadata.dtype;
|
|
186
|
+
const mixed = selectedBands.some(index => metadata.bands?.[index] && metadata.bands[index].dtype !== outputDtype);
|
|
187
|
+
const interleaved = parameters.interleaved ?? this.options.geotiff?.interleaved ?? false;
|
|
188
|
+
if (mixed && !requireCrs)
|
|
189
|
+
throw new Error('Mixed-type GeoTIFF viewport reads require separate single-band requests');
|
|
190
|
+
if (mixed && interleaved)
|
|
191
|
+
throw new Error('Mixed-type GeoTIFF regions require planar arrays');
|
|
192
|
+
const bytesPerPixel = selectedBands.reduce((bytes, index) => bytes +
|
|
193
|
+
Number((metadata.bands?.[index]?.dtype ?? metadata.dtype).match(/\d+/)?.[0] ?? 64) / 8, 0);
|
|
194
|
+
const maxPixels = parameters.maxPixels ?? this.options.geotiff?.maxPixels ?? 16_000_000;
|
|
195
|
+
const maxDecodedBytes = parameters.maxDecodedBytes ?? this.options.geotiff?.maxDecodedBytes ?? 256 * 1024 * 1024;
|
|
196
|
+
const pixels = validateRasterRegion(viewportBoundingBox, parameters.width, parameters.height, bytesPerPixel, maxPixels, maxDecodedBytes);
|
|
197
|
+
const clippedBoundingBox = intersectBoundingBoxes(viewportBoundingBox, metadata.boundingBox);
|
|
198
|
+
if (!clippedBoundingBox) {
|
|
199
|
+
if (pixels * (bytesPerPixel + 1) > maxDecodedBytes)
|
|
200
|
+
throw new Error('Empty raster mask exceeds decoded-byte budget');
|
|
201
|
+
if (mixed) {
|
|
202
|
+
return {
|
|
203
|
+
data: selectedBands.map(index => createFilledTypedArray(metadata.bands[index].dtype, pixels, metadata.bands[index].noData ?? 0)),
|
|
204
|
+
dtype: 'mixed',
|
|
205
|
+
interleaved: false,
|
|
206
|
+
bands: selectedBands.map(index => metadata.bands[index]),
|
|
207
|
+
width: parameters.width,
|
|
208
|
+
height: parameters.height,
|
|
209
|
+
bandCount,
|
|
210
|
+
crs: metadata.crs,
|
|
211
|
+
boundingBox: parameters.bounds,
|
|
212
|
+
transform: createRegionTransform(parameters.bounds, parameters.width, parameters.height),
|
|
213
|
+
pixelRegistration: 'area',
|
|
214
|
+
provenance: { sourceType: 'geotiff' },
|
|
215
|
+
ownership: 'owned',
|
|
216
|
+
validityMasks: [
|
|
217
|
+
{ data: new Uint8Array(pixels), width: parameters.width, height: parameters.height }
|
|
218
|
+
]
|
|
219
|
+
};
|
|
220
|
+
}
|
|
221
|
+
const empty = createEmptyRaster(parameters, { ...metadata, dtype: outputDtype });
|
|
222
|
+
empty.validityMasks = [
|
|
223
|
+
{ data: new Uint8Array(pixels), width: parameters.width, height: parameters.height }
|
|
224
|
+
];
|
|
225
|
+
return empty;
|
|
226
|
+
}
|
|
227
|
+
const targetSize = getClippedTargetSize(viewportBoundingBox, clippedBoundingBox, parameters);
|
|
228
|
+
const fillValue = metadata.noData ?? undefined;
|
|
229
|
+
const requestedResolution = [
|
|
230
|
+
(clippedBoundingBox[1][0] - clippedBoundingBox[0][0]) / targetSize.width,
|
|
231
|
+
(clippedBoundingBox[1][1] - clippedBoundingBox[0][1]) / targetSize.height
|
|
232
|
+
];
|
|
233
|
+
let overview = 0;
|
|
234
|
+
let transform;
|
|
235
|
+
let actualBoundingBox = clippedBoundingBox;
|
|
236
|
+
let raster;
|
|
237
|
+
let validityMasks;
|
|
238
|
+
const readOptions = {
|
|
239
|
+
width: targetSize.width,
|
|
240
|
+
height: targetSize.height,
|
|
241
|
+
samples: parameters.bands,
|
|
242
|
+
interleave: interleaved,
|
|
243
|
+
resampleMethod: parameters.resampleMethod ?? this.options.geotiff?.resampleMethod,
|
|
244
|
+
fillValue,
|
|
245
|
+
signal: parameters.signal
|
|
246
|
+
};
|
|
247
|
+
if (images.length) {
|
|
248
|
+
for (let index = 1; index < images.length; index++) {
|
|
249
|
+
const image = images[index];
|
|
250
|
+
const directory = image.fileDirectory;
|
|
251
|
+
if (directory.NewSubfileType & 4)
|
|
252
|
+
continue;
|
|
253
|
+
if (!(directory.NewSubfileType & 1) && directory.SubfileType !== 2)
|
|
254
|
+
continue;
|
|
255
|
+
if (images.some(candidate => candidate.fileDirectory?.NewSubfileType & 4) &&
|
|
256
|
+
!images.some(candidate => candidate.fileDirectory?.NewSubfileType & 4 &&
|
|
257
|
+
candidate.getWidth() === image.getWidth() &&
|
|
258
|
+
candidate.getHeight() === image.getHeight()))
|
|
259
|
+
continue;
|
|
260
|
+
const registration = image.getGeoKeys?.()?.GTRasterTypeGeoKey;
|
|
261
|
+
if ((registration === 2 ? 'point' : 'area') !== (metadata.pixelRegistration ?? 'area') &&
|
|
262
|
+
registration !== undefined)
|
|
263
|
+
continue;
|
|
264
|
+
if (typeof image.getSamplesPerPixel === 'function' &&
|
|
265
|
+
selectedBands.some(band => band >= image.getSamplesPerPixel()))
|
|
266
|
+
continue;
|
|
267
|
+
if (typeof image.getBitsPerSample === 'function' &&
|
|
268
|
+
typeof image.getSampleFormat === 'function') {
|
|
269
|
+
try {
|
|
270
|
+
if (selectedBands.some(band => getImageDataType(image, band) !==
|
|
271
|
+
(metadata.bands?.[band]?.dtype ?? metadata.dtype)))
|
|
272
|
+
continue;
|
|
273
|
+
}
|
|
274
|
+
catch {
|
|
275
|
+
continue;
|
|
276
|
+
}
|
|
277
|
+
}
|
|
278
|
+
const resolution = getImageResolution(image, images[0]);
|
|
279
|
+
if (resolution &&
|
|
280
|
+
Math.abs(resolution[0]) <= requestedResolution[0] &&
|
|
281
|
+
Math.abs(resolution[1]) <= requestedResolution[1] &&
|
|
282
|
+
image.getWidth() < images[overview].getWidth())
|
|
283
|
+
overview = index;
|
|
284
|
+
}
|
|
285
|
+
const image = images[overview];
|
|
286
|
+
const affine = getImageTransform(image, images[0]);
|
|
287
|
+
if (!affine)
|
|
288
|
+
throw new Error('GeoTIFF source has no usable affine transform');
|
|
289
|
+
const [columnScale, rowShear, originX, columnShear, rowScale, originY] = affine;
|
|
290
|
+
const determinant = columnScale * rowScale - rowShear * columnShear;
|
|
291
|
+
if (!affine.every(Number.isFinite) || !Number.isFinite(determinant) || determinant === 0)
|
|
292
|
+
throw new Error('Singular GeoTIFF affine transform');
|
|
293
|
+
const corners = [
|
|
294
|
+
clippedBoundingBox[0],
|
|
295
|
+
clippedBoundingBox[1],
|
|
296
|
+
[clippedBoundingBox[0][0], clippedBoundingBox[1][1]],
|
|
297
|
+
[clippedBoundingBox[1][0], clippedBoundingBox[0][1]]
|
|
298
|
+
];
|
|
299
|
+
const grid = corners.map(([coordinateX, coordinateY]) => [
|
|
300
|
+
(rowScale * (coordinateX - originX) - rowShear * (coordinateY - originY)) / determinant,
|
|
301
|
+
(columnScale * (coordinateY - originY) - columnShear * (coordinateX - originX)) /
|
|
302
|
+
determinant
|
|
303
|
+
]);
|
|
304
|
+
const window = [
|
|
305
|
+
Math.max(0, Math.floor(Math.min(...grid.map(point => point[0])))),
|
|
306
|
+
Math.max(0, Math.floor(Math.min(...grid.map(point => point[1])))),
|
|
307
|
+
Math.min(image.getWidth(), Math.ceil(Math.max(...grid.map(point => point[0])))),
|
|
308
|
+
Math.min(image.getHeight(), Math.ceil(Math.max(...grid.map(point => point[1]))))
|
|
309
|
+
];
|
|
310
|
+
const maskImages = images.filter(candidate => candidate.fileDirectory?.NewSubfileType & 4 &&
|
|
311
|
+
candidate.getWidth() === image.getWidth() &&
|
|
312
|
+
candidate.getHeight() === image.getHeight());
|
|
313
|
+
if (maskImages.length > 1)
|
|
314
|
+
throw new Error('Ambiguous GeoTIFF validity mask');
|
|
315
|
+
const nativePixelCount = (window[2] - window[0]) * (window[3] - window[1]);
|
|
316
|
+
const nativeBytes = nativePixelCount * bytesPerPixel;
|
|
317
|
+
const maskBytes = maskImages.length
|
|
318
|
+
? nativePixelCount * 3 + estimateImageTileBytes(maskImages[0], window, 2)
|
|
319
|
+
: 0;
|
|
320
|
+
const sourceBytesPerPixel = image.fileDirectory?.PlanarConfiguration === 2
|
|
321
|
+
? bytesPerPixel
|
|
322
|
+
: metadata.bands
|
|
323
|
+
? metadata.bands.reduce((bytes, band) => bytes + Number(band.dtype.match(/\d+/)?.[0] ?? 64) / 8, 0)
|
|
324
|
+
: (metadata.bandCount * Number(metadata.dtype.match(/\d+/)?.[0] ?? 64)) / 8;
|
|
325
|
+
const tileBytes = estimateImageTileBytes(image, window, sourceBytesPerPixel);
|
|
326
|
+
if (nativeBytes * 2 + maskBytes + pixels * (bytesPerPixel + bandCount) + tileBytes >
|
|
327
|
+
maxDecodedBytes)
|
|
328
|
+
throw new Error('Native decode window exceeds decoded-byte budget');
|
|
329
|
+
if (window[2] <= window[0] || window[3] <= window[1])
|
|
330
|
+
throw new Error('Region does not intersect the source grid');
|
|
331
|
+
const scaleX = (window[2] - window[0]) / targetSize.width;
|
|
332
|
+
const scaleY = (window[3] - window[1]) / targetSize.height;
|
|
333
|
+
const pointShift = metadata.pixelRegistration === 'point' ? 0.5 : 0;
|
|
334
|
+
transform = [
|
|
335
|
+
columnScale * scaleX,
|
|
336
|
+
rowShear * scaleY,
|
|
337
|
+
columnScale * (window[0] - pointShift) + rowShear * (window[1] - pointShift) + originX,
|
|
338
|
+
columnShear * scaleX,
|
|
339
|
+
rowScale * scaleY,
|
|
340
|
+
columnShear * (window[0] - pointShift) + rowScale * (window[1] - pointShift) + originY
|
|
341
|
+
];
|
|
342
|
+
const sourceCorners = [
|
|
343
|
+
[window[0], window[1]],
|
|
344
|
+
[window[2], window[1]],
|
|
345
|
+
[window[0], window[3]],
|
|
346
|
+
[window[2], window[3]]
|
|
347
|
+
].map(([column, row]) => [
|
|
348
|
+
columnScale * (column - pointShift) + rowShear * (row - pointShift) + originX,
|
|
349
|
+
columnShear * (column - pointShift) + rowScale * (row - pointShift) + originY
|
|
350
|
+
]);
|
|
351
|
+
actualBoundingBox = [
|
|
352
|
+
[
|
|
353
|
+
Math.min(...sourceCorners.map(point => point[0])),
|
|
354
|
+
Math.min(...sourceCorners.map(point => point[1]))
|
|
355
|
+
],
|
|
356
|
+
[
|
|
357
|
+
Math.max(...sourceCorners.map(point => point[0])),
|
|
358
|
+
Math.max(...sourceCorners.map(point => point[1]))
|
|
359
|
+
]
|
|
360
|
+
];
|
|
361
|
+
const nativeRaster = (await image.readRasters({
|
|
362
|
+
...readOptions,
|
|
363
|
+
// geotiff.js interleaving chooses a type from every source band, including unselected bands.
|
|
364
|
+
interleave: false,
|
|
365
|
+
width: window[2] - window[0],
|
|
366
|
+
height: window[3] - window[1],
|
|
367
|
+
window,
|
|
368
|
+
resampleMethod: 'nearest'
|
|
369
|
+
}));
|
|
370
|
+
if (nativeRaster.width !== window[2] - window[0] ||
|
|
371
|
+
nativeRaster.height !== window[3] - window[1])
|
|
372
|
+
throw new Error('Invalid native raster dimensions');
|
|
373
|
+
const nativeArrays = Array.isArray(nativeRaster) ? nativeRaster : [nativeRaster];
|
|
374
|
+
if (nativeArrays.reduce((length, array) => length + array.length, 0) !==
|
|
375
|
+
nativeRaster.width * nativeRaster.height * bandCount ||
|
|
376
|
+
nativeArrays.reduce((length, array) => length + array.byteLength, 0) > maxDecodedBytes)
|
|
377
|
+
throw new Error('Invalid or oversized native raster');
|
|
378
|
+
if (nativeArrays.length !== bandCount ||
|
|
379
|
+
nativeArrays.some((array, index) => array.constructor !==
|
|
380
|
+
createFilledTypedArray(metadata.bands?.[selectedBands[index]]?.dtype ?? metadata.dtype, 0, 0).constructor))
|
|
381
|
+
throw new Error('Native raster representation does not match selected band metadata');
|
|
382
|
+
let nativeValidityMasks;
|
|
383
|
+
if (maskImages.length) {
|
|
384
|
+
parameters.signal?.throwIfAborted();
|
|
385
|
+
const maskRaster = (await maskImages[0].readRasters({
|
|
386
|
+
window,
|
|
387
|
+
samples: [0],
|
|
388
|
+
interleave: true,
|
|
389
|
+
signal: parameters.signal
|
|
390
|
+
}));
|
|
391
|
+
if (maskRaster.length !== nativePixelCount || maskRaster.byteLength > nativePixelCount * 2)
|
|
392
|
+
throw new Error('Invalid GeoTIFF validity mask');
|
|
393
|
+
nativeValidityMasks = [
|
|
394
|
+
{
|
|
395
|
+
data: Uint8Array.from(maskRaster, value => Number.isFinite(value) && value !== 0 ? 1 : 0),
|
|
396
|
+
width: nativeRaster.width,
|
|
397
|
+
height: nativeRaster.height,
|
|
398
|
+
pixelStride: 1,
|
|
399
|
+
rowStride: nativeRaster.width
|
|
400
|
+
}
|
|
401
|
+
];
|
|
402
|
+
}
|
|
403
|
+
const resized = await resizeRasterWindow(nativeRaster, selectedBands.map(index => metadata.bands?.[index]
|
|
404
|
+
? { ...metadata.bands[index] }
|
|
405
|
+
: { index, dtype: outputDtype, noData: metadata.noData }), interleaved, targetSize, readOptions.resampleMethod ?? 'nearest', parameters.signal, nativeValidityMasks);
|
|
406
|
+
raster = resized.raster;
|
|
407
|
+
validityMasks = resized.validityMasks;
|
|
408
|
+
}
|
|
409
|
+
else {
|
|
410
|
+
raster = (await tiff.readRasters({
|
|
411
|
+
...readOptions,
|
|
412
|
+
bbox: flattenBoundingBox(clippedBoundingBox)
|
|
413
|
+
}));
|
|
414
|
+
}
|
|
415
|
+
const data = normalizeRasterReadResult(raster, interleaved);
|
|
416
|
+
parameters.signal?.throwIfAborted();
|
|
417
|
+
const arrays = Array.isArray(data) ? data : [data];
|
|
418
|
+
const expectedLength = raster.width * raster.height * bandCount;
|
|
419
|
+
if (!Number.isSafeInteger(raster.width) ||
|
|
420
|
+
!Number.isSafeInteger(raster.height) ||
|
|
421
|
+
raster.width <= 0 ||
|
|
422
|
+
raster.height <= 0 ||
|
|
423
|
+
raster.width * raster.height >
|
|
424
|
+
(parameters.maxPixels ?? this.options.geotiff?.maxPixels ?? 16_000_000))
|
|
425
|
+
throw new Error('Invalid decoded raster dimensions');
|
|
426
|
+
if (arrays.reduce((length, array) => length + array.length, 0) !== expectedLength ||
|
|
427
|
+
arrays.reduce((length, array) => length + array.byteLength, 0) >
|
|
428
|
+
(parameters.maxDecodedBytes ?? this.options.geotiff?.maxDecodedBytes ?? 256 * 1024 * 1024))
|
|
429
|
+
throw new Error('Invalid or oversized decoded raster');
|
|
430
|
+
const result = {
|
|
431
|
+
data,
|
|
432
|
+
width: raster.width,
|
|
433
|
+
height: raster.height,
|
|
434
|
+
bandCount,
|
|
435
|
+
dtype: outputDtype,
|
|
436
|
+
interleaved,
|
|
437
|
+
noData: metadata.noData,
|
|
438
|
+
boundingBox: actualBoundingBox,
|
|
439
|
+
crs: metadata.crs,
|
|
440
|
+
metadata: metadata.metadata,
|
|
441
|
+
bands: (parameters.bands ?? Array.from({ length: bandCount }, (_, index) => index)).map(index => metadata.bands?.[index]
|
|
442
|
+
? { ...metadata.bands[index] }
|
|
443
|
+
: { index, dtype: metadata.dtype, noData: metadata.noData }),
|
|
444
|
+
transform,
|
|
445
|
+
pixelRegistration: 'area',
|
|
446
|
+
validityMasks,
|
|
447
|
+
overview,
|
|
448
|
+
resolution: transform
|
|
449
|
+
? [Math.hypot(transform[0], transform[3]), Math.hypot(transform[1], transform[4])]
|
|
450
|
+
: requestedResolution,
|
|
451
|
+
nativeResolution: metadata.overviews
|
|
452
|
+
?.find(level => level.index === overview)
|
|
453
|
+
?.resolution?.map(Math.abs),
|
|
454
|
+
overzoom: metadata.overviews
|
|
455
|
+
?.find(level => level.index === overview)
|
|
456
|
+
?.resolution?.some((resolution, axis) => Math.abs(resolution) > requestedResolution[axis]),
|
|
457
|
+
provenance: { sourceType: 'geotiff' },
|
|
458
|
+
ownership: 'owned'
|
|
459
|
+
};
|
|
460
|
+
if (mixed)
|
|
461
|
+
return {
|
|
462
|
+
...result,
|
|
463
|
+
data: arrays,
|
|
464
|
+
dtype: 'mixed',
|
|
465
|
+
interleaved: false,
|
|
466
|
+
bands: result.bands
|
|
467
|
+
};
|
|
468
|
+
return result;
|
|
469
|
+
}
|
|
470
|
+
/** Opens the GeoTIFF once and resolves its overview images and normalized metadata. */
|
|
471
|
+
async _initialize(signal) {
|
|
472
|
+
signal?.throwIfAborted();
|
|
473
|
+
const tiff = await this._openGeoTIFF(signal);
|
|
474
|
+
signal?.throwIfAborted();
|
|
475
|
+
const imageCount = await tiff.getImageCount();
|
|
476
|
+
signal?.throwIfAborted();
|
|
477
|
+
const images = await Promise.all(Array.from({ length: imageCount }, (_, index) => tiff.getImage(index)));
|
|
478
|
+
signal?.throwIfAborted();
|
|
479
|
+
if (!images.length) {
|
|
480
|
+
throw new Error('GeoTIFFRasterSource could not load any images.');
|
|
481
|
+
}
|
|
482
|
+
const referenceImage = images[0];
|
|
483
|
+
const metadata = this._getMetadata(referenceImage, images);
|
|
484
|
+
return { tiff, images, metadata };
|
|
485
|
+
}
|
|
486
|
+
/** Returns the shared initialization promise for this source instance. */
|
|
487
|
+
_getInitPromise(signal) {
|
|
488
|
+
signal?.throwIfAborted();
|
|
489
|
+
if (!this._initPromise) {
|
|
490
|
+
const initialization = { controller: new AbortController(), subscribers: 0, settled: false };
|
|
491
|
+
this._initialization = initialization;
|
|
492
|
+
const promise = this._initialize(initialization.controller.signal);
|
|
493
|
+
this._initPromise = promise;
|
|
494
|
+
void promise.then(() => {
|
|
495
|
+
initialization.settled = true;
|
|
496
|
+
}, () => {
|
|
497
|
+
initialization.settled = true;
|
|
498
|
+
if (this._initPromise === promise)
|
|
499
|
+
this._initPromise = null;
|
|
500
|
+
});
|
|
501
|
+
}
|
|
502
|
+
const promise = this._initPromise;
|
|
503
|
+
const initialization = this._initialization;
|
|
504
|
+
if (initialization)
|
|
505
|
+
initialization.subscribers++;
|
|
506
|
+
const release = () => {
|
|
507
|
+
if (!initialization)
|
|
508
|
+
return;
|
|
509
|
+
initialization.subscribers--;
|
|
510
|
+
if (!initialization.settled && initialization.subscribers === 0) {
|
|
511
|
+
initialization.controller.abort(signal?.reason);
|
|
512
|
+
if (this._initPromise === promise)
|
|
513
|
+
this._initPromise = null;
|
|
514
|
+
}
|
|
515
|
+
};
|
|
516
|
+
if (!signal) {
|
|
517
|
+
void promise.then(release, release);
|
|
518
|
+
return promise;
|
|
519
|
+
}
|
|
520
|
+
return new Promise((resolve, reject) => {
|
|
521
|
+
let released = false;
|
|
522
|
+
const cleanup = () => {
|
|
523
|
+
if (released)
|
|
524
|
+
return;
|
|
525
|
+
released = true;
|
|
526
|
+
signal.removeEventListener('abort', abort);
|
|
527
|
+
release();
|
|
528
|
+
};
|
|
529
|
+
const abort = () => {
|
|
530
|
+
cleanup();
|
|
531
|
+
reject(signal.reason);
|
|
532
|
+
};
|
|
533
|
+
signal.addEventListener('abort', abort, { once: true });
|
|
534
|
+
if (signal.aborted)
|
|
535
|
+
abort();
|
|
536
|
+
void promise.then(value => {
|
|
537
|
+
cleanup();
|
|
538
|
+
resolve(value);
|
|
539
|
+
}, error => {
|
|
540
|
+
cleanup();
|
|
541
|
+
reject(error);
|
|
542
|
+
});
|
|
543
|
+
});
|
|
544
|
+
}
|
|
545
|
+
/** Opens the underlying GeoTIFF using Blob reads or range-scheduled HTTP access. */
|
|
546
|
+
async _openGeoTIFF(signal) {
|
|
547
|
+
const initialization = this._initialization;
|
|
548
|
+
if (typeof this.data === 'string') {
|
|
549
|
+
const maxEntries = this.options.geotiff?.rangeCacheProps?.maxEntries ?? 128;
|
|
550
|
+
const maxBytes = this.options.geotiff?.rangeCacheProps?.maxBytes ?? 8 * 1024 * 1024;
|
|
551
|
+
if (![maxEntries, maxBytes].every(value => Number.isSafeInteger(value) && value >= 0))
|
|
552
|
+
throw new Error('Invalid GeoTIFF cache limits');
|
|
553
|
+
this._rangeCache?.clear();
|
|
554
|
+
this._rangeCache = new RangeRequestCache({ maxEntries, maxBytes });
|
|
555
|
+
const headers = Object.fromEntries(new Headers(this.options.geotiff?.headers));
|
|
556
|
+
const rangeScheduler = this._getRangeScheduler();
|
|
557
|
+
const rangeCache = this._rangeCache;
|
|
558
|
+
const client = new GeoTIFFRangeSchedulerClient({
|
|
559
|
+
url: this.url,
|
|
560
|
+
fetch: this.fetch,
|
|
561
|
+
requireContentRange: this.options.geotiff?.requireContentRange,
|
|
562
|
+
sourceId: 'geotiff',
|
|
563
|
+
headers,
|
|
564
|
+
rangeCache,
|
|
565
|
+
maxPendingRequests: rangeScheduler.props.maxQueueSize,
|
|
566
|
+
rangeScheduler,
|
|
567
|
+
getInitializationSignal: () => (initialization?.settled ? undefined : signal),
|
|
568
|
+
onRevisionChange: error => {
|
|
569
|
+
this._finalizationController.abort(error);
|
|
570
|
+
rangeCache.clear();
|
|
571
|
+
}
|
|
572
|
+
});
|
|
573
|
+
// The library's BlockedSource retries interrupted shared blocks without a signal.
|
|
574
|
+
// Adapt its buffer-source protocol directly; loaders.gl owns bounded caching and cancellation.
|
|
575
|
+
return await openGeoTIFFSourceDecoder({
|
|
576
|
+
/** Reads independently owned buffers in source request order. */
|
|
577
|
+
fetch: (slices, requestSignal) => client.readRanges(slices, requestSignal),
|
|
578
|
+
/** Reflects the validated remote object length discovered by transport. */
|
|
579
|
+
get fileSize() {
|
|
580
|
+
return client.getFileSize();
|
|
581
|
+
},
|
|
582
|
+
/** Releases only this source's owned byte cache. */
|
|
583
|
+
close: () => rangeCache.clear()
|
|
584
|
+
}, signal);
|
|
585
|
+
}
|
|
586
|
+
return await openGeoTIFFSourceDecoder(this.data, signal);
|
|
587
|
+
}
|
|
588
|
+
/** Returns the configured shared scheduler or lazily creates a per-source scheduler. */
|
|
589
|
+
_getRangeScheduler() {
|
|
590
|
+
if (this.options.geotiff?.rangeScheduler) {
|
|
591
|
+
return this.options.geotiff.rangeScheduler;
|
|
592
|
+
}
|
|
593
|
+
if (!this._rangeScheduler) {
|
|
594
|
+
this._rangeScheduler = new RangeRequestScheduler({
|
|
595
|
+
batchDelayMs: 0,
|
|
596
|
+
...this.options.geotiff?.rangeSchedulerProps
|
|
597
|
+
});
|
|
598
|
+
}
|
|
599
|
+
return this._rangeScheduler;
|
|
600
|
+
}
|
|
601
|
+
/** Normalizes one GeoTIFF image hierarchy into public raster-source metadata. */
|
|
602
|
+
_getMetadata(referenceImage, images) {
|
|
603
|
+
if (![
|
|
604
|
+
referenceImage.getWidth(),
|
|
605
|
+
referenceImage.getHeight(),
|
|
606
|
+
referenceImage.getSamplesPerPixel()
|
|
607
|
+
].every(value => Number.isSafeInteger(value) && value > 0))
|
|
608
|
+
throw new Error('Invalid GeoTIFF image dimensions or band count');
|
|
609
|
+
const boundingBox = getImageBoundingBox(referenceImage);
|
|
610
|
+
const geoKeys = referenceImage.getGeoKeys?.() || undefined;
|
|
611
|
+
const gdalMetadata = referenceImage.getGDALMetadata?.() || undefined;
|
|
612
|
+
const noData = referenceImage.getGDALNoData?.() ?? null;
|
|
613
|
+
return {
|
|
614
|
+
name: getGeoTIFFName(this.data),
|
|
615
|
+
keywords: [],
|
|
616
|
+
attributions: this.options.core?.attributions || [],
|
|
617
|
+
crs: getImageCRS(referenceImage),
|
|
618
|
+
boundingBox,
|
|
619
|
+
tileGrid: getImageTileGrid(images, referenceImage),
|
|
620
|
+
width: referenceImage.getWidth(),
|
|
621
|
+
height: referenceImage.getHeight(),
|
|
622
|
+
bandCount: referenceImage.getSamplesPerPixel(),
|
|
623
|
+
dtype: getImageDataType(referenceImage),
|
|
624
|
+
bands: Array.from({ length: referenceImage.getSamplesPerPixel() }, (_, index) => getImageBandMetadata(referenceImage, index, noData)),
|
|
625
|
+
transform: getImageTransform(referenceImage, referenceImage),
|
|
626
|
+
pixelRegistration: geoKeys?.GTRasterTypeGeoKey === 2
|
|
627
|
+
? 'point'
|
|
628
|
+
: geoKeys?.GTRasterTypeGeoKey === 1
|
|
629
|
+
? 'area'
|
|
630
|
+
: undefined,
|
|
631
|
+
supportsRegion: true,
|
|
632
|
+
tileSize: {
|
|
633
|
+
width: referenceImage.getTileWidth(),
|
|
634
|
+
height: referenceImage.getTileHeight()
|
|
635
|
+
},
|
|
636
|
+
overviews: images
|
|
637
|
+
.map((image, index) => ({
|
|
638
|
+
index,
|
|
639
|
+
width: image.getWidth(),
|
|
640
|
+
height: image.getHeight(),
|
|
641
|
+
resolution: getImageResolution(image, referenceImage)
|
|
642
|
+
}))
|
|
643
|
+
.filter(overview => !(images[overview.index].fileDirectory?.NewSubfileType & 4)),
|
|
644
|
+
noData,
|
|
645
|
+
metadata: {
|
|
646
|
+
geoKeys,
|
|
647
|
+
gdalMetadata,
|
|
648
|
+
bandMetadata: Array.from({ length: referenceImage.getSamplesPerPixel() }, (_, index) => referenceImage.getGDALMetadata?.(index) || undefined)
|
|
649
|
+
}
|
|
650
|
+
};
|
|
651
|
+
}
|
|
652
|
+
}
|
|
653
|
+
/** Flattens the internal tuple bounding box to GeoTIFF's `[minX, minY, maxX, maxY]` form. */
|
|
654
|
+
function flattenBoundingBox(boundingBox) {
|
|
655
|
+
return [...boundingBox[0], ...boundingBox[1]];
|
|
656
|
+
}
|
|
657
|
+
/** Computes the overlap between two source-coordinate bounding boxes. */
|
|
658
|
+
function intersectBoundingBoxes(leftBoundingBox, rightBoundingBox) {
|
|
659
|
+
const minX = Math.max(leftBoundingBox[0][0], rightBoundingBox[0][0]);
|
|
660
|
+
const minY = Math.max(leftBoundingBox[0][1], rightBoundingBox[0][1]);
|
|
661
|
+
const maxX = Math.min(leftBoundingBox[1][0], rightBoundingBox[1][0]);
|
|
662
|
+
const maxY = Math.min(leftBoundingBox[1][1], rightBoundingBox[1][1]);
|
|
663
|
+
if (maxX <= minX || maxY <= minY) {
|
|
664
|
+
return null;
|
|
665
|
+
}
|
|
666
|
+
return [
|
|
667
|
+
[minX, minY],
|
|
668
|
+
[maxX, maxY]
|
|
669
|
+
];
|
|
670
|
+
}
|
|
671
|
+
/** Scales the output raster size to the portion of the viewport that intersects the source. */
|
|
672
|
+
function getClippedTargetSize(viewportBoundingBox, clippedBoundingBox, parameters) {
|
|
673
|
+
const viewportWidth = Math.abs(viewportBoundingBox[1][0] - viewportBoundingBox[0][0]);
|
|
674
|
+
const viewportHeight = Math.abs(viewportBoundingBox[1][1] - viewportBoundingBox[0][1]);
|
|
675
|
+
const clippedWidth = Math.abs(clippedBoundingBox[1][0] - clippedBoundingBox[0][0]);
|
|
676
|
+
const clippedHeight = Math.abs(clippedBoundingBox[1][1] - clippedBoundingBox[0][1]);
|
|
677
|
+
return {
|
|
678
|
+
width: Math.max(1, Math.min(parameters.width, Math.round((clippedWidth / Math.max(viewportWidth, Number.EPSILON)) * parameters.width))),
|
|
679
|
+
height: Math.max(1, Math.min(parameters.height, Math.round((clippedHeight / Math.max(viewportHeight, Number.EPSILON)) * parameters.height)))
|
|
680
|
+
};
|
|
681
|
+
}
|
|
682
|
+
/** Creates a no-data raster payload when the viewport does not overlap the dataset. */
|
|
683
|
+
function createEmptyRaster(parameters, metadata) {
|
|
684
|
+
const length = parameters.width * parameters.height;
|
|
685
|
+
const bandCount = parameters.bands?.length ?? metadata.bandCount;
|
|
686
|
+
const interleaved = parameters.interleaved ?? false;
|
|
687
|
+
const noData = metadata.noData ?? 0;
|
|
688
|
+
const data = interleaved
|
|
689
|
+
? createFilledTypedArray(metadata.dtype, length * bandCount, noData)
|
|
690
|
+
: bandCount === 1
|
|
691
|
+
? createFilledTypedArray(metadata.dtype, length, noData)
|
|
692
|
+
: Array.from({ length: bandCount }, () => createFilledTypedArray(metadata.dtype, length, noData));
|
|
693
|
+
return {
|
|
694
|
+
data,
|
|
695
|
+
width: parameters.width,
|
|
696
|
+
height: parameters.height,
|
|
697
|
+
bandCount,
|
|
698
|
+
dtype: metadata.dtype,
|
|
699
|
+
interleaved,
|
|
700
|
+
noData: metadata.noData,
|
|
701
|
+
boundingBox: parameters.bounds,
|
|
702
|
+
crs: metadata.crs,
|
|
703
|
+
metadata: metadata.metadata,
|
|
704
|
+
bands: (parameters.bands ?? Array.from({ length: bandCount }, (_, index) => index)).map(index => metadata.bands?.[index]
|
|
705
|
+
? { ...metadata.bands[index] }
|
|
706
|
+
: { index, dtype: metadata.dtype, noData: metadata.noData }),
|
|
707
|
+
transform: createRegionTransform(parameters.bounds, parameters.width, parameters.height),
|
|
708
|
+
pixelRegistration: 'area',
|
|
709
|
+
provenance: { sourceType: 'geotiff' },
|
|
710
|
+
ownership: 'owned'
|
|
711
|
+
};
|
|
712
|
+
}
|
|
713
|
+
/** Allocates a typed array for the requested raster channel type and fills it with one value. */
|
|
714
|
+
function createFilledTypedArray(dtype, length, fillValue) {
|
|
715
|
+
switch (dtype) {
|
|
716
|
+
case 'uint8':
|
|
717
|
+
return new Uint8Array(length).fill(fillValue);
|
|
718
|
+
case 'uint16':
|
|
719
|
+
return new Uint16Array(length).fill(fillValue);
|
|
720
|
+
case 'uint32':
|
|
721
|
+
return new Uint32Array(length).fill(fillValue);
|
|
722
|
+
case 'int8':
|
|
723
|
+
return new Int8Array(length).fill(fillValue);
|
|
724
|
+
case 'int16':
|
|
725
|
+
return new Int16Array(length).fill(fillValue);
|
|
726
|
+
case 'int32':
|
|
727
|
+
return new Int32Array(length).fill(fillValue);
|
|
728
|
+
case 'float32':
|
|
729
|
+
return new Float32Array(length).fill(fillValue);
|
|
730
|
+
case 'float64':
|
|
731
|
+
return new Float64Array(length).fill(fillValue);
|
|
732
|
+
default:
|
|
733
|
+
return new Uint8Array(length).fill(fillValue);
|
|
734
|
+
}
|
|
735
|
+
}
|
|
736
|
+
/** Converts GeoTIFF `readRasters()` output into the public `RasterData.data` union shape. */
|
|
737
|
+
function normalizeRasterReadResult(raster, interleaved) {
|
|
738
|
+
if (interleaved) {
|
|
739
|
+
return raster;
|
|
740
|
+
}
|
|
741
|
+
if (Array.isArray(raster)) {
|
|
742
|
+
return raster.length === 1 ? raster[0] : raster;
|
|
743
|
+
}
|
|
744
|
+
return [raster];
|
|
745
|
+
}
|
|
746
|
+
/** Resolves a human-readable dataset name from the source input when possible. */
|
|
747
|
+
function getGeoTIFFName(data) {
|
|
748
|
+
if (typeof data !== 'string') {
|
|
749
|
+
return undefined;
|
|
750
|
+
}
|
|
751
|
+
const [path] = data.split(/[?#]/);
|
|
752
|
+
return path.split('/').pop() || undefined;
|
|
753
|
+
}
|
|
754
|
+
/** Returns the source-coordinate bounds advertised by a GeoTIFF image. */
|
|
755
|
+
function getImageBoundingBox(image) {
|
|
756
|
+
try {
|
|
757
|
+
const [minX, minY, maxX, maxY] = image.getBoundingBox();
|
|
758
|
+
return [
|
|
759
|
+
[minX, minY],
|
|
760
|
+
[maxX, maxY]
|
|
761
|
+
];
|
|
762
|
+
}
|
|
763
|
+
catch {
|
|
764
|
+
return undefined;
|
|
765
|
+
}
|
|
766
|
+
}
|
|
767
|
+
/** Estimates overview resolution relative to the full-resolution reference image. */
|
|
768
|
+
function getImageResolution(image, referenceImage) {
|
|
769
|
+
const transform = getImageTransform(image, referenceImage);
|
|
770
|
+
if (transform) {
|
|
771
|
+
return [
|
|
772
|
+
transform[3] === 0 ? transform[0] : Math.hypot(transform[0], transform[3]),
|
|
773
|
+
transform[1] === 0 ? transform[4] : Math.hypot(transform[1], transform[4])
|
|
774
|
+
];
|
|
775
|
+
}
|
|
776
|
+
try {
|
|
777
|
+
const resolution = image.getResolution(referenceImage);
|
|
778
|
+
return [resolution[0], resolution[1]];
|
|
779
|
+
}
|
|
780
|
+
catch {
|
|
781
|
+
return undefined;
|
|
782
|
+
}
|
|
783
|
+
}
|
|
784
|
+
/** Returns a normalized CRS string for the GeoTIFF image when one is available. */
|
|
785
|
+
function getImageCRS(image) {
|
|
786
|
+
const geoKeys = image.getGeoKeys?.();
|
|
787
|
+
const projectedCrs = geoKeys?.ProjectedCSTypeGeoKey;
|
|
788
|
+
if (projectedCrs || geoKeys?.GTModelTypeGeoKey === 1) {
|
|
789
|
+
return projectedCrs && projectedCrs !== 32767 ? `EPSG:${projectedCrs}` : undefined;
|
|
790
|
+
}
|
|
791
|
+
const geographicCrs = geoKeys?.GeographicTypeGeoKey;
|
|
792
|
+
if (geographicCrs && geographicCrs !== 32767) {
|
|
793
|
+
return `EPSG:${geographicCrs}`;
|
|
794
|
+
}
|
|
795
|
+
return undefined;
|
|
796
|
+
}
|
|
797
|
+
/** Converts GeoTIFF sample-format metadata to a public raster channel data type. */
|
|
798
|
+
function getImageDataType(image, index = 0) {
|
|
799
|
+
const bitsPerSample = normalizeSampleValue(image.getBitsPerSample(index));
|
|
800
|
+
const sampleFormat = normalizeSampleValue(image.getSampleFormat(index));
|
|
801
|
+
switch (sampleFormat) {
|
|
802
|
+
case 1:
|
|
803
|
+
switch (bitsPerSample) {
|
|
804
|
+
case 8:
|
|
805
|
+
return 'uint8';
|
|
806
|
+
case 16:
|
|
807
|
+
return 'uint16';
|
|
808
|
+
case 32:
|
|
809
|
+
return 'uint32';
|
|
810
|
+
default:
|
|
811
|
+
break;
|
|
812
|
+
}
|
|
813
|
+
break;
|
|
814
|
+
case 2:
|
|
815
|
+
switch (bitsPerSample) {
|
|
816
|
+
case 8:
|
|
817
|
+
return 'int8';
|
|
818
|
+
case 16:
|
|
819
|
+
return 'int16';
|
|
820
|
+
case 32:
|
|
821
|
+
return 'int32';
|
|
822
|
+
default:
|
|
823
|
+
break;
|
|
824
|
+
}
|
|
825
|
+
break;
|
|
826
|
+
case 3:
|
|
827
|
+
switch (bitsPerSample) {
|
|
828
|
+
case 32:
|
|
829
|
+
return 'float32';
|
|
830
|
+
case 64:
|
|
831
|
+
return 'float64';
|
|
832
|
+
default:
|
|
833
|
+
break;
|
|
834
|
+
}
|
|
835
|
+
break;
|
|
836
|
+
default:
|
|
837
|
+
break;
|
|
838
|
+
}
|
|
839
|
+
throw new Error(`GeoTIFFRasterSource does not support sample format ${sampleFormat} with ${bitsPerSample} bits.`);
|
|
840
|
+
}
|
|
841
|
+
/** Normalizes single-value or per-sample TIFF metadata arrays to the first sample value. */
|
|
842
|
+
function normalizeSampleValue(value) {
|
|
843
|
+
return Array.isArray(value) ? value[0] : value;
|
|
844
|
+
}
|
|
845
|
+
/** Minimal geotiff.js client backed by loaders.gl fetch and range scheduling. */
|
|
846
|
+
class GeoTIFFRangeSchedulerClient {
|
|
847
|
+
url;
|
|
848
|
+
fetch;
|
|
849
|
+
/** Strict browser profiles require the server to expose range placement metadata. */
|
|
850
|
+
requireContentRange;
|
|
851
|
+
sourceId;
|
|
852
|
+
defaultHeaders;
|
|
853
|
+
rangeScheduler;
|
|
854
|
+
schedulerIsolationKey = {};
|
|
855
|
+
/** Source-owned cache; never shared across authorization or source instances. */
|
|
856
|
+
rangeCache;
|
|
857
|
+
/** Admission limit includes every logical cache subscriber. */
|
|
858
|
+
maxPendingRequests;
|
|
859
|
+
/** Number of logical requests awaiting transfer or a cache entry. */
|
|
860
|
+
pendingRequests = 0;
|
|
861
|
+
fileSize = null;
|
|
862
|
+
/** Remote object revision headers remain private to cache identity. */
|
|
863
|
+
entityTag = null;
|
|
864
|
+
/** Optional fallback revision hint, compared only when both responses declare it. */
|
|
865
|
+
lastModified = null;
|
|
866
|
+
/** Invalidates owned source work without disposing a borrowed scheduler. */
|
|
867
|
+
onRevisionChange;
|
|
868
|
+
/** Discovery cancellation for geotiff.js directory reads without their own signal. */
|
|
869
|
+
getInitializationSignal;
|
|
870
|
+
/** Creates a new range-scheduled GeoTIFF client. */
|
|
871
|
+
constructor(props) {
|
|
872
|
+
this.url = props.url;
|
|
873
|
+
this.fetch = props.fetch;
|
|
874
|
+
this.requireContentRange = props.requireContentRange ?? false;
|
|
875
|
+
this.sourceId = props.sourceId;
|
|
876
|
+
this.defaultHeaders = new Headers(props.headers);
|
|
877
|
+
this.rangeCache = props.rangeCache;
|
|
878
|
+
this.maxPendingRequests = props.maxPendingRequests;
|
|
879
|
+
this.rangeScheduler = props.rangeScheduler;
|
|
880
|
+
this.getInitializationSignal = props.getInitializationSignal;
|
|
881
|
+
this.onRevisionChange = props.onRevisionChange;
|
|
882
|
+
}
|
|
883
|
+
/** Returns the validated remote file size, when available. */
|
|
884
|
+
getFileSize() {
|
|
885
|
+
return this.fileSize;
|
|
886
|
+
}
|
|
887
|
+
/** Returns standalone buffers in the order required by geotiff.js's source protocol. */
|
|
888
|
+
async readRanges(slices, signal) {
|
|
889
|
+
return Promise.all(slices.map(slice => this.request({
|
|
890
|
+
headers: createRangeRequestHeaders(new Headers(), slice.offset, slice.length),
|
|
891
|
+
signal
|
|
892
|
+
})));
|
|
893
|
+
}
|
|
894
|
+
/** Executes one geotiff.js byte-range request through the shared scheduler. */
|
|
895
|
+
async request({ headers, signal } = {}) {
|
|
896
|
+
signal ??= this.getInitializationSignal?.();
|
|
897
|
+
signal?.throwIfAborted();
|
|
898
|
+
if (this.pendingRequests >= this.maxPendingRequests)
|
|
899
|
+
throw new Error('GeoTIFF request queue limit exceeded');
|
|
900
|
+
this.pendingRequests++;
|
|
901
|
+
try {
|
|
902
|
+
const mergedHeaders = new Headers(this.defaultHeaders);
|
|
903
|
+
new Headers(headers).forEach((value, key) => mergedHeaders.set(key, value));
|
|
904
|
+
const { offset, length } = parseSingleRangeHeader(mergedHeaders.get('Range'));
|
|
905
|
+
const requestHeaders = new Headers(mergedHeaders);
|
|
906
|
+
requestHeaders.delete('Range');
|
|
907
|
+
const readRange = (rangeOffset, rangeLength, rangeSignal) => this.rangeScheduler.scheduleRequest({
|
|
908
|
+
sourceId: this.sourceId,
|
|
909
|
+
isolationKey: this.schedulerIsolationKey,
|
|
910
|
+
offset: rangeOffset,
|
|
911
|
+
length: rangeLength,
|
|
912
|
+
signal: rangeSignal,
|
|
913
|
+
fetchRange: (transportOffset, transportLength, transportSignal) => this._fetchRange(transportOffset, transportLength, requestHeaders, transportSignal)
|
|
914
|
+
});
|
|
915
|
+
let arrayBuffer;
|
|
916
|
+
if (this.fileSize === null) {
|
|
917
|
+
// The first read can be shorter at EOF; it discovers the immutable file size.
|
|
918
|
+
arrayBuffer = await readRange(offset, length, signal);
|
|
919
|
+
this.rangeCache.set(this.sourceId, offset, arrayBuffer);
|
|
920
|
+
}
|
|
921
|
+
else {
|
|
922
|
+
const boundedLength = offset < this.fileSize ? Math.min(length, this.fileSize - offset) : length;
|
|
923
|
+
arrayBuffer = await this.rangeCache.read({
|
|
924
|
+
sourceId: this.sourceId,
|
|
925
|
+
offset,
|
|
926
|
+
length: boundedLength,
|
|
927
|
+
signal,
|
|
928
|
+
fetchRange: readRange
|
|
929
|
+
});
|
|
930
|
+
}
|
|
931
|
+
signal?.throwIfAborted();
|
|
932
|
+
return arrayBuffer;
|
|
933
|
+
}
|
|
934
|
+
finally {
|
|
935
|
+
this.pendingRequests--;
|
|
936
|
+
}
|
|
937
|
+
}
|
|
938
|
+
/** Fetches one transport range from the remote GeoTIFF. */
|
|
939
|
+
async _fetchRange(offset, length, headers, signal) {
|
|
940
|
+
let response = await this.fetch(this.url, {
|
|
941
|
+
headers: createRangeRequestHeaders(headers, offset, length),
|
|
942
|
+
signal
|
|
943
|
+
});
|
|
944
|
+
if (response.status === 416 && offset === 0) {
|
|
945
|
+
const actualLength = parseUnsatisfiedContentRange(response.headers.get('Content-Range'));
|
|
946
|
+
if (!actualLength || !Number.isSafeInteger(actualLength) || actualLength > length) {
|
|
947
|
+
throw new Error('Missing content-length on 416 response');
|
|
948
|
+
}
|
|
949
|
+
await response.body?.cancel().catch(() => { });
|
|
950
|
+
response = await this.fetch(this.url, {
|
|
951
|
+
headers: createRangeRequestHeaders(headers, 0, actualLength),
|
|
952
|
+
signal
|
|
953
|
+
});
|
|
954
|
+
}
|
|
955
|
+
if (response.status === 200) {
|
|
956
|
+
await response.body?.cancel().catch(() => { });
|
|
957
|
+
throw new Error('Byte-range request failed: server returned 200 instead of 206');
|
|
958
|
+
}
|
|
959
|
+
if (response.status !== 206) {
|
|
960
|
+
await response.body?.cancel().catch(() => { });
|
|
961
|
+
throw new Error(`Bad response code: ${response.status}`);
|
|
962
|
+
}
|
|
963
|
+
let total;
|
|
964
|
+
try {
|
|
965
|
+
const contentRange = response.headers.get('Content-Range');
|
|
966
|
+
if (this.requireContentRange && !contentRange)
|
|
967
|
+
throw new Error('GeoTIFF range responses require an exposed Content-Range header; configure Access-Control-Expose-Headers: Content-Range.');
|
|
968
|
+
total = validateGeoTIFFContentRange(contentRange, offset, length);
|
|
969
|
+
const entityTag = response.headers.get('ETag');
|
|
970
|
+
const lastModified = response.headers.get('Last-Modified');
|
|
971
|
+
if ((this.fileSize !== null && total !== null && this.fileSize !== total) ||
|
|
972
|
+
(this.entityTag && entityTag && this.entityTag !== entityTag) ||
|
|
973
|
+
(this.lastModified && lastModified && this.lastModified !== lastModified)) {
|
|
974
|
+
const error = new Error('Remote GeoTIFF revision changed; recreate the source');
|
|
975
|
+
this.onRevisionChange?.(error);
|
|
976
|
+
throw error;
|
|
977
|
+
}
|
|
978
|
+
if (total !== null)
|
|
979
|
+
this.fileSize = total;
|
|
980
|
+
this.entityTag ??= entityTag;
|
|
981
|
+
this.lastModified ??= lastModified;
|
|
982
|
+
}
|
|
983
|
+
catch (error) {
|
|
984
|
+
await response.body?.cancel().catch(() => { });
|
|
985
|
+
throw error;
|
|
986
|
+
}
|
|
987
|
+
const arrayBuffer = await readGeoTIFFRangeResponse(response, length, signal);
|
|
988
|
+
return {
|
|
989
|
+
arrayBuffer,
|
|
990
|
+
status: response.status,
|
|
991
|
+
sourceByteLength: this.fileSize ?? undefined,
|
|
992
|
+
transportBytes: arrayBuffer.byteLength
|
|
993
|
+
};
|
|
994
|
+
}
|
|
995
|
+
}
|
|
996
|
+
/** Creates the HTTP headers for one byte-range request. */
|
|
997
|
+
function createRangeRequestHeaders(headers, offset, length) {
|
|
998
|
+
const requestHeaders = new Headers(headers);
|
|
999
|
+
requestHeaders.set('Range', `bytes=${offset}-${offset + length - 1}`);
|
|
1000
|
+
return requestHeaders;
|
|
1001
|
+
}
|
|
1002
|
+
/** Parses one single-range `Range` header into offset and byte length. */
|
|
1003
|
+
function parseSingleRangeHeader(rangeHeader) {
|
|
1004
|
+
const match = rangeHeader?.match(/^bytes=(\d+)-(\d+)$/);
|
|
1005
|
+
if (!match) {
|
|
1006
|
+
throw new Error(`GeoTIFF range request requires a single byte range. Received: ${rangeHeader}`);
|
|
1007
|
+
}
|
|
1008
|
+
const offset = Number(match[1]);
|
|
1009
|
+
const endOffset = Number(match[2]);
|
|
1010
|
+
if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(endOffset) || endOffset < offset)
|
|
1011
|
+
throw new Error('Invalid GeoTIFF byte range');
|
|
1012
|
+
return { offset, length: endOffset - offset + 1 };
|
|
1013
|
+
}
|
|
1014
|
+
/** Validates response placement and optional object length before any encoded bytes are buffered. */
|
|
1015
|
+
function validateGeoTIFFContentRange(contentRange, offset, length) {
|
|
1016
|
+
if (!contentRange)
|
|
1017
|
+
return null; // CORS may hide this response header.
|
|
1018
|
+
const match = contentRange.match(/^bytes (\d+)-(\d+)\/(\d+|\*)$/);
|
|
1019
|
+
if (!match)
|
|
1020
|
+
throw new Error('Invalid GeoTIFF Content-Range');
|
|
1021
|
+
const start = Number(match[1]);
|
|
1022
|
+
const end = Number(match[2]);
|
|
1023
|
+
const total = match[3] === '*' ? null : Number(match[3]);
|
|
1024
|
+
if (![start, end].every(Number.isSafeInteger) ||
|
|
1025
|
+
start !== offset ||
|
|
1026
|
+
end < start ||
|
|
1027
|
+
(total !== null && (!Number.isSafeInteger(total) || total <= end)) ||
|
|
1028
|
+
end !== Math.min(offset + length - 1, total === null ? Infinity : total - 1))
|
|
1029
|
+
throw new Error('Contradictory GeoTIFF Content-Range');
|
|
1030
|
+
return total;
|
|
1031
|
+
}
|
|
1032
|
+
/** Reads at most one requested range, canceling lying or obsolete streams without buffering a whole asset. */
|
|
1033
|
+
async function readGeoTIFFRangeResponse(response, maximumBytes, signal) {
|
|
1034
|
+
if (!response.body)
|
|
1035
|
+
return new ArrayBuffer(0);
|
|
1036
|
+
const reader = response.body.getReader();
|
|
1037
|
+
const bytes = new Uint8Array(maximumBytes);
|
|
1038
|
+
let writtenBytes = 0;
|
|
1039
|
+
try {
|
|
1040
|
+
while (true) {
|
|
1041
|
+
const chunk = await waitForPromiseWithSignal(reader.read(), signal);
|
|
1042
|
+
if (chunk.done)
|
|
1043
|
+
break;
|
|
1044
|
+
if (writtenBytes + chunk.value.byteLength > maximumBytes)
|
|
1045
|
+
throw new Error('GeoTIFF range response exceeds byte budget');
|
|
1046
|
+
bytes.set(chunk.value, writtenBytes);
|
|
1047
|
+
writtenBytes += chunk.value.byteLength;
|
|
1048
|
+
}
|
|
1049
|
+
signal?.throwIfAborted();
|
|
1050
|
+
return writtenBytes === maximumBytes ? bytes.buffer : bytes.buffer.slice(0, writtenBytes);
|
|
1051
|
+
}
|
|
1052
|
+
finally {
|
|
1053
|
+
await reader.cancel().catch(() => { });
|
|
1054
|
+
reader.releaseLock();
|
|
1055
|
+
}
|
|
1056
|
+
}
|
|
1057
|
+
/** Parses the file length from a `416 Range Not Satisfiable` `Content-Range` header. */
|
|
1058
|
+
function parseUnsatisfiedContentRange(contentRange) {
|
|
1059
|
+
const match = contentRange?.match(/^bytes \*\/(\d+)$/);
|
|
1060
|
+
return match ? Number(match[1]) : null;
|
|
1061
|
+
}
|
|
1062
|
+
/** Preserves TIFF rotation/shear, or resolves the explicit origin and signed pixel spacing. */
|
|
1063
|
+
function getImageTransform(image, referenceImage) {
|
|
1064
|
+
const matrix = image.fileDirectory?.ModelTransformation;
|
|
1065
|
+
if (matrix)
|
|
1066
|
+
return [matrix[0], matrix[1], matrix[3], matrix[4], matrix[5], matrix[7]];
|
|
1067
|
+
if (image !== referenceImage &&
|
|
1068
|
+
!image.fileDirectory?.ModelTiepoint &&
|
|
1069
|
+
!image.fileDirectory?.ModelPixelScale) {
|
|
1070
|
+
const referenceTransform = getImageTransform(referenceImage, referenceImage);
|
|
1071
|
+
if (referenceTransform) {
|
|
1072
|
+
const scaleX = referenceImage.getWidth() / image.getWidth();
|
|
1073
|
+
const scaleY = referenceImage.getHeight() / image.getHeight();
|
|
1074
|
+
return [
|
|
1075
|
+
referenceTransform[0] * scaleX,
|
|
1076
|
+
referenceTransform[1] * scaleY,
|
|
1077
|
+
referenceTransform[2],
|
|
1078
|
+
referenceTransform[3] * scaleX,
|
|
1079
|
+
referenceTransform[4] * scaleY,
|
|
1080
|
+
referenceTransform[5]
|
|
1081
|
+
];
|
|
1082
|
+
}
|
|
1083
|
+
}
|
|
1084
|
+
try {
|
|
1085
|
+
const resolution = image.getResolution(referenceImage);
|
|
1086
|
+
let origin;
|
|
1087
|
+
try {
|
|
1088
|
+
origin = image.getOrigin();
|
|
1089
|
+
}
|
|
1090
|
+
catch {
|
|
1091
|
+
origin = referenceImage.getOrigin();
|
|
1092
|
+
}
|
|
1093
|
+
const tiepoint = image.fileDirectory?.ModelTiepoint;
|
|
1094
|
+
return [
|
|
1095
|
+
resolution[0],
|
|
1096
|
+
0,
|
|
1097
|
+
origin[0] - (tiepoint?.[0] ?? 0) * resolution[0],
|
|
1098
|
+
0,
|
|
1099
|
+
resolution[1],
|
|
1100
|
+
origin[1] - (tiepoint?.[1] ?? 0) * resolution[1]
|
|
1101
|
+
];
|
|
1102
|
+
}
|
|
1103
|
+
catch {
|
|
1104
|
+
return undefined;
|
|
1105
|
+
}
|
|
1106
|
+
}
|
|
1107
|
+
/** Parses finite numeric metadata without interpreting empty content as zero. */
|
|
1108
|
+
function parseFiniteMetadataValue(value) {
|
|
1109
|
+
if (typeof value !== 'number' && typeof value !== 'string')
|
|
1110
|
+
return undefined;
|
|
1111
|
+
if (typeof value === 'string' && !value.trim())
|
|
1112
|
+
return undefined;
|
|
1113
|
+
const numericValue = Number(value);
|
|
1114
|
+
return Number.isFinite(numericValue) ? numericValue : undefined;
|
|
1115
|
+
}
|
|
1116
|
+
/** Interprets optional GDAL band attributes while retaining samples in the raw domain. */
|
|
1117
|
+
function getImageBandMetadata(image, index, noData) {
|
|
1118
|
+
const metadata = image.getGDALMetadata?.(index) || {};
|
|
1119
|
+
const scale = parseFiniteMetadataValue(metadata.SCALE);
|
|
1120
|
+
const offset = parseFiniteMetadataValue(metadata.OFFSET);
|
|
1121
|
+
if ((metadata.SCALE !== undefined && scale === undefined) ||
|
|
1122
|
+
(metadata.OFFSET !== undefined && offset === undefined))
|
|
1123
|
+
throw new Error('Invalid GDAL band scale or offset');
|
|
1124
|
+
const minimumValue = parseFiniteMetadataValue(metadata.STATISTICS_MINIMUM);
|
|
1125
|
+
const maximumValue = parseFiniteMetadataValue(metadata.STATISTICS_MAXIMUM);
|
|
1126
|
+
const hasMinimum = minimumValue !== undefined;
|
|
1127
|
+
const hasMaximum = maximumValue !== undefined;
|
|
1128
|
+
const hasDeclaredRange = (hasMinimum || hasMaximum) && !(hasMinimum && hasMaximum && minimumValue > maximumValue);
|
|
1129
|
+
return {
|
|
1130
|
+
index,
|
|
1131
|
+
declaredStatistics: hasDeclaredRange
|
|
1132
|
+
? {
|
|
1133
|
+
band: index,
|
|
1134
|
+
domain: 'unknown',
|
|
1135
|
+
scope: 'source',
|
|
1136
|
+
method: 'declared',
|
|
1137
|
+
min: hasMinimum ? minimumValue : undefined,
|
|
1138
|
+
max: hasMaximum ? maximumValue : undefined
|
|
1139
|
+
}
|
|
1140
|
+
: undefined,
|
|
1141
|
+
dtype: getImageDataType(image, index),
|
|
1142
|
+
categorical: index === 0 && image.fileDirectory?.PhotometricInterpretation === 3 ? true : undefined,
|
|
1143
|
+
name: typeof metadata.DESCRIPTION === 'string' ? metadata.DESCRIPTION : undefined,
|
|
1144
|
+
units: typeof metadata.UNITTYPE === 'string' ? metadata.UNITTYPE : undefined,
|
|
1145
|
+
scale,
|
|
1146
|
+
offset,
|
|
1147
|
+
noData
|
|
1148
|
+
};
|
|
1149
|
+
}
|
|
1150
|
+
/** Resamples native windows with shared raw-domain validity; yields between row groups for cancellation. */
|
|
1151
|
+
async function resizeRasterWindow(nativeRaster, bands, interleaved, targetSize, method, signal, nativeValidityMasks) {
|
|
1152
|
+
signal?.throwIfAborted();
|
|
1153
|
+
if (nativeRaster.width === targetSize.width && nativeRaster.height === targetSize.height) {
|
|
1154
|
+
const raster = interleaved
|
|
1155
|
+
? await interleaveRasterBands(nativeRaster, bands[0].dtype, signal)
|
|
1156
|
+
: nativeRaster;
|
|
1157
|
+
return { raster, validityMasks: nativeValidityMasks };
|
|
1158
|
+
}
|
|
1159
|
+
const data = normalizeRasterReadResult(nativeRaster, false);
|
|
1160
|
+
const mixed = bands.some(band => band.dtype !== bands[0].dtype);
|
|
1161
|
+
const input = {
|
|
1162
|
+
data,
|
|
1163
|
+
dtype: mixed ? 'mixed' : bands[0].dtype,
|
|
1164
|
+
interleaved: false,
|
|
1165
|
+
width: nativeRaster.width,
|
|
1166
|
+
height: nativeRaster.height,
|
|
1167
|
+
bandCount: bands.length,
|
|
1168
|
+
bands,
|
|
1169
|
+
validityMasks: nativeValidityMasks
|
|
1170
|
+
};
|
|
1171
|
+
const pixelCount = targetSize.width * targetSize.height;
|
|
1172
|
+
const output = interleaved
|
|
1173
|
+
? createFilledTypedArray(bands[0].dtype, pixelCount * bands.length, 0)
|
|
1174
|
+
: bands.map(band => createFilledTypedArray(band.dtype, pixelCount, band.noData ?? 0));
|
|
1175
|
+
const validityMasks = bands.map((_band, band) => ({
|
|
1176
|
+
data: new Uint8Array(pixelCount),
|
|
1177
|
+
band,
|
|
1178
|
+
width: targetSize.width,
|
|
1179
|
+
height: targetSize.height,
|
|
1180
|
+
pixelStride: 1,
|
|
1181
|
+
rowStride: targetSize.width
|
|
1182
|
+
}));
|
|
1183
|
+
for (let row = 0; row < targetSize.height; row++) {
|
|
1184
|
+
for (let column = 0; column < targetSize.width; column++) {
|
|
1185
|
+
const pixelIndex = row * targetSize.width + column;
|
|
1186
|
+
if (pixelIndex % 32768 === 0) {
|
|
1187
|
+
signal?.throwIfAborted();
|
|
1188
|
+
if (pixelIndex > 0)
|
|
1189
|
+
await new Promise(resolve => setTimeout(resolve, 0));
|
|
1190
|
+
signal?.throwIfAborted();
|
|
1191
|
+
}
|
|
1192
|
+
const sample = sampleRaster(input, [
|
|
1193
|
+
((column + 0.5) * nativeRaster.width) / targetSize.width - 0.5,
|
|
1194
|
+
((row + 0.5) * nativeRaster.height) / targetSize.height - 0.5
|
|
1195
|
+
], { method });
|
|
1196
|
+
for (let band = 0; band < bands.length; band++) {
|
|
1197
|
+
const value = sample.values[band];
|
|
1198
|
+
if (value === undefined || !Number.isFinite(value))
|
|
1199
|
+
continue;
|
|
1200
|
+
if (Array.isArray(output))
|
|
1201
|
+
output[band][pixelIndex] = value;
|
|
1202
|
+
else
|
|
1203
|
+
output[pixelIndex * bands.length + band] = value;
|
|
1204
|
+
validityMasks[band].data[pixelIndex] = 1;
|
|
1205
|
+
}
|
|
1206
|
+
}
|
|
1207
|
+
}
|
|
1208
|
+
signal?.throwIfAborted();
|
|
1209
|
+
const raster = Object.assign(output, {
|
|
1210
|
+
width: targetSize.width,
|
|
1211
|
+
height: targetSize.height
|
|
1212
|
+
});
|
|
1213
|
+
return { raster, validityMasks };
|
|
1214
|
+
}
|
|
1215
|
+
/** Packs native planar bands without widening, scaling, or replacing invalid raw values. */
|
|
1216
|
+
async function interleaveRasterBands(raster, dtype, signal) {
|
|
1217
|
+
const arrays = Array.isArray(raster) ? raster : [raster];
|
|
1218
|
+
const pixelCount = raster.width * raster.height;
|
|
1219
|
+
const output = createFilledTypedArray(dtype, pixelCount * arrays.length, 0);
|
|
1220
|
+
for (let pixel = 0; pixel < pixelCount; pixel++) {
|
|
1221
|
+
if (pixel % 32768 === 0) {
|
|
1222
|
+
signal?.throwIfAborted();
|
|
1223
|
+
if (pixel > 0)
|
|
1224
|
+
await new Promise(resolve => setTimeout(resolve, 0));
|
|
1225
|
+
signal?.throwIfAborted();
|
|
1226
|
+
}
|
|
1227
|
+
for (let band = 0; band < arrays.length; band++)
|
|
1228
|
+
output[pixel * arrays.length + band] = arrays[band][pixel];
|
|
1229
|
+
}
|
|
1230
|
+
signal?.throwIfAborted();
|
|
1231
|
+
return Object.assign(output, {
|
|
1232
|
+
width: raster.width,
|
|
1233
|
+
height: raster.height
|
|
1234
|
+
});
|
|
1235
|
+
}
|
|
1236
|
+
/** Describes an explicitly invalid output grid in the caller's declared source CRS. */
|
|
1237
|
+
function createRegionTransform(bounds, width, height) {
|
|
1238
|
+
return [
|
|
1239
|
+
(bounds[1][0] - bounds[0][0]) / width,
|
|
1240
|
+
0,
|
|
1241
|
+
bounds[0][0],
|
|
1242
|
+
0,
|
|
1243
|
+
-(bounds[1][1] - bounds[0][1]) / height,
|
|
1244
|
+
bounds[1][1]
|
|
1245
|
+
];
|
|
1246
|
+
}
|
|
1247
|
+
/** Estimates all concurrently decoded tiles intersecting a native window, including unselected channels. */
|
|
1248
|
+
function estimateImageTileBytes(image, window, bytesPerPixel) {
|
|
1249
|
+
const tileWidth = image.getTileWidth?.() ?? window[2] - window[0];
|
|
1250
|
+
const tileHeight = image.getTileHeight?.() ?? window[3] - window[1];
|
|
1251
|
+
if (![tileWidth, tileHeight].every(value => Number.isSafeInteger(value) && value > 0))
|
|
1252
|
+
throw new Error('Invalid GeoTIFF tile dimensions');
|
|
1253
|
+
const columns = Math.ceil(window[2] / tileWidth) - Math.floor(window[0] / tileWidth);
|
|
1254
|
+
const rows = Math.ceil(window[3] / tileHeight) - Math.floor(window[1] / tileHeight);
|
|
1255
|
+
return columns * rows * tileWidth * tileHeight * bytesPerPixel;
|
|
1256
|
+
}
|
|
1257
|
+
/** Builds native storage-tile geometry without decoding samples or treating strips as tiles. */
|
|
1258
|
+
export function getImageTileGrid(images, referenceImage) {
|
|
1259
|
+
const coordinateReferenceSystem = getImageCRS(referenceImage);
|
|
1260
|
+
if (!coordinateReferenceSystem)
|
|
1261
|
+
return undefined;
|
|
1262
|
+
const matrices = images.flatMap((image, index) => {
|
|
1263
|
+
if (image.fileDirectory?.NewSubfileType & 4)
|
|
1264
|
+
return [];
|
|
1265
|
+
if (image !== referenceImage &&
|
|
1266
|
+
!(image.fileDirectory?.NewSubfileType & 1) &&
|
|
1267
|
+
image.fileDirectory?.SubfileType !== 2)
|
|
1268
|
+
return [];
|
|
1269
|
+
const transform = getImageTransform(image, referenceImage);
|
|
1270
|
+
const imageCoordinateReferenceSystem = getImageCRS(image);
|
|
1271
|
+
const imageCoordinateMetadata = image.getGeoKeys?.() || {};
|
|
1272
|
+
const hasDeclaredCoordinateReferenceSystem = Object.entries(imageCoordinateMetadata).some(([key, value]) => key !== 'GTRasterTypeGeoKey' && value !== undefined && value !== null);
|
|
1273
|
+
if ((hasDeclaredCoordinateReferenceSystem && !imageCoordinateReferenceSystem) ||
|
|
1274
|
+
(imageCoordinateReferenceSystem &&
|
|
1275
|
+
imageCoordinateReferenceSystem !== coordinateReferenceSystem) ||
|
|
1276
|
+
!image.fileDirectory?.TileWidth ||
|
|
1277
|
+
!image.fileDirectory?.TileLength ||
|
|
1278
|
+
!transform ||
|
|
1279
|
+
transform[1] !== 0 ||
|
|
1280
|
+
transform[3] !== 0 ||
|
|
1281
|
+
transform[0] <= 0 ||
|
|
1282
|
+
transform[4] === 0) {
|
|
1283
|
+
return [undefined];
|
|
1284
|
+
}
|
|
1285
|
+
const pointRegistration = (imageCoordinateMetadata.GTRasterTypeGeoKey ??
|
|
1286
|
+
referenceImage.getGeoKeys()?.GTRasterTypeGeoKey) === 2;
|
|
1287
|
+
const inheritedTransform = image !== referenceImage &&
|
|
1288
|
+
!image.fileDirectory.ModelTransformation &&
|
|
1289
|
+
!image.fileDirectory.ModelTiepoint &&
|
|
1290
|
+
!image.fileDirectory.ModelPixelScale;
|
|
1291
|
+
const cornerPointRegistration = inheritedTransform
|
|
1292
|
+
? referenceImage.getGeoKeys()?.GTRasterTypeGeoKey === 2
|
|
1293
|
+
: pointRegistration;
|
|
1294
|
+
const cornerTransform = inheritedTransform
|
|
1295
|
+
? getImageTransform(referenceImage, referenceImage)
|
|
1296
|
+
: transform;
|
|
1297
|
+
return [
|
|
1298
|
+
createTileGridMatrix({
|
|
1299
|
+
id: String(index),
|
|
1300
|
+
resolution: transform[0],
|
|
1301
|
+
resolutionY: Math.abs(transform[4]),
|
|
1302
|
+
point: cornerPointRegistration
|
|
1303
|
+
? [
|
|
1304
|
+
cornerTransform[2] - cornerTransform[0] / 2,
|
|
1305
|
+
cornerTransform[5] - cornerTransform[4] / 2
|
|
1306
|
+
]
|
|
1307
|
+
: [cornerTransform[2], cornerTransform[5]],
|
|
1308
|
+
swapAxes: false,
|
|
1309
|
+
cornerOfOrigin: transform[4] < 0 ? 'topLeft' : 'bottomLeft',
|
|
1310
|
+
tileWidth: image.getTileWidth(),
|
|
1311
|
+
tileHeight: image.getTileHeight(),
|
|
1312
|
+
matrixWidth: Math.ceil(image.getWidth() / image.getTileWidth()),
|
|
1313
|
+
matrixHeight: Math.ceil(image.getHeight() / image.getTileHeight())
|
|
1314
|
+
})
|
|
1315
|
+
];
|
|
1316
|
+
});
|
|
1317
|
+
if (!matrices.length || matrices.some(matrix => !matrix))
|
|
1318
|
+
return undefined;
|
|
1319
|
+
const grid = createTileGrid(coordinateReferenceSystem, matrices.filter(matrix => matrix !== undefined));
|
|
1320
|
+
return grid.tileMatrixSet ? grid : undefined;
|
|
1321
|
+
}
|
|
1322
|
+
//# sourceMappingURL=geotiff-source-loader.js.map
|