@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,1955 @@
|
|
|
1
|
+
var __create = Object.create;
|
|
2
|
+
var __defProp = Object.defineProperty;
|
|
3
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
6
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
7
|
+
var __export = (target, all) => {
|
|
8
|
+
for (var name in all)
|
|
9
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
10
|
+
};
|
|
11
|
+
var __copyProps = (to, from, except, desc) => {
|
|
12
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
13
|
+
for (let key of __getOwnPropNames(from))
|
|
14
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
15
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
16
|
+
}
|
|
17
|
+
return to;
|
|
18
|
+
};
|
|
19
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
20
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
21
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
22
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
23
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
24
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
25
|
+
mod
|
|
26
|
+
));
|
|
27
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
28
|
+
|
|
29
|
+
// dist/geotiff/advanced.js
|
|
30
|
+
var advanced_exports = {};
|
|
31
|
+
__export(advanced_exports, {
|
|
32
|
+
GeoTIFFFormat: () => GeoTIFFFormat,
|
|
33
|
+
GeoTIFFLoader: () => GeoTIFFLoader,
|
|
34
|
+
GeoTIFFRasterLoader: () => GeoTIFFRasterLoader,
|
|
35
|
+
GeoTIFFRasterSource: () => GeoTIFFRasterSource,
|
|
36
|
+
GeoTIFFSourceLoader: () => GeoTIFFSourceLoader,
|
|
37
|
+
OMETiffFormat: () => OMETiffFormat,
|
|
38
|
+
OMETiffImageSource: () => OMETiffImageSource,
|
|
39
|
+
OMETiffSourceLoader: () => OMETiffSourceLoader,
|
|
40
|
+
TiffPixelSource: () => TiffPixelSource,
|
|
41
|
+
discoverGeoTIFF: () => discoverGeoTIFF,
|
|
42
|
+
isTIFFHeader: () => isTIFFHeader,
|
|
43
|
+
loadGeoTiff: () => loadGeoTiff
|
|
44
|
+
});
|
|
45
|
+
module.exports = __toCommonJS(advanced_exports);
|
|
46
|
+
|
|
47
|
+
// dist/geotiff/geotiff-format.js
|
|
48
|
+
var GeoTIFFFormat = {
|
|
49
|
+
id: "geotiff",
|
|
50
|
+
name: "GeoTIFF",
|
|
51
|
+
module: "raster",
|
|
52
|
+
encoding: "image",
|
|
53
|
+
format: "geotiff",
|
|
54
|
+
mimeTypes: ["image/tiff"],
|
|
55
|
+
extensions: ["geotiff", "tiff", "geotif", "tif"]
|
|
56
|
+
};
|
|
57
|
+
var OMETiffFormat = {
|
|
58
|
+
name: "OME-TIFF",
|
|
59
|
+
id: "ometiff",
|
|
60
|
+
module: "raster",
|
|
61
|
+
encoding: "image",
|
|
62
|
+
format: "ome-tiff",
|
|
63
|
+
extensions: ["ome.tif", "ome.tiff"],
|
|
64
|
+
mimeTypes: ["image/tiff", "image/geotiff"]
|
|
65
|
+
};
|
|
66
|
+
|
|
67
|
+
// dist/geotiff/geotiff-loader-types.js
|
|
68
|
+
var VERSION = true ? "5.0.0-alpha.14" : "latest";
|
|
69
|
+
async function preload() {
|
|
70
|
+
const { GeoTIFFLoaderWithParser } = await import("@loaders.gl/raster/geotiff/geotiff-loader");
|
|
71
|
+
return GeoTIFFLoaderWithParser;
|
|
72
|
+
}
|
|
73
|
+
var GeoTIFFLoader = {
|
|
74
|
+
dataType: null,
|
|
75
|
+
batchType: null,
|
|
76
|
+
...GeoTIFFFormat,
|
|
77
|
+
version: VERSION,
|
|
78
|
+
options: {
|
|
79
|
+
geotiff: {
|
|
80
|
+
enableAlpha: true
|
|
81
|
+
}
|
|
82
|
+
},
|
|
83
|
+
preload
|
|
84
|
+
};
|
|
85
|
+
|
|
86
|
+
// dist/geotiff/lib/tiff/geotiff-source-adapter.js
|
|
87
|
+
var import_geotiff = require("geotiff");
|
|
88
|
+
async function openGeoTIFFSourceDecoder(source, signal) {
|
|
89
|
+
const dataset = source instanceof Blob ? await (0, import_geotiff.fromBlob)(source, signal) : await import_geotiff.GeoTIFF.fromSource(source, { cache: false }, signal);
|
|
90
|
+
const originalImages = /* @__PURE__ */ new WeakMap();
|
|
91
|
+
const imageCache = /* @__PURE__ */ new Map();
|
|
92
|
+
return {
|
|
93
|
+
getImageCount: () => dataset.getImageCount(),
|
|
94
|
+
/** Wraps each image once; the original image is accessible only inside this adapter. */
|
|
95
|
+
getImage: async (index) => {
|
|
96
|
+
const cached = imageCache.get(index);
|
|
97
|
+
if (cached)
|
|
98
|
+
return cached;
|
|
99
|
+
const original = await dataset.getImage(index);
|
|
100
|
+
const image = {
|
|
101
|
+
fileDirectory: {
|
|
102
|
+
...original.fileDirectory,
|
|
103
|
+
NewSubfileType: original.fileDirectory.NewSubfileType ?? 0
|
|
104
|
+
},
|
|
105
|
+
getWidth: () => original.getWidth(),
|
|
106
|
+
getHeight: () => original.getHeight(),
|
|
107
|
+
getSamplesPerPixel: () => original.getSamplesPerPixel(),
|
|
108
|
+
getTileWidth: () => original.getTileWidth(),
|
|
109
|
+
getTileHeight: () => original.getTileHeight(),
|
|
110
|
+
getBitsPerSample: (band) => original.getBitsPerSample(band),
|
|
111
|
+
getSampleFormat: (band) => original.getSampleFormat(band),
|
|
112
|
+
getGeoKeys: () => original.getGeoKeys() ?? null,
|
|
113
|
+
getGDALMetadata: (band) => original.getGDALMetadata(band) ?? null,
|
|
114
|
+
getGDALNoData: () => original.getGDALNoData() ?? null,
|
|
115
|
+
getBoundingBox: () => original.getBoundingBox(),
|
|
116
|
+
getResolution: (reference) => original.getResolution(originalImages.get(reference)),
|
|
117
|
+
getOrigin: () => original.getOrigin(),
|
|
118
|
+
readRasters: async (options) => await original.readRasters(options)
|
|
119
|
+
};
|
|
120
|
+
imageCache.set(index, image);
|
|
121
|
+
originalImages.set(image, original);
|
|
122
|
+
return image;
|
|
123
|
+
},
|
|
124
|
+
readRasters: async (options) => await dataset.readRasters(options),
|
|
125
|
+
close: async () => {
|
|
126
|
+
imageCache.clear();
|
|
127
|
+
await dataset.close();
|
|
128
|
+
}
|
|
129
|
+
};
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
// dist/geotiff/geotiff-source-loader.js
|
|
133
|
+
var import_loader_utils = require("@loaders.gl/core/loader-utils");
|
|
134
|
+
var VERSION2 = true ? "5.0.0-alpha.14" : "latest";
|
|
135
|
+
var GEOTIFF_RASTER_QUERY_CAPABILITIES = Object.freeze({
|
|
136
|
+
bounds: "pushdown",
|
|
137
|
+
level: "pushdown",
|
|
138
|
+
variables: "pushdown",
|
|
139
|
+
slices: "unsupported",
|
|
140
|
+
streaming: false,
|
|
141
|
+
cancellation: true
|
|
142
|
+
});
|
|
143
|
+
var GeoTIFFSourceLoader = {
|
|
144
|
+
dataType: null,
|
|
145
|
+
batchType: null,
|
|
146
|
+
...GeoTIFFFormat,
|
|
147
|
+
name: "GeoTIFFSourceLoader",
|
|
148
|
+
version: VERSION2,
|
|
149
|
+
type: "geotiff",
|
|
150
|
+
fromUrl: true,
|
|
151
|
+
fromBlob: true,
|
|
152
|
+
options: {
|
|
153
|
+
geotiff: {
|
|
154
|
+
headers: void 0,
|
|
155
|
+
interleaved: false,
|
|
156
|
+
resampleMethod: "nearest"
|
|
157
|
+
}
|
|
158
|
+
},
|
|
159
|
+
defaultOptions: {
|
|
160
|
+
geotiff: {
|
|
161
|
+
headers: void 0,
|
|
162
|
+
interleaved: false,
|
|
163
|
+
resampleMethod: "nearest"
|
|
164
|
+
}
|
|
165
|
+
},
|
|
166
|
+
testURL: (url) => {
|
|
167
|
+
if (/\.ome\.tiff?(?:$|[?#])/i.test(url)) {
|
|
168
|
+
return false;
|
|
169
|
+
}
|
|
170
|
+
return /\.(?:geotiff?|tiff?)(?:$|[?#])/i.test(url);
|
|
171
|
+
},
|
|
172
|
+
createDataSource: (data, options) => new GeoTIFFRasterSource(data, options)
|
|
173
|
+
};
|
|
174
|
+
var GeoTIFFRasterSource = class extends import_loader_utils.DataSource {
|
|
175
|
+
/** Capabilities advertised by this viewport-driven raster source. */
|
|
176
|
+
rasterQueryCapabilities = GEOTIFF_RASTER_QUERY_CAPABILITIES;
|
|
177
|
+
/** Explicit numeric region support without a viewport dependency. */
|
|
178
|
+
supportsRegion = true;
|
|
179
|
+
_initPromise = null;
|
|
180
|
+
/** Shared metadata transport controller, with leases for concurrent callers. */
|
|
181
|
+
_initialization = null;
|
|
182
|
+
_rangeScheduler = null;
|
|
183
|
+
/** Bounded source-owned encoded byte cache with subscriber-aware cancellation. */
|
|
184
|
+
_rangeCache = null;
|
|
185
|
+
/** Cancellation shared by work owned by this source, including borrowed scheduler subscriptions. */
|
|
186
|
+
_finalizationController = new AbortController();
|
|
187
|
+
/** Creates a viewport-driven raster source backed by a GeoTIFF URL or Blob. */
|
|
188
|
+
constructor(data, options) {
|
|
189
|
+
super(data, options, GeoTIFFSourceLoader.defaultOptions);
|
|
190
|
+
if (options.geotiff?.rangeSchedulerProps) {
|
|
191
|
+
this.options.geotiff ||= {};
|
|
192
|
+
this.options.geotiff.rangeSchedulerProps = options.geotiff.rangeSchedulerProps;
|
|
193
|
+
}
|
|
194
|
+
if (options.geotiff?.rangeScheduler) {
|
|
195
|
+
this.options.geotiff ||= {};
|
|
196
|
+
this.options.geotiff.rangeScheduler = options.geotiff.rangeScheduler;
|
|
197
|
+
}
|
|
198
|
+
}
|
|
199
|
+
/**
|
|
200
|
+
* Returns normalized GeoTIFF metadata without loading raster samples.
|
|
201
|
+
*/
|
|
202
|
+
async getMetadata(options = {}) {
|
|
203
|
+
return (0, import_loader_utils.waitForPromiseWithSignals)(async (signal) => {
|
|
204
|
+
const { metadata } = await this._getInitPromise(signal);
|
|
205
|
+
signal.throwIfAborted();
|
|
206
|
+
return metadata;
|
|
207
|
+
}, [options.signal, this._finalizationController.signal]);
|
|
208
|
+
}
|
|
209
|
+
/** Cancels transport owned by this source while preserving an injected shared scheduler. */
|
|
210
|
+
finalize() {
|
|
211
|
+
this._finalizationController.abort();
|
|
212
|
+
this._initialization?.controller.abort();
|
|
213
|
+
this._rangeScheduler?.finalize();
|
|
214
|
+
this._rangeCache?.clear();
|
|
215
|
+
this._rangeCache = null;
|
|
216
|
+
const initializationPromise = this._initPromise;
|
|
217
|
+
this._initPromise = null;
|
|
218
|
+
this._initialization = null;
|
|
219
|
+
void initializationPromise?.then(({ tiff }) => tiff.close()).catch(() => {
|
|
220
|
+
});
|
|
221
|
+
}
|
|
222
|
+
/** Returns raster-query capabilities without opening raster samples. */
|
|
223
|
+
getRasterQueryCapabilities() {
|
|
224
|
+
return this.rasterQueryCapabilities;
|
|
225
|
+
}
|
|
226
|
+
/** Discovers raster bands, bounds, and overview levels for the shared scan query panel. */
|
|
227
|
+
async getQueryMetadata(options = {}) {
|
|
228
|
+
options.signal?.throwIfAborted();
|
|
229
|
+
const metadata = await this.getMetadata(options);
|
|
230
|
+
options.signal?.throwIfAborted();
|
|
231
|
+
const fields = Array.from({ length: metadata.bandCount }, (_, index) => ({
|
|
232
|
+
name: `band_${index + 1}`,
|
|
233
|
+
type: metadata.bands?.[index]?.dtype ?? metadata.dtype,
|
|
234
|
+
nullable: metadata.noData !== null,
|
|
235
|
+
metadata: {}
|
|
236
|
+
}));
|
|
237
|
+
return (0, import_loader_utils.createScanQueryMetadata)({
|
|
238
|
+
sourceType: "geotiff",
|
|
239
|
+
queryType: "raster",
|
|
240
|
+
execution: { status: "supported", method: "getRaster" },
|
|
241
|
+
name: metadata.name,
|
|
242
|
+
schema: { fields, metadata: {} },
|
|
243
|
+
capabilities: {
|
|
244
|
+
bounds: this.rasterQueryCapabilities.bounds,
|
|
245
|
+
levelOfDetail: this.rasterQueryCapabilities.level
|
|
246
|
+
},
|
|
247
|
+
spatial: metadata.boundingBox ? {
|
|
248
|
+
bounds: { minimum: metadata.boundingBox[0], maximum: metadata.boundingBox[1] },
|
|
249
|
+
coordinateReferenceSystems: typeof metadata.crs === "string" ? [metadata.crs] : void 0
|
|
250
|
+
} : void 0,
|
|
251
|
+
levels: metadata.overviews?.map((overview) => ({
|
|
252
|
+
index: overview.index,
|
|
253
|
+
width: overview.width,
|
|
254
|
+
height: overview.height,
|
|
255
|
+
scale: [metadata.width / overview.width, metadata.height / overview.height]
|
|
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) {
|
|
265
|
+
parameters.signal?.throwIfAborted();
|
|
266
|
+
const metadata = await this.getMetadata({ signal: parameters.signal });
|
|
267
|
+
const raster = await this._readRegion({
|
|
268
|
+
...parameters,
|
|
269
|
+
bounds: (0, import_loader_utils.getRasterViewportBoundingBox)(parameters.viewport),
|
|
270
|
+
crs: parameters.viewport.crs ?? metadata.crs,
|
|
271
|
+
width: parameters.viewport.width,
|
|
272
|
+
height: parameters.viewport.height
|
|
273
|
+
}, false);
|
|
274
|
+
if (raster.dtype === "mixed")
|
|
275
|
+
throw new Error("Mixed-type GeoTIFF viewport reads require separate single-band requests; use getRasterForRegion for a mixed planar result");
|
|
276
|
+
return raster;
|
|
277
|
+
}
|
|
278
|
+
/** Reads an explicit region in the source CRS through the shared window pipeline. */
|
|
279
|
+
async getRasterForRegion(parameters) {
|
|
280
|
+
return this._readRegion(parameters, true);
|
|
281
|
+
}
|
|
282
|
+
/** Validates and decodes one source-coordinate window for both public entry points. */
|
|
283
|
+
_readRegion(parameters, requireCrs) {
|
|
284
|
+
return (0, import_loader_utils.waitForPromiseWithSignals)((signal) => this._decodeRegion({ ...parameters, signal }, requireCrs), [parameters.signal, this._finalizationController.signal]);
|
|
285
|
+
}
|
|
286
|
+
/** Runs the native decode pipeline; callers observe cancellation even for noninterruptible codecs. */
|
|
287
|
+
async _decodeRegion(parameters, requireCrs) {
|
|
288
|
+
parameters.signal?.throwIfAborted();
|
|
289
|
+
const { tiff, images, metadata } = await this._getInitPromise(parameters.signal);
|
|
290
|
+
parameters.signal?.throwIfAborted();
|
|
291
|
+
const viewportBoundingBox = parameters.bounds;
|
|
292
|
+
if (requireCrs && (!metadata.crs || !parameters.crs) || parameters.crs && metadata.crs !== parameters.crs)
|
|
293
|
+
throw new Error("GeoTIFFRasterSource does not support reprojection; source and request CRS must match");
|
|
294
|
+
if (!metadata.boundingBox)
|
|
295
|
+
throw new Error("GeoTIFFRasterSource requires source bounds");
|
|
296
|
+
const bandCount = parameters.bands?.length ?? metadata.bandCount;
|
|
297
|
+
if (!bandCount || parameters.bands?.some((band) => !Number.isInteger(band) || band < 0 || band >= metadata.bandCount))
|
|
298
|
+
throw new Error("Invalid raster bands");
|
|
299
|
+
const selectedBands = parameters.bands ?? Array.from({ length: bandCount }, (_, index) => index);
|
|
300
|
+
const outputDtype = metadata.bands?.[selectedBands[0]]?.dtype ?? metadata.dtype;
|
|
301
|
+
const mixed = selectedBands.some((index) => metadata.bands?.[index] && metadata.bands[index].dtype !== outputDtype);
|
|
302
|
+
const interleaved = parameters.interleaved ?? this.options.geotiff?.interleaved ?? false;
|
|
303
|
+
if (mixed && !requireCrs)
|
|
304
|
+
throw new Error("Mixed-type GeoTIFF viewport reads require separate single-band requests");
|
|
305
|
+
if (mixed && interleaved)
|
|
306
|
+
throw new Error("Mixed-type GeoTIFF regions require planar arrays");
|
|
307
|
+
const bytesPerPixel = selectedBands.reduce((bytes, index) => bytes + Number((metadata.bands?.[index]?.dtype ?? metadata.dtype).match(/\d+/)?.[0] ?? 64) / 8, 0);
|
|
308
|
+
const maxPixels = parameters.maxPixels ?? this.options.geotiff?.maxPixels ?? 16e6;
|
|
309
|
+
const maxDecodedBytes = parameters.maxDecodedBytes ?? this.options.geotiff?.maxDecodedBytes ?? 256 * 1024 * 1024;
|
|
310
|
+
const pixels = (0, import_loader_utils.validateRasterRegion)(viewportBoundingBox, parameters.width, parameters.height, bytesPerPixel, maxPixels, maxDecodedBytes);
|
|
311
|
+
const clippedBoundingBox = intersectBoundingBoxes(viewportBoundingBox, metadata.boundingBox);
|
|
312
|
+
if (!clippedBoundingBox) {
|
|
313
|
+
if (pixels * (bytesPerPixel + 1) > maxDecodedBytes)
|
|
314
|
+
throw new Error("Empty raster mask exceeds decoded-byte budget");
|
|
315
|
+
if (mixed) {
|
|
316
|
+
return {
|
|
317
|
+
data: selectedBands.map((index) => createFilledTypedArray(metadata.bands[index].dtype, pixels, metadata.bands[index].noData ?? 0)),
|
|
318
|
+
dtype: "mixed",
|
|
319
|
+
interleaved: false,
|
|
320
|
+
bands: selectedBands.map((index) => metadata.bands[index]),
|
|
321
|
+
width: parameters.width,
|
|
322
|
+
height: parameters.height,
|
|
323
|
+
bandCount,
|
|
324
|
+
crs: metadata.crs,
|
|
325
|
+
boundingBox: parameters.bounds,
|
|
326
|
+
transform: createRegionTransform(parameters.bounds, parameters.width, parameters.height),
|
|
327
|
+
pixelRegistration: "area",
|
|
328
|
+
provenance: { sourceType: "geotiff" },
|
|
329
|
+
ownership: "owned",
|
|
330
|
+
validityMasks: [
|
|
331
|
+
{ data: new Uint8Array(pixels), width: parameters.width, height: parameters.height }
|
|
332
|
+
]
|
|
333
|
+
};
|
|
334
|
+
}
|
|
335
|
+
const empty = createEmptyRaster(parameters, { ...metadata, dtype: outputDtype });
|
|
336
|
+
empty.validityMasks = [
|
|
337
|
+
{ data: new Uint8Array(pixels), width: parameters.width, height: parameters.height }
|
|
338
|
+
];
|
|
339
|
+
return empty;
|
|
340
|
+
}
|
|
341
|
+
const targetSize = getClippedTargetSize(viewportBoundingBox, clippedBoundingBox, parameters);
|
|
342
|
+
const fillValue = metadata.noData ?? void 0;
|
|
343
|
+
const requestedResolution = [
|
|
344
|
+
(clippedBoundingBox[1][0] - clippedBoundingBox[0][0]) / targetSize.width,
|
|
345
|
+
(clippedBoundingBox[1][1] - clippedBoundingBox[0][1]) / targetSize.height
|
|
346
|
+
];
|
|
347
|
+
let overview = 0;
|
|
348
|
+
let transform;
|
|
349
|
+
let actualBoundingBox = clippedBoundingBox;
|
|
350
|
+
let raster;
|
|
351
|
+
let validityMasks;
|
|
352
|
+
const readOptions = {
|
|
353
|
+
width: targetSize.width,
|
|
354
|
+
height: targetSize.height,
|
|
355
|
+
samples: parameters.bands,
|
|
356
|
+
interleave: interleaved,
|
|
357
|
+
resampleMethod: parameters.resampleMethod ?? this.options.geotiff?.resampleMethod,
|
|
358
|
+
fillValue,
|
|
359
|
+
signal: parameters.signal
|
|
360
|
+
};
|
|
361
|
+
if (images.length) {
|
|
362
|
+
for (let index = 1; index < images.length; index++) {
|
|
363
|
+
const image2 = images[index];
|
|
364
|
+
const directory = image2.fileDirectory;
|
|
365
|
+
if (directory.NewSubfileType & 4)
|
|
366
|
+
continue;
|
|
367
|
+
if (!(directory.NewSubfileType & 1) && directory.SubfileType !== 2)
|
|
368
|
+
continue;
|
|
369
|
+
if (images.some((candidate) => candidate.fileDirectory?.NewSubfileType & 4) && !images.some((candidate) => candidate.fileDirectory?.NewSubfileType & 4 && candidate.getWidth() === image2.getWidth() && candidate.getHeight() === image2.getHeight()))
|
|
370
|
+
continue;
|
|
371
|
+
const registration = image2.getGeoKeys?.()?.GTRasterTypeGeoKey;
|
|
372
|
+
if ((registration === 2 ? "point" : "area") !== (metadata.pixelRegistration ?? "area") && registration !== void 0)
|
|
373
|
+
continue;
|
|
374
|
+
if (typeof image2.getSamplesPerPixel === "function" && selectedBands.some((band) => band >= image2.getSamplesPerPixel()))
|
|
375
|
+
continue;
|
|
376
|
+
if (typeof image2.getBitsPerSample === "function" && typeof image2.getSampleFormat === "function") {
|
|
377
|
+
try {
|
|
378
|
+
if (selectedBands.some((band) => getImageDataType(image2, band) !== (metadata.bands?.[band]?.dtype ?? metadata.dtype)))
|
|
379
|
+
continue;
|
|
380
|
+
} catch {
|
|
381
|
+
continue;
|
|
382
|
+
}
|
|
383
|
+
}
|
|
384
|
+
const resolution = getImageResolution(image2, images[0]);
|
|
385
|
+
if (resolution && Math.abs(resolution[0]) <= requestedResolution[0] && Math.abs(resolution[1]) <= requestedResolution[1] && image2.getWidth() < images[overview].getWidth())
|
|
386
|
+
overview = index;
|
|
387
|
+
}
|
|
388
|
+
const image = images[overview];
|
|
389
|
+
const affine = getImageTransform(image, images[0]);
|
|
390
|
+
if (!affine)
|
|
391
|
+
throw new Error("GeoTIFF source has no usable affine transform");
|
|
392
|
+
const [columnScale, rowShear, originX, columnShear, rowScale, originY] = affine;
|
|
393
|
+
const determinant = columnScale * rowScale - rowShear * columnShear;
|
|
394
|
+
if (!affine.every(Number.isFinite) || !Number.isFinite(determinant) || determinant === 0)
|
|
395
|
+
throw new Error("Singular GeoTIFF affine transform");
|
|
396
|
+
const corners = [
|
|
397
|
+
clippedBoundingBox[0],
|
|
398
|
+
clippedBoundingBox[1],
|
|
399
|
+
[clippedBoundingBox[0][0], clippedBoundingBox[1][1]],
|
|
400
|
+
[clippedBoundingBox[1][0], clippedBoundingBox[0][1]]
|
|
401
|
+
];
|
|
402
|
+
const grid = corners.map(([coordinateX, coordinateY]) => [
|
|
403
|
+
(rowScale * (coordinateX - originX) - rowShear * (coordinateY - originY)) / determinant,
|
|
404
|
+
(columnScale * (coordinateY - originY) - columnShear * (coordinateX - originX)) / determinant
|
|
405
|
+
]);
|
|
406
|
+
const window = [
|
|
407
|
+
Math.max(0, Math.floor(Math.min(...grid.map((point) => point[0])))),
|
|
408
|
+
Math.max(0, Math.floor(Math.min(...grid.map((point) => point[1])))),
|
|
409
|
+
Math.min(image.getWidth(), Math.ceil(Math.max(...grid.map((point) => point[0])))),
|
|
410
|
+
Math.min(image.getHeight(), Math.ceil(Math.max(...grid.map((point) => point[1]))))
|
|
411
|
+
];
|
|
412
|
+
const maskImages = images.filter((candidate) => candidate.fileDirectory?.NewSubfileType & 4 && candidate.getWidth() === image.getWidth() && candidate.getHeight() === image.getHeight());
|
|
413
|
+
if (maskImages.length > 1)
|
|
414
|
+
throw new Error("Ambiguous GeoTIFF validity mask");
|
|
415
|
+
const nativePixelCount = (window[2] - window[0]) * (window[3] - window[1]);
|
|
416
|
+
const nativeBytes = nativePixelCount * bytesPerPixel;
|
|
417
|
+
const maskBytes = maskImages.length ? nativePixelCount * 3 + estimateImageTileBytes(maskImages[0], window, 2) : 0;
|
|
418
|
+
const sourceBytesPerPixel = image.fileDirectory?.PlanarConfiguration === 2 ? bytesPerPixel : metadata.bands ? metadata.bands.reduce((bytes, band) => bytes + Number(band.dtype.match(/\d+/)?.[0] ?? 64) / 8, 0) : metadata.bandCount * Number(metadata.dtype.match(/\d+/)?.[0] ?? 64) / 8;
|
|
419
|
+
const tileBytes = estimateImageTileBytes(image, window, sourceBytesPerPixel);
|
|
420
|
+
if (nativeBytes * 2 + maskBytes + pixels * (bytesPerPixel + bandCount) + tileBytes > maxDecodedBytes)
|
|
421
|
+
throw new Error("Native decode window exceeds decoded-byte budget");
|
|
422
|
+
if (window[2] <= window[0] || window[3] <= window[1])
|
|
423
|
+
throw new Error("Region does not intersect the source grid");
|
|
424
|
+
const scaleX = (window[2] - window[0]) / targetSize.width;
|
|
425
|
+
const scaleY = (window[3] - window[1]) / targetSize.height;
|
|
426
|
+
const pointShift = metadata.pixelRegistration === "point" ? 0.5 : 0;
|
|
427
|
+
transform = [
|
|
428
|
+
columnScale * scaleX,
|
|
429
|
+
rowShear * scaleY,
|
|
430
|
+
columnScale * (window[0] - pointShift) + rowShear * (window[1] - pointShift) + originX,
|
|
431
|
+
columnShear * scaleX,
|
|
432
|
+
rowScale * scaleY,
|
|
433
|
+
columnShear * (window[0] - pointShift) + rowScale * (window[1] - pointShift) + originY
|
|
434
|
+
];
|
|
435
|
+
const sourceCorners = [
|
|
436
|
+
[window[0], window[1]],
|
|
437
|
+
[window[2], window[1]],
|
|
438
|
+
[window[0], window[3]],
|
|
439
|
+
[window[2], window[3]]
|
|
440
|
+
].map(([column, row]) => [
|
|
441
|
+
columnScale * (column - pointShift) + rowShear * (row - pointShift) + originX,
|
|
442
|
+
columnShear * (column - pointShift) + rowScale * (row - pointShift) + originY
|
|
443
|
+
]);
|
|
444
|
+
actualBoundingBox = [
|
|
445
|
+
[
|
|
446
|
+
Math.min(...sourceCorners.map((point) => point[0])),
|
|
447
|
+
Math.min(...sourceCorners.map((point) => point[1]))
|
|
448
|
+
],
|
|
449
|
+
[
|
|
450
|
+
Math.max(...sourceCorners.map((point) => point[0])),
|
|
451
|
+
Math.max(...sourceCorners.map((point) => point[1]))
|
|
452
|
+
]
|
|
453
|
+
];
|
|
454
|
+
const nativeRaster = await image.readRasters({
|
|
455
|
+
...readOptions,
|
|
456
|
+
// geotiff.js interleaving chooses a type from every source band, including unselected bands.
|
|
457
|
+
interleave: false,
|
|
458
|
+
width: window[2] - window[0],
|
|
459
|
+
height: window[3] - window[1],
|
|
460
|
+
window,
|
|
461
|
+
resampleMethod: "nearest"
|
|
462
|
+
});
|
|
463
|
+
if (nativeRaster.width !== window[2] - window[0] || nativeRaster.height !== window[3] - window[1])
|
|
464
|
+
throw new Error("Invalid native raster dimensions");
|
|
465
|
+
const nativeArrays = Array.isArray(nativeRaster) ? nativeRaster : [nativeRaster];
|
|
466
|
+
if (nativeArrays.reduce((length, array) => length + array.length, 0) !== nativeRaster.width * nativeRaster.height * bandCount || nativeArrays.reduce((length, array) => length + array.byteLength, 0) > maxDecodedBytes)
|
|
467
|
+
throw new Error("Invalid or oversized native raster");
|
|
468
|
+
if (nativeArrays.length !== bandCount || nativeArrays.some((array, index) => array.constructor !== createFilledTypedArray(metadata.bands?.[selectedBands[index]]?.dtype ?? metadata.dtype, 0, 0).constructor))
|
|
469
|
+
throw new Error("Native raster representation does not match selected band metadata");
|
|
470
|
+
let nativeValidityMasks;
|
|
471
|
+
if (maskImages.length) {
|
|
472
|
+
parameters.signal?.throwIfAborted();
|
|
473
|
+
const maskRaster = await maskImages[0].readRasters({
|
|
474
|
+
window,
|
|
475
|
+
samples: [0],
|
|
476
|
+
interleave: true,
|
|
477
|
+
signal: parameters.signal
|
|
478
|
+
});
|
|
479
|
+
if (maskRaster.length !== nativePixelCount || maskRaster.byteLength > nativePixelCount * 2)
|
|
480
|
+
throw new Error("Invalid GeoTIFF validity mask");
|
|
481
|
+
nativeValidityMasks = [
|
|
482
|
+
{
|
|
483
|
+
data: Uint8Array.from(maskRaster, (value) => Number.isFinite(value) && value !== 0 ? 1 : 0),
|
|
484
|
+
width: nativeRaster.width,
|
|
485
|
+
height: nativeRaster.height,
|
|
486
|
+
pixelStride: 1,
|
|
487
|
+
rowStride: nativeRaster.width
|
|
488
|
+
}
|
|
489
|
+
];
|
|
490
|
+
}
|
|
491
|
+
const resized = await resizeRasterWindow(nativeRaster, selectedBands.map((index) => metadata.bands?.[index] ? { ...metadata.bands[index] } : { index, dtype: outputDtype, noData: metadata.noData }), interleaved, targetSize, readOptions.resampleMethod ?? "nearest", parameters.signal, nativeValidityMasks);
|
|
492
|
+
raster = resized.raster;
|
|
493
|
+
validityMasks = resized.validityMasks;
|
|
494
|
+
} else {
|
|
495
|
+
raster = await tiff.readRasters({
|
|
496
|
+
...readOptions,
|
|
497
|
+
bbox: flattenBoundingBox(clippedBoundingBox)
|
|
498
|
+
});
|
|
499
|
+
}
|
|
500
|
+
const data = normalizeRasterReadResult(raster, interleaved);
|
|
501
|
+
parameters.signal?.throwIfAborted();
|
|
502
|
+
const arrays = Array.isArray(data) ? data : [data];
|
|
503
|
+
const expectedLength = raster.width * raster.height * bandCount;
|
|
504
|
+
if (!Number.isSafeInteger(raster.width) || !Number.isSafeInteger(raster.height) || raster.width <= 0 || raster.height <= 0 || raster.width * raster.height > (parameters.maxPixels ?? this.options.geotiff?.maxPixels ?? 16e6))
|
|
505
|
+
throw new Error("Invalid decoded raster dimensions");
|
|
506
|
+
if (arrays.reduce((length, array) => length + array.length, 0) !== expectedLength || arrays.reduce((length, array) => length + array.byteLength, 0) > (parameters.maxDecodedBytes ?? this.options.geotiff?.maxDecodedBytes ?? 256 * 1024 * 1024))
|
|
507
|
+
throw new Error("Invalid or oversized decoded raster");
|
|
508
|
+
const result = {
|
|
509
|
+
data,
|
|
510
|
+
width: raster.width,
|
|
511
|
+
height: raster.height,
|
|
512
|
+
bandCount,
|
|
513
|
+
dtype: outputDtype,
|
|
514
|
+
interleaved,
|
|
515
|
+
noData: metadata.noData,
|
|
516
|
+
boundingBox: actualBoundingBox,
|
|
517
|
+
crs: metadata.crs,
|
|
518
|
+
metadata: metadata.metadata,
|
|
519
|
+
bands: (parameters.bands ?? Array.from({ length: bandCount }, (_, index) => index)).map((index) => metadata.bands?.[index] ? { ...metadata.bands[index] } : { index, dtype: metadata.dtype, noData: metadata.noData }),
|
|
520
|
+
transform,
|
|
521
|
+
pixelRegistration: "area",
|
|
522
|
+
validityMasks,
|
|
523
|
+
overview,
|
|
524
|
+
resolution: transform ? [Math.hypot(transform[0], transform[3]), Math.hypot(transform[1], transform[4])] : requestedResolution,
|
|
525
|
+
nativeResolution: metadata.overviews?.find((level) => level.index === overview)?.resolution?.map(Math.abs),
|
|
526
|
+
overzoom: metadata.overviews?.find((level) => level.index === overview)?.resolution?.some((resolution, axis) => Math.abs(resolution) > requestedResolution[axis]),
|
|
527
|
+
provenance: { sourceType: "geotiff" },
|
|
528
|
+
ownership: "owned"
|
|
529
|
+
};
|
|
530
|
+
if (mixed)
|
|
531
|
+
return {
|
|
532
|
+
...result,
|
|
533
|
+
data: arrays,
|
|
534
|
+
dtype: "mixed",
|
|
535
|
+
interleaved: false,
|
|
536
|
+
bands: result.bands
|
|
537
|
+
};
|
|
538
|
+
return result;
|
|
539
|
+
}
|
|
540
|
+
/** Opens the GeoTIFF once and resolves its overview images and normalized metadata. */
|
|
541
|
+
async _initialize(signal) {
|
|
542
|
+
signal?.throwIfAborted();
|
|
543
|
+
const tiff = await this._openGeoTIFF(signal);
|
|
544
|
+
signal?.throwIfAborted();
|
|
545
|
+
const imageCount = await tiff.getImageCount();
|
|
546
|
+
signal?.throwIfAborted();
|
|
547
|
+
const images = await Promise.all(Array.from({ length: imageCount }, (_, index) => tiff.getImage(index)));
|
|
548
|
+
signal?.throwIfAborted();
|
|
549
|
+
if (!images.length) {
|
|
550
|
+
throw new Error("GeoTIFFRasterSource could not load any images.");
|
|
551
|
+
}
|
|
552
|
+
const referenceImage = images[0];
|
|
553
|
+
const metadata = this._getMetadata(referenceImage, images);
|
|
554
|
+
return { tiff, images, metadata };
|
|
555
|
+
}
|
|
556
|
+
/** Returns the shared initialization promise for this source instance. */
|
|
557
|
+
_getInitPromise(signal) {
|
|
558
|
+
signal?.throwIfAborted();
|
|
559
|
+
if (!this._initPromise) {
|
|
560
|
+
const initialization2 = { controller: new AbortController(), subscribers: 0, settled: false };
|
|
561
|
+
this._initialization = initialization2;
|
|
562
|
+
const promise2 = this._initialize(initialization2.controller.signal);
|
|
563
|
+
this._initPromise = promise2;
|
|
564
|
+
void promise2.then(() => {
|
|
565
|
+
initialization2.settled = true;
|
|
566
|
+
}, () => {
|
|
567
|
+
initialization2.settled = true;
|
|
568
|
+
if (this._initPromise === promise2)
|
|
569
|
+
this._initPromise = null;
|
|
570
|
+
});
|
|
571
|
+
}
|
|
572
|
+
const promise = this._initPromise;
|
|
573
|
+
const initialization = this._initialization;
|
|
574
|
+
if (initialization)
|
|
575
|
+
initialization.subscribers++;
|
|
576
|
+
const release = () => {
|
|
577
|
+
if (!initialization)
|
|
578
|
+
return;
|
|
579
|
+
initialization.subscribers--;
|
|
580
|
+
if (!initialization.settled && initialization.subscribers === 0) {
|
|
581
|
+
initialization.controller.abort(signal?.reason);
|
|
582
|
+
if (this._initPromise === promise)
|
|
583
|
+
this._initPromise = null;
|
|
584
|
+
}
|
|
585
|
+
};
|
|
586
|
+
if (!signal) {
|
|
587
|
+
void promise.then(release, release);
|
|
588
|
+
return promise;
|
|
589
|
+
}
|
|
590
|
+
return new Promise((resolve, reject) => {
|
|
591
|
+
let released = false;
|
|
592
|
+
const cleanup = () => {
|
|
593
|
+
if (released)
|
|
594
|
+
return;
|
|
595
|
+
released = true;
|
|
596
|
+
signal.removeEventListener("abort", abort);
|
|
597
|
+
release();
|
|
598
|
+
};
|
|
599
|
+
const abort = () => {
|
|
600
|
+
cleanup();
|
|
601
|
+
reject(signal.reason);
|
|
602
|
+
};
|
|
603
|
+
signal.addEventListener("abort", abort, { once: true });
|
|
604
|
+
if (signal.aborted)
|
|
605
|
+
abort();
|
|
606
|
+
void promise.then((value) => {
|
|
607
|
+
cleanup();
|
|
608
|
+
resolve(value);
|
|
609
|
+
}, (error) => {
|
|
610
|
+
cleanup();
|
|
611
|
+
reject(error);
|
|
612
|
+
});
|
|
613
|
+
});
|
|
614
|
+
}
|
|
615
|
+
/** Opens the underlying GeoTIFF using Blob reads or range-scheduled HTTP access. */
|
|
616
|
+
async _openGeoTIFF(signal) {
|
|
617
|
+
const initialization = this._initialization;
|
|
618
|
+
if (typeof this.data === "string") {
|
|
619
|
+
const maxEntries = this.options.geotiff?.rangeCacheProps?.maxEntries ?? 128;
|
|
620
|
+
const maxBytes = this.options.geotiff?.rangeCacheProps?.maxBytes ?? 8 * 1024 * 1024;
|
|
621
|
+
if (![maxEntries, maxBytes].every((value) => Number.isSafeInteger(value) && value >= 0))
|
|
622
|
+
throw new Error("Invalid GeoTIFF cache limits");
|
|
623
|
+
this._rangeCache?.clear();
|
|
624
|
+
this._rangeCache = new import_loader_utils.RangeRequestCache({ maxEntries, maxBytes });
|
|
625
|
+
const headers = Object.fromEntries(new Headers(this.options.geotiff?.headers));
|
|
626
|
+
const rangeScheduler = this._getRangeScheduler();
|
|
627
|
+
const rangeCache = this._rangeCache;
|
|
628
|
+
const client = new GeoTIFFRangeSchedulerClient({
|
|
629
|
+
url: this.url,
|
|
630
|
+
fetch: this.fetch,
|
|
631
|
+
requireContentRange: this.options.geotiff?.requireContentRange,
|
|
632
|
+
sourceId: "geotiff",
|
|
633
|
+
headers,
|
|
634
|
+
rangeCache,
|
|
635
|
+
maxPendingRequests: rangeScheduler.props.maxQueueSize,
|
|
636
|
+
rangeScheduler,
|
|
637
|
+
getInitializationSignal: () => initialization?.settled ? void 0 : signal,
|
|
638
|
+
onRevisionChange: (error) => {
|
|
639
|
+
this._finalizationController.abort(error);
|
|
640
|
+
rangeCache.clear();
|
|
641
|
+
}
|
|
642
|
+
});
|
|
643
|
+
return await openGeoTIFFSourceDecoder({
|
|
644
|
+
/** Reads independently owned buffers in source request order. */
|
|
645
|
+
fetch: (slices, requestSignal) => client.readRanges(slices, requestSignal),
|
|
646
|
+
/** Reflects the validated remote object length discovered by transport. */
|
|
647
|
+
get fileSize() {
|
|
648
|
+
return client.getFileSize();
|
|
649
|
+
},
|
|
650
|
+
/** Releases only this source's owned byte cache. */
|
|
651
|
+
close: () => rangeCache.clear()
|
|
652
|
+
}, signal);
|
|
653
|
+
}
|
|
654
|
+
return await openGeoTIFFSourceDecoder(this.data, signal);
|
|
655
|
+
}
|
|
656
|
+
/** Returns the configured shared scheduler or lazily creates a per-source scheduler. */
|
|
657
|
+
_getRangeScheduler() {
|
|
658
|
+
if (this.options.geotiff?.rangeScheduler) {
|
|
659
|
+
return this.options.geotiff.rangeScheduler;
|
|
660
|
+
}
|
|
661
|
+
if (!this._rangeScheduler) {
|
|
662
|
+
this._rangeScheduler = new import_loader_utils.RangeRequestScheduler({
|
|
663
|
+
batchDelayMs: 0,
|
|
664
|
+
...this.options.geotiff?.rangeSchedulerProps
|
|
665
|
+
});
|
|
666
|
+
}
|
|
667
|
+
return this._rangeScheduler;
|
|
668
|
+
}
|
|
669
|
+
/** Normalizes one GeoTIFF image hierarchy into public raster-source metadata. */
|
|
670
|
+
_getMetadata(referenceImage, images) {
|
|
671
|
+
if (![
|
|
672
|
+
referenceImage.getWidth(),
|
|
673
|
+
referenceImage.getHeight(),
|
|
674
|
+
referenceImage.getSamplesPerPixel()
|
|
675
|
+
].every((value) => Number.isSafeInteger(value) && value > 0))
|
|
676
|
+
throw new Error("Invalid GeoTIFF image dimensions or band count");
|
|
677
|
+
const boundingBox = getImageBoundingBox(referenceImage);
|
|
678
|
+
const geoKeys = referenceImage.getGeoKeys?.() || void 0;
|
|
679
|
+
const gdalMetadata = referenceImage.getGDALMetadata?.() || void 0;
|
|
680
|
+
const noData = referenceImage.getGDALNoData?.() ?? null;
|
|
681
|
+
return {
|
|
682
|
+
name: getGeoTIFFName(this.data),
|
|
683
|
+
keywords: [],
|
|
684
|
+
attributions: this.options.core?.attributions || [],
|
|
685
|
+
crs: getImageCRS(referenceImage),
|
|
686
|
+
boundingBox,
|
|
687
|
+
tileGrid: getImageTileGrid(images, referenceImage),
|
|
688
|
+
width: referenceImage.getWidth(),
|
|
689
|
+
height: referenceImage.getHeight(),
|
|
690
|
+
bandCount: referenceImage.getSamplesPerPixel(),
|
|
691
|
+
dtype: getImageDataType(referenceImage),
|
|
692
|
+
bands: Array.from({ length: referenceImage.getSamplesPerPixel() }, (_, index) => getImageBandMetadata(referenceImage, index, noData)),
|
|
693
|
+
transform: getImageTransform(referenceImage, referenceImage),
|
|
694
|
+
pixelRegistration: geoKeys?.GTRasterTypeGeoKey === 2 ? "point" : geoKeys?.GTRasterTypeGeoKey === 1 ? "area" : void 0,
|
|
695
|
+
supportsRegion: true,
|
|
696
|
+
tileSize: {
|
|
697
|
+
width: referenceImage.getTileWidth(),
|
|
698
|
+
height: referenceImage.getTileHeight()
|
|
699
|
+
},
|
|
700
|
+
overviews: images.map((image, index) => ({
|
|
701
|
+
index,
|
|
702
|
+
width: image.getWidth(),
|
|
703
|
+
height: image.getHeight(),
|
|
704
|
+
resolution: getImageResolution(image, referenceImage)
|
|
705
|
+
})).filter((overview) => !(images[overview.index].fileDirectory?.NewSubfileType & 4)),
|
|
706
|
+
noData,
|
|
707
|
+
metadata: {
|
|
708
|
+
geoKeys,
|
|
709
|
+
gdalMetadata,
|
|
710
|
+
bandMetadata: Array.from({ length: referenceImage.getSamplesPerPixel() }, (_, index) => referenceImage.getGDALMetadata?.(index) || void 0)
|
|
711
|
+
}
|
|
712
|
+
};
|
|
713
|
+
}
|
|
714
|
+
};
|
|
715
|
+
function flattenBoundingBox(boundingBox) {
|
|
716
|
+
return [...boundingBox[0], ...boundingBox[1]];
|
|
717
|
+
}
|
|
718
|
+
function intersectBoundingBoxes(leftBoundingBox, rightBoundingBox) {
|
|
719
|
+
const minX = Math.max(leftBoundingBox[0][0], rightBoundingBox[0][0]);
|
|
720
|
+
const minY = Math.max(leftBoundingBox[0][1], rightBoundingBox[0][1]);
|
|
721
|
+
const maxX = Math.min(leftBoundingBox[1][0], rightBoundingBox[1][0]);
|
|
722
|
+
const maxY = Math.min(leftBoundingBox[1][1], rightBoundingBox[1][1]);
|
|
723
|
+
if (maxX <= minX || maxY <= minY) {
|
|
724
|
+
return null;
|
|
725
|
+
}
|
|
726
|
+
return [
|
|
727
|
+
[minX, minY],
|
|
728
|
+
[maxX, maxY]
|
|
729
|
+
];
|
|
730
|
+
}
|
|
731
|
+
function getClippedTargetSize(viewportBoundingBox, clippedBoundingBox, parameters) {
|
|
732
|
+
const viewportWidth = Math.abs(viewportBoundingBox[1][0] - viewportBoundingBox[0][0]);
|
|
733
|
+
const viewportHeight = Math.abs(viewportBoundingBox[1][1] - viewportBoundingBox[0][1]);
|
|
734
|
+
const clippedWidth = Math.abs(clippedBoundingBox[1][0] - clippedBoundingBox[0][0]);
|
|
735
|
+
const clippedHeight = Math.abs(clippedBoundingBox[1][1] - clippedBoundingBox[0][1]);
|
|
736
|
+
return {
|
|
737
|
+
width: Math.max(1, Math.min(parameters.width, Math.round(clippedWidth / Math.max(viewportWidth, Number.EPSILON) * parameters.width))),
|
|
738
|
+
height: Math.max(1, Math.min(parameters.height, Math.round(clippedHeight / Math.max(viewportHeight, Number.EPSILON) * parameters.height)))
|
|
739
|
+
};
|
|
740
|
+
}
|
|
741
|
+
function createEmptyRaster(parameters, metadata) {
|
|
742
|
+
const length = parameters.width * parameters.height;
|
|
743
|
+
const bandCount = parameters.bands?.length ?? metadata.bandCount;
|
|
744
|
+
const interleaved = parameters.interleaved ?? false;
|
|
745
|
+
const noData = metadata.noData ?? 0;
|
|
746
|
+
const data = interleaved ? createFilledTypedArray(metadata.dtype, length * bandCount, noData) : bandCount === 1 ? createFilledTypedArray(metadata.dtype, length, noData) : Array.from({ length: bandCount }, () => createFilledTypedArray(metadata.dtype, length, noData));
|
|
747
|
+
return {
|
|
748
|
+
data,
|
|
749
|
+
width: parameters.width,
|
|
750
|
+
height: parameters.height,
|
|
751
|
+
bandCount,
|
|
752
|
+
dtype: metadata.dtype,
|
|
753
|
+
interleaved,
|
|
754
|
+
noData: metadata.noData,
|
|
755
|
+
boundingBox: parameters.bounds,
|
|
756
|
+
crs: metadata.crs,
|
|
757
|
+
metadata: metadata.metadata,
|
|
758
|
+
bands: (parameters.bands ?? Array.from({ length: bandCount }, (_, index) => index)).map((index) => metadata.bands?.[index] ? { ...metadata.bands[index] } : { index, dtype: metadata.dtype, noData: metadata.noData }),
|
|
759
|
+
transform: createRegionTransform(parameters.bounds, parameters.width, parameters.height),
|
|
760
|
+
pixelRegistration: "area",
|
|
761
|
+
provenance: { sourceType: "geotiff" },
|
|
762
|
+
ownership: "owned"
|
|
763
|
+
};
|
|
764
|
+
}
|
|
765
|
+
function createFilledTypedArray(dtype, length, fillValue) {
|
|
766
|
+
switch (dtype) {
|
|
767
|
+
case "uint8":
|
|
768
|
+
return new Uint8Array(length).fill(fillValue);
|
|
769
|
+
case "uint16":
|
|
770
|
+
return new Uint16Array(length).fill(fillValue);
|
|
771
|
+
case "uint32":
|
|
772
|
+
return new Uint32Array(length).fill(fillValue);
|
|
773
|
+
case "int8":
|
|
774
|
+
return new Int8Array(length).fill(fillValue);
|
|
775
|
+
case "int16":
|
|
776
|
+
return new Int16Array(length).fill(fillValue);
|
|
777
|
+
case "int32":
|
|
778
|
+
return new Int32Array(length).fill(fillValue);
|
|
779
|
+
case "float32":
|
|
780
|
+
return new Float32Array(length).fill(fillValue);
|
|
781
|
+
case "float64":
|
|
782
|
+
return new Float64Array(length).fill(fillValue);
|
|
783
|
+
default:
|
|
784
|
+
return new Uint8Array(length).fill(fillValue);
|
|
785
|
+
}
|
|
786
|
+
}
|
|
787
|
+
function normalizeRasterReadResult(raster, interleaved) {
|
|
788
|
+
if (interleaved) {
|
|
789
|
+
return raster;
|
|
790
|
+
}
|
|
791
|
+
if (Array.isArray(raster)) {
|
|
792
|
+
return raster.length === 1 ? raster[0] : raster;
|
|
793
|
+
}
|
|
794
|
+
return [raster];
|
|
795
|
+
}
|
|
796
|
+
function getGeoTIFFName(data) {
|
|
797
|
+
if (typeof data !== "string") {
|
|
798
|
+
return void 0;
|
|
799
|
+
}
|
|
800
|
+
const [path] = data.split(/[?#]/);
|
|
801
|
+
return path.split("/").pop() || void 0;
|
|
802
|
+
}
|
|
803
|
+
function getImageBoundingBox(image) {
|
|
804
|
+
try {
|
|
805
|
+
const [minX, minY, maxX, maxY] = image.getBoundingBox();
|
|
806
|
+
return [
|
|
807
|
+
[minX, minY],
|
|
808
|
+
[maxX, maxY]
|
|
809
|
+
];
|
|
810
|
+
} catch {
|
|
811
|
+
return void 0;
|
|
812
|
+
}
|
|
813
|
+
}
|
|
814
|
+
function getImageResolution(image, referenceImage) {
|
|
815
|
+
const transform = getImageTransform(image, referenceImage);
|
|
816
|
+
if (transform) {
|
|
817
|
+
return [
|
|
818
|
+
transform[3] === 0 ? transform[0] : Math.hypot(transform[0], transform[3]),
|
|
819
|
+
transform[1] === 0 ? transform[4] : Math.hypot(transform[1], transform[4])
|
|
820
|
+
];
|
|
821
|
+
}
|
|
822
|
+
try {
|
|
823
|
+
const resolution = image.getResolution(referenceImage);
|
|
824
|
+
return [resolution[0], resolution[1]];
|
|
825
|
+
} catch {
|
|
826
|
+
return void 0;
|
|
827
|
+
}
|
|
828
|
+
}
|
|
829
|
+
function getImageCRS(image) {
|
|
830
|
+
const geoKeys = image.getGeoKeys?.();
|
|
831
|
+
const projectedCrs = geoKeys?.ProjectedCSTypeGeoKey;
|
|
832
|
+
if (projectedCrs || geoKeys?.GTModelTypeGeoKey === 1) {
|
|
833
|
+
return projectedCrs && projectedCrs !== 32767 ? `EPSG:${projectedCrs}` : void 0;
|
|
834
|
+
}
|
|
835
|
+
const geographicCrs = geoKeys?.GeographicTypeGeoKey;
|
|
836
|
+
if (geographicCrs && geographicCrs !== 32767) {
|
|
837
|
+
return `EPSG:${geographicCrs}`;
|
|
838
|
+
}
|
|
839
|
+
return void 0;
|
|
840
|
+
}
|
|
841
|
+
function getImageDataType(image, index = 0) {
|
|
842
|
+
const bitsPerSample = normalizeSampleValue(image.getBitsPerSample(index));
|
|
843
|
+
const sampleFormat = normalizeSampleValue(image.getSampleFormat(index));
|
|
844
|
+
switch (sampleFormat) {
|
|
845
|
+
case 1:
|
|
846
|
+
switch (bitsPerSample) {
|
|
847
|
+
case 8:
|
|
848
|
+
return "uint8";
|
|
849
|
+
case 16:
|
|
850
|
+
return "uint16";
|
|
851
|
+
case 32:
|
|
852
|
+
return "uint32";
|
|
853
|
+
default:
|
|
854
|
+
break;
|
|
855
|
+
}
|
|
856
|
+
break;
|
|
857
|
+
case 2:
|
|
858
|
+
switch (bitsPerSample) {
|
|
859
|
+
case 8:
|
|
860
|
+
return "int8";
|
|
861
|
+
case 16:
|
|
862
|
+
return "int16";
|
|
863
|
+
case 32:
|
|
864
|
+
return "int32";
|
|
865
|
+
default:
|
|
866
|
+
break;
|
|
867
|
+
}
|
|
868
|
+
break;
|
|
869
|
+
case 3:
|
|
870
|
+
switch (bitsPerSample) {
|
|
871
|
+
case 32:
|
|
872
|
+
return "float32";
|
|
873
|
+
case 64:
|
|
874
|
+
return "float64";
|
|
875
|
+
default:
|
|
876
|
+
break;
|
|
877
|
+
}
|
|
878
|
+
break;
|
|
879
|
+
default:
|
|
880
|
+
break;
|
|
881
|
+
}
|
|
882
|
+
throw new Error(`GeoTIFFRasterSource does not support sample format ${sampleFormat} with ${bitsPerSample} bits.`);
|
|
883
|
+
}
|
|
884
|
+
function normalizeSampleValue(value) {
|
|
885
|
+
return Array.isArray(value) ? value[0] : value;
|
|
886
|
+
}
|
|
887
|
+
var GeoTIFFRangeSchedulerClient = class {
|
|
888
|
+
url;
|
|
889
|
+
fetch;
|
|
890
|
+
/** Strict browser profiles require the server to expose range placement metadata. */
|
|
891
|
+
requireContentRange;
|
|
892
|
+
sourceId;
|
|
893
|
+
defaultHeaders;
|
|
894
|
+
rangeScheduler;
|
|
895
|
+
schedulerIsolationKey = {};
|
|
896
|
+
/** Source-owned cache; never shared across authorization or source instances. */
|
|
897
|
+
rangeCache;
|
|
898
|
+
/** Admission limit includes every logical cache subscriber. */
|
|
899
|
+
maxPendingRequests;
|
|
900
|
+
/** Number of logical requests awaiting transfer or a cache entry. */
|
|
901
|
+
pendingRequests = 0;
|
|
902
|
+
fileSize = null;
|
|
903
|
+
/** Remote object revision headers remain private to cache identity. */
|
|
904
|
+
entityTag = null;
|
|
905
|
+
/** Optional fallback revision hint, compared only when both responses declare it. */
|
|
906
|
+
lastModified = null;
|
|
907
|
+
/** Invalidates owned source work without disposing a borrowed scheduler. */
|
|
908
|
+
onRevisionChange;
|
|
909
|
+
/** Discovery cancellation for geotiff.js directory reads without their own signal. */
|
|
910
|
+
getInitializationSignal;
|
|
911
|
+
/** Creates a new range-scheduled GeoTIFF client. */
|
|
912
|
+
constructor(props) {
|
|
913
|
+
this.url = props.url;
|
|
914
|
+
this.fetch = props.fetch;
|
|
915
|
+
this.requireContentRange = props.requireContentRange ?? false;
|
|
916
|
+
this.sourceId = props.sourceId;
|
|
917
|
+
this.defaultHeaders = new Headers(props.headers);
|
|
918
|
+
this.rangeCache = props.rangeCache;
|
|
919
|
+
this.maxPendingRequests = props.maxPendingRequests;
|
|
920
|
+
this.rangeScheduler = props.rangeScheduler;
|
|
921
|
+
this.getInitializationSignal = props.getInitializationSignal;
|
|
922
|
+
this.onRevisionChange = props.onRevisionChange;
|
|
923
|
+
}
|
|
924
|
+
/** Returns the validated remote file size, when available. */
|
|
925
|
+
getFileSize() {
|
|
926
|
+
return this.fileSize;
|
|
927
|
+
}
|
|
928
|
+
/** Returns standalone buffers in the order required by geotiff.js's source protocol. */
|
|
929
|
+
async readRanges(slices, signal) {
|
|
930
|
+
return Promise.all(slices.map((slice) => this.request({
|
|
931
|
+
headers: createRangeRequestHeaders(new Headers(), slice.offset, slice.length),
|
|
932
|
+
signal
|
|
933
|
+
})));
|
|
934
|
+
}
|
|
935
|
+
/** Executes one geotiff.js byte-range request through the shared scheduler. */
|
|
936
|
+
async request({ headers, signal } = {}) {
|
|
937
|
+
signal ??= this.getInitializationSignal?.();
|
|
938
|
+
signal?.throwIfAborted();
|
|
939
|
+
if (this.pendingRequests >= this.maxPendingRequests)
|
|
940
|
+
throw new Error("GeoTIFF request queue limit exceeded");
|
|
941
|
+
this.pendingRequests++;
|
|
942
|
+
try {
|
|
943
|
+
const mergedHeaders = new Headers(this.defaultHeaders);
|
|
944
|
+
new Headers(headers).forEach((value, key) => mergedHeaders.set(key, value));
|
|
945
|
+
const { offset, length } = parseSingleRangeHeader(mergedHeaders.get("Range"));
|
|
946
|
+
const requestHeaders = new Headers(mergedHeaders);
|
|
947
|
+
requestHeaders.delete("Range");
|
|
948
|
+
const readRange = (rangeOffset, rangeLength, rangeSignal) => this.rangeScheduler.scheduleRequest({
|
|
949
|
+
sourceId: this.sourceId,
|
|
950
|
+
isolationKey: this.schedulerIsolationKey,
|
|
951
|
+
offset: rangeOffset,
|
|
952
|
+
length: rangeLength,
|
|
953
|
+
signal: rangeSignal,
|
|
954
|
+
fetchRange: (transportOffset, transportLength, transportSignal) => this._fetchRange(transportOffset, transportLength, requestHeaders, transportSignal)
|
|
955
|
+
});
|
|
956
|
+
let arrayBuffer;
|
|
957
|
+
if (this.fileSize === null) {
|
|
958
|
+
arrayBuffer = await readRange(offset, length, signal);
|
|
959
|
+
this.rangeCache.set(this.sourceId, offset, arrayBuffer);
|
|
960
|
+
} else {
|
|
961
|
+
const boundedLength = offset < this.fileSize ? Math.min(length, this.fileSize - offset) : length;
|
|
962
|
+
arrayBuffer = await this.rangeCache.read({
|
|
963
|
+
sourceId: this.sourceId,
|
|
964
|
+
offset,
|
|
965
|
+
length: boundedLength,
|
|
966
|
+
signal,
|
|
967
|
+
fetchRange: readRange
|
|
968
|
+
});
|
|
969
|
+
}
|
|
970
|
+
signal?.throwIfAborted();
|
|
971
|
+
return arrayBuffer;
|
|
972
|
+
} finally {
|
|
973
|
+
this.pendingRequests--;
|
|
974
|
+
}
|
|
975
|
+
}
|
|
976
|
+
/** Fetches one transport range from the remote GeoTIFF. */
|
|
977
|
+
async _fetchRange(offset, length, headers, signal) {
|
|
978
|
+
let response = await this.fetch(this.url, {
|
|
979
|
+
headers: createRangeRequestHeaders(headers, offset, length),
|
|
980
|
+
signal
|
|
981
|
+
});
|
|
982
|
+
if (response.status === 416 && offset === 0) {
|
|
983
|
+
const actualLength = parseUnsatisfiedContentRange(response.headers.get("Content-Range"));
|
|
984
|
+
if (!actualLength || !Number.isSafeInteger(actualLength) || actualLength > length) {
|
|
985
|
+
throw new Error("Missing content-length on 416 response");
|
|
986
|
+
}
|
|
987
|
+
await response.body?.cancel().catch(() => {
|
|
988
|
+
});
|
|
989
|
+
response = await this.fetch(this.url, {
|
|
990
|
+
headers: createRangeRequestHeaders(headers, 0, actualLength),
|
|
991
|
+
signal
|
|
992
|
+
});
|
|
993
|
+
}
|
|
994
|
+
if (response.status === 200) {
|
|
995
|
+
await response.body?.cancel().catch(() => {
|
|
996
|
+
});
|
|
997
|
+
throw new Error("Byte-range request failed: server returned 200 instead of 206");
|
|
998
|
+
}
|
|
999
|
+
if (response.status !== 206) {
|
|
1000
|
+
await response.body?.cancel().catch(() => {
|
|
1001
|
+
});
|
|
1002
|
+
throw new Error(`Bad response code: ${response.status}`);
|
|
1003
|
+
}
|
|
1004
|
+
let total;
|
|
1005
|
+
try {
|
|
1006
|
+
const contentRange = response.headers.get("Content-Range");
|
|
1007
|
+
if (this.requireContentRange && !contentRange)
|
|
1008
|
+
throw new Error("GeoTIFF range responses require an exposed Content-Range header; configure Access-Control-Expose-Headers: Content-Range.");
|
|
1009
|
+
total = validateGeoTIFFContentRange(contentRange, offset, length);
|
|
1010
|
+
const entityTag = response.headers.get("ETag");
|
|
1011
|
+
const lastModified = response.headers.get("Last-Modified");
|
|
1012
|
+
if (this.fileSize !== null && total !== null && this.fileSize !== total || this.entityTag && entityTag && this.entityTag !== entityTag || this.lastModified && lastModified && this.lastModified !== lastModified) {
|
|
1013
|
+
const error = new Error("Remote GeoTIFF revision changed; recreate the source");
|
|
1014
|
+
this.onRevisionChange?.(error);
|
|
1015
|
+
throw error;
|
|
1016
|
+
}
|
|
1017
|
+
if (total !== null)
|
|
1018
|
+
this.fileSize = total;
|
|
1019
|
+
this.entityTag ??= entityTag;
|
|
1020
|
+
this.lastModified ??= lastModified;
|
|
1021
|
+
} catch (error) {
|
|
1022
|
+
await response.body?.cancel().catch(() => {
|
|
1023
|
+
});
|
|
1024
|
+
throw error;
|
|
1025
|
+
}
|
|
1026
|
+
const arrayBuffer = await readGeoTIFFRangeResponse(response, length, signal);
|
|
1027
|
+
return {
|
|
1028
|
+
arrayBuffer,
|
|
1029
|
+
status: response.status,
|
|
1030
|
+
sourceByteLength: this.fileSize ?? void 0,
|
|
1031
|
+
transportBytes: arrayBuffer.byteLength
|
|
1032
|
+
};
|
|
1033
|
+
}
|
|
1034
|
+
};
|
|
1035
|
+
function createRangeRequestHeaders(headers, offset, length) {
|
|
1036
|
+
const requestHeaders = new Headers(headers);
|
|
1037
|
+
requestHeaders.set("Range", `bytes=${offset}-${offset + length - 1}`);
|
|
1038
|
+
return requestHeaders;
|
|
1039
|
+
}
|
|
1040
|
+
function parseSingleRangeHeader(rangeHeader) {
|
|
1041
|
+
const match = rangeHeader?.match(/^bytes=(\d+)-(\d+)$/);
|
|
1042
|
+
if (!match) {
|
|
1043
|
+
throw new Error(`GeoTIFF range request requires a single byte range. Received: ${rangeHeader}`);
|
|
1044
|
+
}
|
|
1045
|
+
const offset = Number(match[1]);
|
|
1046
|
+
const endOffset = Number(match[2]);
|
|
1047
|
+
if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(endOffset) || endOffset < offset)
|
|
1048
|
+
throw new Error("Invalid GeoTIFF byte range");
|
|
1049
|
+
return { offset, length: endOffset - offset + 1 };
|
|
1050
|
+
}
|
|
1051
|
+
function validateGeoTIFFContentRange(contentRange, offset, length) {
|
|
1052
|
+
if (!contentRange)
|
|
1053
|
+
return null;
|
|
1054
|
+
const match = contentRange.match(/^bytes (\d+)-(\d+)\/(\d+|\*)$/);
|
|
1055
|
+
if (!match)
|
|
1056
|
+
throw new Error("Invalid GeoTIFF Content-Range");
|
|
1057
|
+
const start = Number(match[1]);
|
|
1058
|
+
const end = Number(match[2]);
|
|
1059
|
+
const total = match[3] === "*" ? null : Number(match[3]);
|
|
1060
|
+
if (![start, end].every(Number.isSafeInteger) || start !== offset || end < start || total !== null && (!Number.isSafeInteger(total) || total <= end) || end !== Math.min(offset + length - 1, total === null ? Infinity : total - 1))
|
|
1061
|
+
throw new Error("Contradictory GeoTIFF Content-Range");
|
|
1062
|
+
return total;
|
|
1063
|
+
}
|
|
1064
|
+
async function readGeoTIFFRangeResponse(response, maximumBytes, signal) {
|
|
1065
|
+
if (!response.body)
|
|
1066
|
+
return new ArrayBuffer(0);
|
|
1067
|
+
const reader = response.body.getReader();
|
|
1068
|
+
const bytes = new Uint8Array(maximumBytes);
|
|
1069
|
+
let writtenBytes = 0;
|
|
1070
|
+
try {
|
|
1071
|
+
while (true) {
|
|
1072
|
+
const chunk = await (0, import_loader_utils.waitForPromiseWithSignal)(reader.read(), signal);
|
|
1073
|
+
if (chunk.done)
|
|
1074
|
+
break;
|
|
1075
|
+
if (writtenBytes + chunk.value.byteLength > maximumBytes)
|
|
1076
|
+
throw new Error("GeoTIFF range response exceeds byte budget");
|
|
1077
|
+
bytes.set(chunk.value, writtenBytes);
|
|
1078
|
+
writtenBytes += chunk.value.byteLength;
|
|
1079
|
+
}
|
|
1080
|
+
signal?.throwIfAborted();
|
|
1081
|
+
return writtenBytes === maximumBytes ? bytes.buffer : bytes.buffer.slice(0, writtenBytes);
|
|
1082
|
+
} finally {
|
|
1083
|
+
await reader.cancel().catch(() => {
|
|
1084
|
+
});
|
|
1085
|
+
reader.releaseLock();
|
|
1086
|
+
}
|
|
1087
|
+
}
|
|
1088
|
+
function parseUnsatisfiedContentRange(contentRange) {
|
|
1089
|
+
const match = contentRange?.match(/^bytes \*\/(\d+)$/);
|
|
1090
|
+
return match ? Number(match[1]) : null;
|
|
1091
|
+
}
|
|
1092
|
+
function getImageTransform(image, referenceImage) {
|
|
1093
|
+
const matrix = image.fileDirectory?.ModelTransformation;
|
|
1094
|
+
if (matrix)
|
|
1095
|
+
return [matrix[0], matrix[1], matrix[3], matrix[4], matrix[5], matrix[7]];
|
|
1096
|
+
if (image !== referenceImage && !image.fileDirectory?.ModelTiepoint && !image.fileDirectory?.ModelPixelScale) {
|
|
1097
|
+
const referenceTransform = getImageTransform(referenceImage, referenceImage);
|
|
1098
|
+
if (referenceTransform) {
|
|
1099
|
+
const scaleX = referenceImage.getWidth() / image.getWidth();
|
|
1100
|
+
const scaleY = referenceImage.getHeight() / image.getHeight();
|
|
1101
|
+
return [
|
|
1102
|
+
referenceTransform[0] * scaleX,
|
|
1103
|
+
referenceTransform[1] * scaleY,
|
|
1104
|
+
referenceTransform[2],
|
|
1105
|
+
referenceTransform[3] * scaleX,
|
|
1106
|
+
referenceTransform[4] * scaleY,
|
|
1107
|
+
referenceTransform[5]
|
|
1108
|
+
];
|
|
1109
|
+
}
|
|
1110
|
+
}
|
|
1111
|
+
try {
|
|
1112
|
+
const resolution = image.getResolution(referenceImage);
|
|
1113
|
+
let origin;
|
|
1114
|
+
try {
|
|
1115
|
+
origin = image.getOrigin();
|
|
1116
|
+
} catch {
|
|
1117
|
+
origin = referenceImage.getOrigin();
|
|
1118
|
+
}
|
|
1119
|
+
const tiepoint = image.fileDirectory?.ModelTiepoint;
|
|
1120
|
+
return [
|
|
1121
|
+
resolution[0],
|
|
1122
|
+
0,
|
|
1123
|
+
origin[0] - (tiepoint?.[0] ?? 0) * resolution[0],
|
|
1124
|
+
0,
|
|
1125
|
+
resolution[1],
|
|
1126
|
+
origin[1] - (tiepoint?.[1] ?? 0) * resolution[1]
|
|
1127
|
+
];
|
|
1128
|
+
} catch {
|
|
1129
|
+
return void 0;
|
|
1130
|
+
}
|
|
1131
|
+
}
|
|
1132
|
+
function parseFiniteMetadataValue(value) {
|
|
1133
|
+
if (typeof value !== "number" && typeof value !== "string")
|
|
1134
|
+
return void 0;
|
|
1135
|
+
if (typeof value === "string" && !value.trim())
|
|
1136
|
+
return void 0;
|
|
1137
|
+
const numericValue = Number(value);
|
|
1138
|
+
return Number.isFinite(numericValue) ? numericValue : void 0;
|
|
1139
|
+
}
|
|
1140
|
+
function getImageBandMetadata(image, index, noData) {
|
|
1141
|
+
const metadata = image.getGDALMetadata?.(index) || {};
|
|
1142
|
+
const scale = parseFiniteMetadataValue(metadata.SCALE);
|
|
1143
|
+
const offset = parseFiniteMetadataValue(metadata.OFFSET);
|
|
1144
|
+
if (metadata.SCALE !== void 0 && scale === void 0 || metadata.OFFSET !== void 0 && offset === void 0)
|
|
1145
|
+
throw new Error("Invalid GDAL band scale or offset");
|
|
1146
|
+
const minimumValue = parseFiniteMetadataValue(metadata.STATISTICS_MINIMUM);
|
|
1147
|
+
const maximumValue = parseFiniteMetadataValue(metadata.STATISTICS_MAXIMUM);
|
|
1148
|
+
const hasMinimum = minimumValue !== void 0;
|
|
1149
|
+
const hasMaximum = maximumValue !== void 0;
|
|
1150
|
+
const hasDeclaredRange = (hasMinimum || hasMaximum) && !(hasMinimum && hasMaximum && minimumValue > maximumValue);
|
|
1151
|
+
return {
|
|
1152
|
+
index,
|
|
1153
|
+
declaredStatistics: hasDeclaredRange ? {
|
|
1154
|
+
band: index,
|
|
1155
|
+
domain: "unknown",
|
|
1156
|
+
scope: "source",
|
|
1157
|
+
method: "declared",
|
|
1158
|
+
min: hasMinimum ? minimumValue : void 0,
|
|
1159
|
+
max: hasMaximum ? maximumValue : void 0
|
|
1160
|
+
} : void 0,
|
|
1161
|
+
dtype: getImageDataType(image, index),
|
|
1162
|
+
categorical: index === 0 && image.fileDirectory?.PhotometricInterpretation === 3 ? true : void 0,
|
|
1163
|
+
name: typeof metadata.DESCRIPTION === "string" ? metadata.DESCRIPTION : void 0,
|
|
1164
|
+
units: typeof metadata.UNITTYPE === "string" ? metadata.UNITTYPE : void 0,
|
|
1165
|
+
scale,
|
|
1166
|
+
offset,
|
|
1167
|
+
noData
|
|
1168
|
+
};
|
|
1169
|
+
}
|
|
1170
|
+
async function resizeRasterWindow(nativeRaster, bands, interleaved, targetSize, method, signal, nativeValidityMasks) {
|
|
1171
|
+
signal?.throwIfAborted();
|
|
1172
|
+
if (nativeRaster.width === targetSize.width && nativeRaster.height === targetSize.height) {
|
|
1173
|
+
const raster2 = interleaved ? await interleaveRasterBands(nativeRaster, bands[0].dtype, signal) : nativeRaster;
|
|
1174
|
+
return { raster: raster2, validityMasks: nativeValidityMasks };
|
|
1175
|
+
}
|
|
1176
|
+
const data = normalizeRasterReadResult(nativeRaster, false);
|
|
1177
|
+
const mixed = bands.some((band) => band.dtype !== bands[0].dtype);
|
|
1178
|
+
const input = {
|
|
1179
|
+
data,
|
|
1180
|
+
dtype: mixed ? "mixed" : bands[0].dtype,
|
|
1181
|
+
interleaved: false,
|
|
1182
|
+
width: nativeRaster.width,
|
|
1183
|
+
height: nativeRaster.height,
|
|
1184
|
+
bandCount: bands.length,
|
|
1185
|
+
bands,
|
|
1186
|
+
validityMasks: nativeValidityMasks
|
|
1187
|
+
};
|
|
1188
|
+
const pixelCount = targetSize.width * targetSize.height;
|
|
1189
|
+
const output = interleaved ? createFilledTypedArray(bands[0].dtype, pixelCount * bands.length, 0) : bands.map((band) => createFilledTypedArray(band.dtype, pixelCount, band.noData ?? 0));
|
|
1190
|
+
const validityMasks = bands.map((_band, band) => ({
|
|
1191
|
+
data: new Uint8Array(pixelCount),
|
|
1192
|
+
band,
|
|
1193
|
+
width: targetSize.width,
|
|
1194
|
+
height: targetSize.height,
|
|
1195
|
+
pixelStride: 1,
|
|
1196
|
+
rowStride: targetSize.width
|
|
1197
|
+
}));
|
|
1198
|
+
for (let row = 0; row < targetSize.height; row++) {
|
|
1199
|
+
for (let column = 0; column < targetSize.width; column++) {
|
|
1200
|
+
const pixelIndex = row * targetSize.width + column;
|
|
1201
|
+
if (pixelIndex % 32768 === 0) {
|
|
1202
|
+
signal?.throwIfAborted();
|
|
1203
|
+
if (pixelIndex > 0)
|
|
1204
|
+
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
1205
|
+
signal?.throwIfAborted();
|
|
1206
|
+
}
|
|
1207
|
+
const sample = (0, import_loader_utils.sampleRaster)(input, [
|
|
1208
|
+
(column + 0.5) * nativeRaster.width / targetSize.width - 0.5,
|
|
1209
|
+
(row + 0.5) * nativeRaster.height / targetSize.height - 0.5
|
|
1210
|
+
], { method });
|
|
1211
|
+
for (let band = 0; band < bands.length; band++) {
|
|
1212
|
+
const value = sample.values[band];
|
|
1213
|
+
if (value === void 0 || !Number.isFinite(value))
|
|
1214
|
+
continue;
|
|
1215
|
+
if (Array.isArray(output))
|
|
1216
|
+
output[band][pixelIndex] = value;
|
|
1217
|
+
else
|
|
1218
|
+
output[pixelIndex * bands.length + band] = value;
|
|
1219
|
+
validityMasks[band].data[pixelIndex] = 1;
|
|
1220
|
+
}
|
|
1221
|
+
}
|
|
1222
|
+
}
|
|
1223
|
+
signal?.throwIfAborted();
|
|
1224
|
+
const raster = Object.assign(output, {
|
|
1225
|
+
width: targetSize.width,
|
|
1226
|
+
height: targetSize.height
|
|
1227
|
+
});
|
|
1228
|
+
return { raster, validityMasks };
|
|
1229
|
+
}
|
|
1230
|
+
async function interleaveRasterBands(raster, dtype, signal) {
|
|
1231
|
+
const arrays = Array.isArray(raster) ? raster : [raster];
|
|
1232
|
+
const pixelCount = raster.width * raster.height;
|
|
1233
|
+
const output = createFilledTypedArray(dtype, pixelCount * arrays.length, 0);
|
|
1234
|
+
for (let pixel = 0; pixel < pixelCount; pixel++) {
|
|
1235
|
+
if (pixel % 32768 === 0) {
|
|
1236
|
+
signal?.throwIfAborted();
|
|
1237
|
+
if (pixel > 0)
|
|
1238
|
+
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
1239
|
+
signal?.throwIfAborted();
|
|
1240
|
+
}
|
|
1241
|
+
for (let band = 0; band < arrays.length; band++)
|
|
1242
|
+
output[pixel * arrays.length + band] = arrays[band][pixel];
|
|
1243
|
+
}
|
|
1244
|
+
signal?.throwIfAborted();
|
|
1245
|
+
return Object.assign(output, {
|
|
1246
|
+
width: raster.width,
|
|
1247
|
+
height: raster.height
|
|
1248
|
+
});
|
|
1249
|
+
}
|
|
1250
|
+
function createRegionTransform(bounds, width, height) {
|
|
1251
|
+
return [
|
|
1252
|
+
(bounds[1][0] - bounds[0][0]) / width,
|
|
1253
|
+
0,
|
|
1254
|
+
bounds[0][0],
|
|
1255
|
+
0,
|
|
1256
|
+
-(bounds[1][1] - bounds[0][1]) / height,
|
|
1257
|
+
bounds[1][1]
|
|
1258
|
+
];
|
|
1259
|
+
}
|
|
1260
|
+
function estimateImageTileBytes(image, window, bytesPerPixel) {
|
|
1261
|
+
const tileWidth = image.getTileWidth?.() ?? window[2] - window[0];
|
|
1262
|
+
const tileHeight = image.getTileHeight?.() ?? window[3] - window[1];
|
|
1263
|
+
if (![tileWidth, tileHeight].every((value) => Number.isSafeInteger(value) && value > 0))
|
|
1264
|
+
throw new Error("Invalid GeoTIFF tile dimensions");
|
|
1265
|
+
const columns = Math.ceil(window[2] / tileWidth) - Math.floor(window[0] / tileWidth);
|
|
1266
|
+
const rows = Math.ceil(window[3] / tileHeight) - Math.floor(window[1] / tileHeight);
|
|
1267
|
+
return columns * rows * tileWidth * tileHeight * bytesPerPixel;
|
|
1268
|
+
}
|
|
1269
|
+
function getImageTileGrid(images, referenceImage) {
|
|
1270
|
+
const coordinateReferenceSystem = getImageCRS(referenceImage);
|
|
1271
|
+
if (!coordinateReferenceSystem)
|
|
1272
|
+
return void 0;
|
|
1273
|
+
const matrices = images.flatMap((image, index) => {
|
|
1274
|
+
if (image.fileDirectory?.NewSubfileType & 4)
|
|
1275
|
+
return [];
|
|
1276
|
+
if (image !== referenceImage && !(image.fileDirectory?.NewSubfileType & 1) && image.fileDirectory?.SubfileType !== 2)
|
|
1277
|
+
return [];
|
|
1278
|
+
const transform = getImageTransform(image, referenceImage);
|
|
1279
|
+
const imageCoordinateReferenceSystem = getImageCRS(image);
|
|
1280
|
+
const imageCoordinateMetadata = image.getGeoKeys?.() || {};
|
|
1281
|
+
const hasDeclaredCoordinateReferenceSystem = Object.entries(imageCoordinateMetadata).some(([key, value]) => key !== "GTRasterTypeGeoKey" && value !== void 0 && value !== null);
|
|
1282
|
+
if (hasDeclaredCoordinateReferenceSystem && !imageCoordinateReferenceSystem || imageCoordinateReferenceSystem && imageCoordinateReferenceSystem !== coordinateReferenceSystem || !image.fileDirectory?.TileWidth || !image.fileDirectory?.TileLength || !transform || transform[1] !== 0 || transform[3] !== 0 || transform[0] <= 0 || transform[4] === 0) {
|
|
1283
|
+
return [void 0];
|
|
1284
|
+
}
|
|
1285
|
+
const pointRegistration = (imageCoordinateMetadata.GTRasterTypeGeoKey ?? referenceImage.getGeoKeys()?.GTRasterTypeGeoKey) === 2;
|
|
1286
|
+
const inheritedTransform = image !== referenceImage && !image.fileDirectory.ModelTransformation && !image.fileDirectory.ModelTiepoint && !image.fileDirectory.ModelPixelScale;
|
|
1287
|
+
const cornerPointRegistration = inheritedTransform ? referenceImage.getGeoKeys()?.GTRasterTypeGeoKey === 2 : pointRegistration;
|
|
1288
|
+
const cornerTransform = inheritedTransform ? getImageTransform(referenceImage, referenceImage) : transform;
|
|
1289
|
+
return [
|
|
1290
|
+
(0, import_loader_utils.createTileGridMatrix)({
|
|
1291
|
+
id: String(index),
|
|
1292
|
+
resolution: transform[0],
|
|
1293
|
+
resolutionY: Math.abs(transform[4]),
|
|
1294
|
+
point: cornerPointRegistration ? [
|
|
1295
|
+
cornerTransform[2] - cornerTransform[0] / 2,
|
|
1296
|
+
cornerTransform[5] - cornerTransform[4] / 2
|
|
1297
|
+
] : [cornerTransform[2], cornerTransform[5]],
|
|
1298
|
+
swapAxes: false,
|
|
1299
|
+
cornerOfOrigin: transform[4] < 0 ? "topLeft" : "bottomLeft",
|
|
1300
|
+
tileWidth: image.getTileWidth(),
|
|
1301
|
+
tileHeight: image.getTileHeight(),
|
|
1302
|
+
matrixWidth: Math.ceil(image.getWidth() / image.getTileWidth()),
|
|
1303
|
+
matrixHeight: Math.ceil(image.getHeight() / image.getTileHeight())
|
|
1304
|
+
})
|
|
1305
|
+
];
|
|
1306
|
+
});
|
|
1307
|
+
if (!matrices.length || matrices.some((matrix) => !matrix))
|
|
1308
|
+
return void 0;
|
|
1309
|
+
const grid = (0, import_loader_utils.createTileGrid)(coordinateReferenceSystem, matrices.filter((matrix) => matrix !== void 0));
|
|
1310
|
+
return grid.tileMatrixSet ? grid : void 0;
|
|
1311
|
+
}
|
|
1312
|
+
|
|
1313
|
+
// dist/geotiff/ometiff-source-loader.js
|
|
1314
|
+
var import_geotiff2 = require("geotiff");
|
|
1315
|
+
var import_loader_utils2 = require("@loaders.gl/core/loader-utils");
|
|
1316
|
+
|
|
1317
|
+
// dist/geotiff/lib/utils/tiff-utils.js
|
|
1318
|
+
function ensureArray(x) {
|
|
1319
|
+
return Array.isArray(x) ? x : [x];
|
|
1320
|
+
}
|
|
1321
|
+
function intToRgba(int) {
|
|
1322
|
+
if (!Number.isInteger(int)) {
|
|
1323
|
+
throw Error("Not an integer.");
|
|
1324
|
+
}
|
|
1325
|
+
const buffer = new ArrayBuffer(4);
|
|
1326
|
+
const view = new DataView(buffer);
|
|
1327
|
+
view.setInt32(0, int, false);
|
|
1328
|
+
const bytes = new Uint8Array(buffer);
|
|
1329
|
+
return Array.from(bytes);
|
|
1330
|
+
}
|
|
1331
|
+
function isInterleaved(shape) {
|
|
1332
|
+
const lastDimSize = shape[shape.length - 1];
|
|
1333
|
+
return lastDimSize === 3 || lastDimSize === 4;
|
|
1334
|
+
}
|
|
1335
|
+
function getImageSize(source) {
|
|
1336
|
+
const interleaved = isInterleaved(source.shape);
|
|
1337
|
+
const [height, width] = source.shape.slice(interleaved ? -3 : -2);
|
|
1338
|
+
return { height, width };
|
|
1339
|
+
}
|
|
1340
|
+
var SIGNAL_ABORTED = "__vivSignalAborted";
|
|
1341
|
+
|
|
1342
|
+
// dist/geotiff/lib/tiff-pixel-source.js
|
|
1343
|
+
var TiffPixelSource = class {
|
|
1344
|
+
dtype;
|
|
1345
|
+
tileSize;
|
|
1346
|
+
shape;
|
|
1347
|
+
labels;
|
|
1348
|
+
meta;
|
|
1349
|
+
_indexer;
|
|
1350
|
+
// eslint-disable-next-line max-params
|
|
1351
|
+
constructor(indexer, dtype, tileSize, shape, labels, meta) {
|
|
1352
|
+
this._indexer = indexer;
|
|
1353
|
+
this.dtype = dtype;
|
|
1354
|
+
this.tileSize = tileSize;
|
|
1355
|
+
this.shape = shape;
|
|
1356
|
+
this.labels = labels;
|
|
1357
|
+
this.meta = meta;
|
|
1358
|
+
}
|
|
1359
|
+
async getRaster({ selection, signal }) {
|
|
1360
|
+
const image = await this._indexer(selection);
|
|
1361
|
+
return this._readRasters(image, { signal });
|
|
1362
|
+
}
|
|
1363
|
+
async getTile({ x, y, selection, signal }) {
|
|
1364
|
+
const { height, width } = this._getTileExtent(x, y);
|
|
1365
|
+
const x0 = x * this.tileSize;
|
|
1366
|
+
const y0 = y * this.tileSize;
|
|
1367
|
+
const window = [x0, y0, x0 + width, y0 + height];
|
|
1368
|
+
const image = await this._indexer(selection);
|
|
1369
|
+
return this._readRasters(image, { window, width, height, signal });
|
|
1370
|
+
}
|
|
1371
|
+
async _readRasters(image, props) {
|
|
1372
|
+
const interleave = isInterleaved(this.shape);
|
|
1373
|
+
const raster = await image.readRasters({ interleave, ...props });
|
|
1374
|
+
if (props?.signal?.aborted) {
|
|
1375
|
+
throw SIGNAL_ABORTED;
|
|
1376
|
+
}
|
|
1377
|
+
const data = interleave ? raster : raster[0];
|
|
1378
|
+
return {
|
|
1379
|
+
data,
|
|
1380
|
+
width: raster.width,
|
|
1381
|
+
height: raster.height
|
|
1382
|
+
};
|
|
1383
|
+
}
|
|
1384
|
+
/*
|
|
1385
|
+
* Computes tile size given x, y coord.
|
|
1386
|
+
*/
|
|
1387
|
+
_getTileExtent(x, y) {
|
|
1388
|
+
const { height: zoomLevelHeight, width: zoomLevelWidth } = getImageSize(this);
|
|
1389
|
+
let height = this.tileSize;
|
|
1390
|
+
let width = this.tileSize;
|
|
1391
|
+
const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);
|
|
1392
|
+
const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);
|
|
1393
|
+
if (x === maxXTileCoord) {
|
|
1394
|
+
width = zoomLevelWidth % this.tileSize;
|
|
1395
|
+
}
|
|
1396
|
+
if (y === maxYTileCoord) {
|
|
1397
|
+
height = zoomLevelHeight % this.tileSize;
|
|
1398
|
+
}
|
|
1399
|
+
return { height, width };
|
|
1400
|
+
}
|
|
1401
|
+
onTileError(err) {
|
|
1402
|
+
console.error(err);
|
|
1403
|
+
}
|
|
1404
|
+
};
|
|
1405
|
+
|
|
1406
|
+
// dist/geotiff/lib/ome/ome-indexers.js
|
|
1407
|
+
function getOmeLegacyIndexer(tiff, rootMeta) {
|
|
1408
|
+
const imgMeta = rootMeta[0];
|
|
1409
|
+
const { SizeT, SizeC, SizeZ } = imgMeta.Pixels;
|
|
1410
|
+
const ifdIndexer = getOmeIFDIndexer(imgMeta);
|
|
1411
|
+
return (sel, pyramidLevel) => {
|
|
1412
|
+
const index = ifdIndexer(sel);
|
|
1413
|
+
const pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;
|
|
1414
|
+
return tiff.getImage(index + pyramidIndex);
|
|
1415
|
+
};
|
|
1416
|
+
}
|
|
1417
|
+
function getOmeSubIFDIndexer(tiff, rootMeta) {
|
|
1418
|
+
const imgMeta = rootMeta[0];
|
|
1419
|
+
const ifdIndexer = getOmeIFDIndexer(imgMeta);
|
|
1420
|
+
const ifdCache = /* @__PURE__ */ new Map();
|
|
1421
|
+
return async (sel, pyramidLevel) => {
|
|
1422
|
+
const index = ifdIndexer(sel);
|
|
1423
|
+
const baseImage = await tiff.getImage(index);
|
|
1424
|
+
if (pyramidLevel === 0) {
|
|
1425
|
+
return baseImage;
|
|
1426
|
+
}
|
|
1427
|
+
const { SubIFDs } = baseImage.fileDirectory;
|
|
1428
|
+
if (!SubIFDs) {
|
|
1429
|
+
throw Error("Indexing Error: OME-TIFF is missing SubIFDs.");
|
|
1430
|
+
}
|
|
1431
|
+
const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;
|
|
1432
|
+
if (!ifdCache.has(key)) {
|
|
1433
|
+
const subIfdOffset = SubIFDs[pyramidLevel - 1];
|
|
1434
|
+
ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
|
|
1435
|
+
}
|
|
1436
|
+
const ifd = await ifdCache.get(key);
|
|
1437
|
+
return new baseImage.constructor(
|
|
1438
|
+
ifd.fileDirectory,
|
|
1439
|
+
ifd.geoKeyDirectory,
|
|
1440
|
+
// @ts-expect-error
|
|
1441
|
+
tiff.dataView,
|
|
1442
|
+
tiff.littleEndian,
|
|
1443
|
+
tiff.cache,
|
|
1444
|
+
tiff.source
|
|
1445
|
+
);
|
|
1446
|
+
};
|
|
1447
|
+
}
|
|
1448
|
+
function getOmeIFDIndexer(imgMeta) {
|
|
1449
|
+
const { SizeC, SizeZ, SizeT, DimensionOrder } = imgMeta.Pixels;
|
|
1450
|
+
switch (DimensionOrder) {
|
|
1451
|
+
case "XYZCT": {
|
|
1452
|
+
return ({ t, c, z }) => t * SizeZ * SizeC + c * SizeZ + z;
|
|
1453
|
+
}
|
|
1454
|
+
case "XYZTC": {
|
|
1455
|
+
return ({ t, c, z }) => c * SizeZ * SizeT + t * SizeZ + z;
|
|
1456
|
+
}
|
|
1457
|
+
case "XYCTZ": {
|
|
1458
|
+
return ({ t, c, z }) => z * SizeC * SizeT + t * SizeC + c;
|
|
1459
|
+
}
|
|
1460
|
+
case "XYCZT": {
|
|
1461
|
+
return ({ t, c, z }) => t * SizeC * SizeZ + z * SizeC + c;
|
|
1462
|
+
}
|
|
1463
|
+
case "XYTCZ": {
|
|
1464
|
+
return ({ t, c, z }) => z * SizeT * SizeC + c * SizeT + t;
|
|
1465
|
+
}
|
|
1466
|
+
case "XYTZC": {
|
|
1467
|
+
return ({ t, c, z }) => c * SizeT * SizeZ + z * SizeT + t;
|
|
1468
|
+
}
|
|
1469
|
+
default: {
|
|
1470
|
+
throw new Error(`Invalid OME-XML DimensionOrder, got ${DimensionOrder}.`);
|
|
1471
|
+
}
|
|
1472
|
+
}
|
|
1473
|
+
}
|
|
1474
|
+
|
|
1475
|
+
// dist/geotiff/lib/ome/utils.js
|
|
1476
|
+
function getLabels(dimOrder) {
|
|
1477
|
+
return dimOrder.toLowerCase().split("").reverse();
|
|
1478
|
+
}
|
|
1479
|
+
function getDims(labels) {
|
|
1480
|
+
const lookup = new Map(labels.map((name, i) => [name, i]));
|
|
1481
|
+
if (lookup.size !== labels.length) {
|
|
1482
|
+
throw Error("Labels must be unique, found duplicated label.");
|
|
1483
|
+
}
|
|
1484
|
+
return (name) => {
|
|
1485
|
+
const index = lookup.get(name);
|
|
1486
|
+
if (index === void 0) {
|
|
1487
|
+
throw Error("Invalid dimension.");
|
|
1488
|
+
}
|
|
1489
|
+
return index;
|
|
1490
|
+
};
|
|
1491
|
+
}
|
|
1492
|
+
|
|
1493
|
+
// dist/geotiff/lib/ome/ome-utils.js
|
|
1494
|
+
var DTYPE_LOOKUP = {
|
|
1495
|
+
uint8: "uint8",
|
|
1496
|
+
uint16: "uint16",
|
|
1497
|
+
uint32: "uint32",
|
|
1498
|
+
float: "float32",
|
|
1499
|
+
double: "float64",
|
|
1500
|
+
int8: "int8",
|
|
1501
|
+
int16: "int16",
|
|
1502
|
+
int32: "int32"
|
|
1503
|
+
};
|
|
1504
|
+
function getOmePixelSourceMeta({ Pixels }) {
|
|
1505
|
+
const labels = getLabels(Pixels.DimensionOrder);
|
|
1506
|
+
const dims = getDims(labels);
|
|
1507
|
+
const shape = Array(labels.length).fill(0);
|
|
1508
|
+
shape[dims("t")] = Pixels.SizeT;
|
|
1509
|
+
shape[dims("c")] = Pixels.SizeC;
|
|
1510
|
+
shape[dims("z")] = Pixels.SizeZ;
|
|
1511
|
+
if (Pixels.Interleaved) {
|
|
1512
|
+
labels.push("_c");
|
|
1513
|
+
shape.push(3);
|
|
1514
|
+
}
|
|
1515
|
+
const getShape = (level) => {
|
|
1516
|
+
const s = [...shape];
|
|
1517
|
+
s[dims("x")] = Pixels.SizeX >> level;
|
|
1518
|
+
s[dims("y")] = Pixels.SizeY >> level;
|
|
1519
|
+
return s;
|
|
1520
|
+
};
|
|
1521
|
+
if (!(Pixels.Type in DTYPE_LOOKUP)) {
|
|
1522
|
+
throw Error(`Pixel type ${Pixels.Type} not supported.`);
|
|
1523
|
+
}
|
|
1524
|
+
const dtype = DTYPE_LOOKUP[Pixels.Type];
|
|
1525
|
+
if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {
|
|
1526
|
+
const physicalSizes = {
|
|
1527
|
+
x: {
|
|
1528
|
+
size: Pixels.PhysicalSizeX,
|
|
1529
|
+
unit: Pixels.PhysicalSizeXUnit
|
|
1530
|
+
},
|
|
1531
|
+
y: {
|
|
1532
|
+
size: Pixels.PhysicalSizeY,
|
|
1533
|
+
unit: Pixels.PhysicalSizeYUnit
|
|
1534
|
+
}
|
|
1535
|
+
};
|
|
1536
|
+
if (Pixels.PhysicalSizeZ) {
|
|
1537
|
+
physicalSizes.z = {
|
|
1538
|
+
size: Pixels.PhysicalSizeZ,
|
|
1539
|
+
unit: Pixels.PhysicalSizeZUnit
|
|
1540
|
+
};
|
|
1541
|
+
}
|
|
1542
|
+
return { labels, getShape, physicalSizes, dtype };
|
|
1543
|
+
}
|
|
1544
|
+
return { labels, getShape, dtype };
|
|
1545
|
+
}
|
|
1546
|
+
|
|
1547
|
+
// dist/geotiff/lib/ome/omexml.js
|
|
1548
|
+
var import_fast_xml_parser = require("fast-xml-parser");
|
|
1549
|
+
var xmlParser = new import_fast_xml_parser.XMLParser({
|
|
1550
|
+
// Nests attributes withtout prefix under 'attr' key for each node
|
|
1551
|
+
attributeNamePrefix: "",
|
|
1552
|
+
attributesGroupName: "attr",
|
|
1553
|
+
// Parses numbers for both attributes and nodes
|
|
1554
|
+
parseTagValue: true,
|
|
1555
|
+
parseAttributeValue: true,
|
|
1556
|
+
// Forces attributes to be parsed
|
|
1557
|
+
ignoreAttributes: false
|
|
1558
|
+
});
|
|
1559
|
+
var parse = (str) => xmlParser.parse(str);
|
|
1560
|
+
function fromString(str) {
|
|
1561
|
+
const res = parse(str);
|
|
1562
|
+
if (!res.OME) {
|
|
1563
|
+
throw Error("Failed to parse OME-XML metadata.");
|
|
1564
|
+
}
|
|
1565
|
+
return ensureArray(res.OME.Image).map((img) => {
|
|
1566
|
+
const Channels = ensureArray(img.Pixels.Channel).map((c) => {
|
|
1567
|
+
if ("Color" in c.attr) {
|
|
1568
|
+
return { ...c.attr, Color: intToRgba(c.attr.Color) };
|
|
1569
|
+
}
|
|
1570
|
+
return { ...c.attr };
|
|
1571
|
+
});
|
|
1572
|
+
const { AquisitionDate = "", Description = "" } = img;
|
|
1573
|
+
const image = {
|
|
1574
|
+
...img.attr,
|
|
1575
|
+
AquisitionDate,
|
|
1576
|
+
Description,
|
|
1577
|
+
Pixels: {
|
|
1578
|
+
...img.Pixels.attr,
|
|
1579
|
+
Channels
|
|
1580
|
+
}
|
|
1581
|
+
};
|
|
1582
|
+
return {
|
|
1583
|
+
...image,
|
|
1584
|
+
format() {
|
|
1585
|
+
const { Pixels } = image;
|
|
1586
|
+
const sizes = ["X", "Y", "Z"].map((name) => {
|
|
1587
|
+
const size = Pixels[`PhysicalSize${name}`];
|
|
1588
|
+
const unit = Pixels[`PhysicalSize${name}Unit`];
|
|
1589
|
+
return size && unit ? `${size} ${unit}` : "-";
|
|
1590
|
+
}).join(" x ");
|
|
1591
|
+
return {
|
|
1592
|
+
"Acquisition Date": image.AquisitionDate,
|
|
1593
|
+
"Dimensions (XY)": `${Pixels.SizeX} x ${Pixels.SizeY}`,
|
|
1594
|
+
"Pixels Type": Pixels.Type,
|
|
1595
|
+
"Pixels Size (XYZ)": sizes,
|
|
1596
|
+
"Z-sections/Timepoints": `${Pixels.SizeZ} x ${Pixels.SizeT}`,
|
|
1597
|
+
Channels: Pixels.SizeC
|
|
1598
|
+
};
|
|
1599
|
+
}
|
|
1600
|
+
};
|
|
1601
|
+
});
|
|
1602
|
+
}
|
|
1603
|
+
|
|
1604
|
+
// dist/geotiff/lib/ome/load-ome-tiff.js
|
|
1605
|
+
var isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes("<OME");
|
|
1606
|
+
async function loadOmeTiff(tiff, firstImage) {
|
|
1607
|
+
const { ImageDescription, SubIFDs, PhotometricInterpretation: photometricInterpretation } = firstImage.fileDirectory;
|
|
1608
|
+
const omexml = fromString(ImageDescription);
|
|
1609
|
+
let levels;
|
|
1610
|
+
let pyramidIndexer;
|
|
1611
|
+
if (SubIFDs) {
|
|
1612
|
+
levels = SubIFDs.length + 1;
|
|
1613
|
+
pyramidIndexer = getOmeSubIFDIndexer(tiff, omexml);
|
|
1614
|
+
} else {
|
|
1615
|
+
levels = omexml.length;
|
|
1616
|
+
pyramidIndexer = getOmeLegacyIndexer(tiff, omexml);
|
|
1617
|
+
}
|
|
1618
|
+
const imgMeta = omexml[0];
|
|
1619
|
+
const { labels, getShape, physicalSizes, dtype } = getOmePixelSourceMeta(imgMeta);
|
|
1620
|
+
const tileSize = firstImage.getTileWidth();
|
|
1621
|
+
const meta = { photometricInterpretation, physicalSizes };
|
|
1622
|
+
const data = Array.from({ length: levels }).map((_, resolution) => {
|
|
1623
|
+
const shape = getShape(resolution);
|
|
1624
|
+
const indexer = (sel) => pyramidIndexer(sel, resolution);
|
|
1625
|
+
const source = new TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta);
|
|
1626
|
+
return source;
|
|
1627
|
+
});
|
|
1628
|
+
return { data, metadata: imgMeta };
|
|
1629
|
+
}
|
|
1630
|
+
|
|
1631
|
+
// dist/geotiff/ometiff-source-loader.js
|
|
1632
|
+
var VERSION3 = true ? "5.0.0-alpha.14" : "latest";
|
|
1633
|
+
var OMETiffSourceLoader = {
|
|
1634
|
+
dataType: null,
|
|
1635
|
+
batchType: null,
|
|
1636
|
+
...OMETiffFormat,
|
|
1637
|
+
name: "OMETiffSourceLoader",
|
|
1638
|
+
version: VERSION3,
|
|
1639
|
+
type: "ometiff",
|
|
1640
|
+
fromUrl: true,
|
|
1641
|
+
fromBlob: true,
|
|
1642
|
+
options: {
|
|
1643
|
+
ometiff: {
|
|
1644
|
+
headers: void 0,
|
|
1645
|
+
interleaved: false,
|
|
1646
|
+
defaultChannels: void 0
|
|
1647
|
+
}
|
|
1648
|
+
},
|
|
1649
|
+
defaultOptions: {
|
|
1650
|
+
ometiff: {
|
|
1651
|
+
headers: void 0,
|
|
1652
|
+
interleaved: false,
|
|
1653
|
+
defaultChannels: void 0
|
|
1654
|
+
}
|
|
1655
|
+
},
|
|
1656
|
+
testURL: (url) => /\.ome\.tiff?(?:$|[?#])/i.test(url),
|
|
1657
|
+
createDataSource: (data, options) => new OMETiffImageSource(data, options)
|
|
1658
|
+
};
|
|
1659
|
+
var OMETiffImageSource = class extends import_loader_utils2.DataSource {
|
|
1660
|
+
_initPromise = null;
|
|
1661
|
+
/**
|
|
1662
|
+
* Returns normalized OME-TIFF metadata for the first image in the file.
|
|
1663
|
+
*/
|
|
1664
|
+
async getMetadata() {
|
|
1665
|
+
const { metadata } = await this._getInitPromise();
|
|
1666
|
+
return metadata;
|
|
1667
|
+
}
|
|
1668
|
+
/** Discovers OME-TIFF channels, pyramid levels, and selectable dimensions. */
|
|
1669
|
+
async getQueryMetadata(options = {}) {
|
|
1670
|
+
if (options.signal?.aborted)
|
|
1671
|
+
throw new DOMException("The operation was aborted", "AbortError");
|
|
1672
|
+
const metadata = await this.getMetadata();
|
|
1673
|
+
if (options.signal?.aborted)
|
|
1674
|
+
throw new DOMException("The operation was aborted", "AbortError");
|
|
1675
|
+
const fields = metadata.channels.map((channel) => ({
|
|
1676
|
+
name: channel.name || `channel_${channel.index + 1}`,
|
|
1677
|
+
type: metadata.dtype,
|
|
1678
|
+
nullable: false,
|
|
1679
|
+
metadata: channel.color ? { color: channel.color.join(",") } : void 0
|
|
1680
|
+
}));
|
|
1681
|
+
return (0, import_loader_utils2.createScanQueryMetadata)({
|
|
1682
|
+
sourceType: "ometiff",
|
|
1683
|
+
queryType: "raster",
|
|
1684
|
+
execution: { status: "supported", method: "getRaster" },
|
|
1685
|
+
name: metadata.name,
|
|
1686
|
+
schema: { fields, metadata: {} },
|
|
1687
|
+
capabilities: {
|
|
1688
|
+
levelOfDetail: metadata.levels.length > 1 ? "pushdown" : "unsupported"
|
|
1689
|
+
},
|
|
1690
|
+
levels: metadata.levels.map((level) => ({
|
|
1691
|
+
index: level.level,
|
|
1692
|
+
width: level.width,
|
|
1693
|
+
height: level.height,
|
|
1694
|
+
scale: [metadata.width / level.width, metadata.height / level.height]
|
|
1695
|
+
}))
|
|
1696
|
+
});
|
|
1697
|
+
}
|
|
1698
|
+
/**
|
|
1699
|
+
* Loads one 2D OME-TIFF plane or channel composite.
|
|
1700
|
+
*/
|
|
1701
|
+
async getRaster(parameters = {}) {
|
|
1702
|
+
const { data, metadata } = await this._getInitPromise();
|
|
1703
|
+
const level = parameters.level ?? 0;
|
|
1704
|
+
const pixelSource = data[level];
|
|
1705
|
+
if (!pixelSource) {
|
|
1706
|
+
throw new Error(`OME-TIFF pyramid level ${level} is not available.`);
|
|
1707
|
+
}
|
|
1708
|
+
const channels = normalizeChannelSelection(parameters.channels, metadata.bandCount, this.options.ometiff?.defaultChannels);
|
|
1709
|
+
const selection = {
|
|
1710
|
+
t: parameters.t ?? 0,
|
|
1711
|
+
z: parameters.z ?? 0
|
|
1712
|
+
};
|
|
1713
|
+
const interleaved = parameters.interleaved ?? this.options.ometiff?.interleaved ?? false;
|
|
1714
|
+
const rasters = await Promise.all(channels.map((channel) => pixelSource.getRaster({
|
|
1715
|
+
selection: { ...selection, c: channel },
|
|
1716
|
+
signal: parameters.signal
|
|
1717
|
+
})));
|
|
1718
|
+
const { width, height } = rasters[0];
|
|
1719
|
+
const channelData = rasters.map((raster) => raster.data);
|
|
1720
|
+
return {
|
|
1721
|
+
data: interleaved ? interleaveTypedArrays(channelData, metadata.dtype) : channelData.length === 1 ? channelData[0] : channelData,
|
|
1722
|
+
width,
|
|
1723
|
+
height,
|
|
1724
|
+
bandCount: channelData.length,
|
|
1725
|
+
dtype: metadata.dtype,
|
|
1726
|
+
interleaved,
|
|
1727
|
+
metadata: {
|
|
1728
|
+
selection,
|
|
1729
|
+
channels,
|
|
1730
|
+
level,
|
|
1731
|
+
sourceLabels: metadata.labels
|
|
1732
|
+
}
|
|
1733
|
+
};
|
|
1734
|
+
}
|
|
1735
|
+
/** Returns the shared initialization promise for this source instance. */
|
|
1736
|
+
_getInitPromise() {
|
|
1737
|
+
if (!this._initPromise) {
|
|
1738
|
+
this._initPromise = this._initialize();
|
|
1739
|
+
}
|
|
1740
|
+
return this._initPromise;
|
|
1741
|
+
}
|
|
1742
|
+
/** Opens the OME-TIFF once and resolves its pixel sources and normalized metadata. */
|
|
1743
|
+
async _initialize() {
|
|
1744
|
+
const tiff = await this._openTiff();
|
|
1745
|
+
const firstImage = await tiff.getImage(0);
|
|
1746
|
+
if (!isOmeTiff(firstImage)) {
|
|
1747
|
+
throw new Error("OMETiffImageSource requires an OME-TIFF input.");
|
|
1748
|
+
}
|
|
1749
|
+
const loaded = await loadOmeTiff(tiff, firstImage);
|
|
1750
|
+
return {
|
|
1751
|
+
data: loaded.data,
|
|
1752
|
+
metadata: normalizeOMETiffMetadata(this.data, loaded)
|
|
1753
|
+
};
|
|
1754
|
+
}
|
|
1755
|
+
/** Opens the backing OME-TIFF from a URL or Blob input. */
|
|
1756
|
+
async _openTiff() {
|
|
1757
|
+
if (typeof this.data === "string") {
|
|
1758
|
+
return await (0, import_geotiff2.fromUrl)(this.url, this.options.ometiff?.headers);
|
|
1759
|
+
}
|
|
1760
|
+
return await (0, import_geotiff2.fromBlob)(this.data);
|
|
1761
|
+
}
|
|
1762
|
+
};
|
|
1763
|
+
function normalizeOMETiffMetadata(data, loaded) {
|
|
1764
|
+
const baseSource = loaded.data[0];
|
|
1765
|
+
const { width, height } = getImageSize(baseSource);
|
|
1766
|
+
const pixels = loaded.metadata.Pixels;
|
|
1767
|
+
return {
|
|
1768
|
+
name: loaded.metadata.Name || getOMETiffName(data),
|
|
1769
|
+
width,
|
|
1770
|
+
height,
|
|
1771
|
+
bandCount: pixels.SizeC,
|
|
1772
|
+
dtype: baseSource.dtype,
|
|
1773
|
+
sizeT: pixels.SizeT,
|
|
1774
|
+
sizeZ: pixels.SizeZ,
|
|
1775
|
+
sizeC: pixels.SizeC,
|
|
1776
|
+
labels: [...baseSource.labels],
|
|
1777
|
+
tileSize: {
|
|
1778
|
+
width: baseSource.tileSize,
|
|
1779
|
+
height: baseSource.tileSize
|
|
1780
|
+
},
|
|
1781
|
+
levels: loaded.data.map((source, level) => {
|
|
1782
|
+
const imageSize = getImageSize(source);
|
|
1783
|
+
return { level, width: imageSize.width, height: imageSize.height };
|
|
1784
|
+
}),
|
|
1785
|
+
channels: ensureArray(pixels.Channels || []).map((channel, index) => ({
|
|
1786
|
+
index,
|
|
1787
|
+
name: channel.Name,
|
|
1788
|
+
color: Number.isInteger(channel.Color) ? intToRgba(channel.Color) : void 0,
|
|
1789
|
+
samplesPerPixel: channel.SamplesPerPixel
|
|
1790
|
+
})),
|
|
1791
|
+
physicalSizes: baseSource.meta?.physicalSizes,
|
|
1792
|
+
metadata: loaded.metadata
|
|
1793
|
+
};
|
|
1794
|
+
}
|
|
1795
|
+
function normalizeChannelSelection(channels, bandCount, defaultChannels) {
|
|
1796
|
+
const resolvedChannels = channels && channels.length ? channels : defaultChannels && defaultChannels.length ? defaultChannels : bandCount >= 3 ? [0, 1, 2] : [0];
|
|
1797
|
+
for (const channel of resolvedChannels) {
|
|
1798
|
+
if (channel < 0 || channel >= bandCount) {
|
|
1799
|
+
throw new Error(`OME-TIFF channel ${channel} is out of bounds for ${bandCount} channels.`);
|
|
1800
|
+
}
|
|
1801
|
+
}
|
|
1802
|
+
return resolvedChannels;
|
|
1803
|
+
}
|
|
1804
|
+
function interleaveTypedArrays(arrays, dtype) {
|
|
1805
|
+
if (arrays.length === 1) {
|
|
1806
|
+
return arrays[0];
|
|
1807
|
+
}
|
|
1808
|
+
const output = createTypedArray(dtype, arrays[0].length * arrays.length);
|
|
1809
|
+
let outputIndex = 0;
|
|
1810
|
+
for (let pixelIndex = 0; pixelIndex < arrays[0].length; pixelIndex++) {
|
|
1811
|
+
for (let channelIndex = 0; channelIndex < arrays.length; channelIndex++) {
|
|
1812
|
+
output[outputIndex++] = arrays[channelIndex][pixelIndex];
|
|
1813
|
+
}
|
|
1814
|
+
}
|
|
1815
|
+
return output;
|
|
1816
|
+
}
|
|
1817
|
+
function createTypedArray(dtype, length) {
|
|
1818
|
+
switch (dtype) {
|
|
1819
|
+
case "uint8":
|
|
1820
|
+
return new Uint8Array(length);
|
|
1821
|
+
case "uint16":
|
|
1822
|
+
return new Uint16Array(length);
|
|
1823
|
+
case "uint32":
|
|
1824
|
+
return new Uint32Array(length);
|
|
1825
|
+
case "int8":
|
|
1826
|
+
return new Int8Array(length);
|
|
1827
|
+
case "int16":
|
|
1828
|
+
return new Int16Array(length);
|
|
1829
|
+
case "int32":
|
|
1830
|
+
return new Int32Array(length);
|
|
1831
|
+
case "float32":
|
|
1832
|
+
return new Float32Array(length);
|
|
1833
|
+
case "float64":
|
|
1834
|
+
return new Float64Array(length);
|
|
1835
|
+
default:
|
|
1836
|
+
throw new Error(`Unsupported raster channel type: ${dtype}.`);
|
|
1837
|
+
}
|
|
1838
|
+
}
|
|
1839
|
+
function getOMETiffName(data) {
|
|
1840
|
+
if (typeof data !== "string") {
|
|
1841
|
+
return void 0;
|
|
1842
|
+
}
|
|
1843
|
+
const [path] = data.split(/[?#]/);
|
|
1844
|
+
return path.split("/").pop() || void 0;
|
|
1845
|
+
}
|
|
1846
|
+
|
|
1847
|
+
// dist/geotiff/lib/load-geotiff.js
|
|
1848
|
+
var import_geotiff3 = require("geotiff");
|
|
1849
|
+
async function loadGeoTiff(source, opts = {}) {
|
|
1850
|
+
const { headers, offsets } = opts;
|
|
1851
|
+
let tiff;
|
|
1852
|
+
if (source instanceof import_geotiff3.GeoTIFF) {
|
|
1853
|
+
tiff = source;
|
|
1854
|
+
} else if (typeof source === "string") {
|
|
1855
|
+
tiff = await (0, import_geotiff3.fromUrl)(source, headers);
|
|
1856
|
+
} else {
|
|
1857
|
+
tiff = await (0, import_geotiff3.fromBlob)(source);
|
|
1858
|
+
}
|
|
1859
|
+
if (offsets) {
|
|
1860
|
+
}
|
|
1861
|
+
const firstImage = await tiff.getImage(0);
|
|
1862
|
+
if (isOmeTiff(firstImage)) {
|
|
1863
|
+
return loadOmeTiff(tiff, firstImage);
|
|
1864
|
+
}
|
|
1865
|
+
throw new Error("GeoTIFF not recognized.");
|
|
1866
|
+
}
|
|
1867
|
+
|
|
1868
|
+
// dist/geotiff/geotiff-raster-loader-types.js
|
|
1869
|
+
var VERSION4 = true ? "5.0.0-alpha.14" : "latest";
|
|
1870
|
+
async function preload2() {
|
|
1871
|
+
const { GeoTIFFRasterLoaderWithParser } = await import("@loaders.gl/raster/geotiff/geotiff-raster-loader");
|
|
1872
|
+
return GeoTIFFRasterLoaderWithParser;
|
|
1873
|
+
}
|
|
1874
|
+
var GeoTIFFRasterLoader = {
|
|
1875
|
+
...GeoTIFFFormat,
|
|
1876
|
+
id: "geotiff-raster",
|
|
1877
|
+
name: "GeoTIFF Raster",
|
|
1878
|
+
version: VERSION4,
|
|
1879
|
+
dataType: null,
|
|
1880
|
+
batchType: null,
|
|
1881
|
+
options: { geotiff: {} },
|
|
1882
|
+
preload: preload2
|
|
1883
|
+
};
|
|
1884
|
+
|
|
1885
|
+
// dist/geotiff/discover-geotiff.js
|
|
1886
|
+
function isTIFFHeader(bytes) {
|
|
1887
|
+
if (bytes.length < 4)
|
|
1888
|
+
return false;
|
|
1889
|
+
const littleEndian = bytes[0] === 73 && bytes[1] === 73;
|
|
1890
|
+
const bigEndian = bytes[0] === 77 && bytes[1] === 77;
|
|
1891
|
+
if (!littleEndian && !bigEndian)
|
|
1892
|
+
return false;
|
|
1893
|
+
const version = littleEndian ? bytes[2] + bytes[3] * 256 : bytes[2] * 256 + bytes[3];
|
|
1894
|
+
if (version === 42)
|
|
1895
|
+
return true;
|
|
1896
|
+
if (version !== 43 || bytes.length < 8)
|
|
1897
|
+
return false;
|
|
1898
|
+
return littleEndian ? bytes[4] === 8 && bytes[5] === 0 && bytes[6] === 0 && bytes[7] === 0 : bytes[4] === 0 && bytes[5] === 8 && bytes[6] === 0 && bytes[7] === 0;
|
|
1899
|
+
}
|
|
1900
|
+
async function discoverGeoTIFF(url, options = {}) {
|
|
1901
|
+
options.signal?.throwIfAborted();
|
|
1902
|
+
const headers = new Headers(options.headers);
|
|
1903
|
+
headers.set("Range", "bytes=0-7");
|
|
1904
|
+
const response = await (options.fetch ?? globalThis.fetch)(url, {
|
|
1905
|
+
headers,
|
|
1906
|
+
signal: options.signal
|
|
1907
|
+
});
|
|
1908
|
+
if (response.status !== 206) {
|
|
1909
|
+
await response.body?.cancel();
|
|
1910
|
+
throw new Error("Bounded TIFF detection requires a 206 byte-range response");
|
|
1911
|
+
}
|
|
1912
|
+
const contentRange = response.headers.get("Content-Range");
|
|
1913
|
+
if (contentRange && !/^bytes 0-[0-7]\/\d+$/.test(contentRange)) {
|
|
1914
|
+
await response.body?.cancel();
|
|
1915
|
+
throw new Error("Invalid TIFF detection content range");
|
|
1916
|
+
}
|
|
1917
|
+
if (!response.body)
|
|
1918
|
+
return false;
|
|
1919
|
+
const reader = response.body.getReader();
|
|
1920
|
+
const prefix = new Uint8Array(8);
|
|
1921
|
+
let length = 0;
|
|
1922
|
+
try {
|
|
1923
|
+
while (length < prefix.length) {
|
|
1924
|
+
options.signal?.throwIfAborted();
|
|
1925
|
+
const chunk = await reader.read();
|
|
1926
|
+
if (chunk.done)
|
|
1927
|
+
break;
|
|
1928
|
+
if (length + chunk.value.byteLength > prefix.length)
|
|
1929
|
+
throw new Error("TIFF detection response exceeds eight-byte budget");
|
|
1930
|
+
prefix.set(chunk.value, length);
|
|
1931
|
+
length += chunk.value.byteLength;
|
|
1932
|
+
}
|
|
1933
|
+
options.signal?.throwIfAborted();
|
|
1934
|
+
return isTIFFHeader(prefix.subarray(0, length));
|
|
1935
|
+
} finally {
|
|
1936
|
+
await reader.cancel();
|
|
1937
|
+
reader.releaseLock();
|
|
1938
|
+
}
|
|
1939
|
+
}
|
|
1940
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
1941
|
+
0 && (module.exports = {
|
|
1942
|
+
GeoTIFFFormat,
|
|
1943
|
+
GeoTIFFLoader,
|
|
1944
|
+
GeoTIFFRasterLoader,
|
|
1945
|
+
GeoTIFFRasterSource,
|
|
1946
|
+
GeoTIFFSourceLoader,
|
|
1947
|
+
OMETiffFormat,
|
|
1948
|
+
OMETiffImageSource,
|
|
1949
|
+
OMETiffSourceLoader,
|
|
1950
|
+
TiffPixelSource,
|
|
1951
|
+
discoverGeoTIFF,
|
|
1952
|
+
isTIFFHeader,
|
|
1953
|
+
loadGeoTiff
|
|
1954
|
+
});
|
|
1955
|
+
//# sourceMappingURL=advanced.cjs.map
|