ol 7.0.1-dev.1661646168074 → 7.0.1-dev.1661715723847

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "7.0.1-dev.1661646168074",
+  "version": "7.0.1-dev.1661715723847",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/source/GeoTIFF.d.ts

@@ -141,9 +141,10 @@ export type Options = {
     /**
      * By default, bands from the sources are read as-is. When
      * reading GeoTIFFs with the purpose of displaying them as RGB images, setting this to `true` will
-     * convert other color spaces (YCbCr, CMYK) to RGB.
+     * convert other color spaces (YCbCr, CMYK) to RGB.  Setting the option to `'auto'` will make it so CMYK, YCbCr,
+     * CIELab, and ICCLab images will automatically be converted to RGB.
      */
-    convertToRGB?: boolean | undefined;
+    convertToRGB?: boolean | "auto" | undefined;
     /**
      * By default, the source data is normalized to values between
      * 0 and 1 with scaling factors based on the raster statistics or `min` and `max` properties of each source.
@@ -194,9 +195,10 @@ export type Options = {
  * another with 1 band, the resulting data tiles will have 5 bands: 3 from the first source, 1 alpha
  * band from the first source, and 1 band from the second source.
  * @property {GeoTIFFSourceOptions} [sourceOptions] Additional options to be passed to [geotiff.js](https://geotiffjs.github.io/geotiff.js/module-geotiff.html)'s `fromUrl` or `fromUrls` methods.
- * @property {boolean} [convertToRGB = false] By default, bands from the sources are read as-is. When
+ * @property {true|false|'auto'} [convertToRGB=false] By default, bands from the sources are read as-is. When
  * reading GeoTIFFs with the purpose of displaying them as RGB images, setting this to `true` will
- * convert other color spaces (YCbCr, CMYK) to RGB.
+ * convert other color spaces (YCbCr, CMYK) to RGB.  Setting the option to `'auto'` will make it so CMYK, YCbCr,
+ * CIELab, and ICCLab images will automatically be converted to RGB.
  * @property {boolean} [normalize=true] By default, the source data is normalized to values between
  * 0 and 1 with scaling factors based on the raster statistics or `min` and `max` properties of each source.
  * If instead you want to work with the raw values in a style expression, set this to `false`.  Setting this option
@@ -233,6 +235,11 @@ declare class GeoTIFFSource extends DataTile {
      * @private
      */
     private sourceImagery_;
+    /**
+     * @type {Array<Array<GeoTIFFImage>>}
+     * @private
+     */
+    private sourceMasks_;
     /**
      * @type {Array<number>}
      * @private
@@ -269,9 +276,9 @@ declare class GeoTIFFSource extends DataTile {
      */
     private error_;
     /**
-     * @type {'readRasters' | 'readRGB'}
+     * @type {true|false|'auto'}
      */
-    readMethod_: 'readRasters' | 'readRGB';
+    convertToRGB_: true | false | 'auto';
     /**
      * @return {Error} A source loading error. When the source state is `error`, use this function
      * to get more information about the error. To debug a faulty configuration, you may want to use
@@ -293,7 +300,21 @@ declare class GeoTIFFSource extends DataTile {
      * @private
      */
     private configure_;
-    loadTile_(z: any, x: any, y: any): Promise<Uint8Array | Float32Array>;
+    /**
+     * @param {number} z The z tile index.
+     * @param {number} x The x tile index.
+     * @param {number} y The y tile index.
+     * @return {Promise} The composed tile data.
+     * @private
+     */
+    private loadTile_;
+    /**
+     * @param {import("../size.js").Size} sourceTileSize The source tile size.
+     * @param {Array} sourceSamples The source samples.
+     * @return {import("../DataTile.js").Data} The composed tile data.
+     * @private
+     */
+    private composeTile_;
 }
 import DataTile from "./DataTile.js";
 //# sourceMappingURL=GeoTIFF.d.ts.map

package/source/GeoTIFF.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeoTIFF.d.ts","sourceRoot":"","sources":["GeoTIFF.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA6Cc,MAAM;;;;wBACN,MAAM;;;;4BACN,MAAM;;;;6BACN,MAAM;;;;6BACN,MAAM;;;;0BACN,MAAM;;;;2BACN,MAAM;;;;2BACN,MAAM;;sBAIP,OAAO,SAAS,EAAE,OAAO;2BAIzB,OAAO,SAAS,EAAE,YAAY;;;;;wBAK7B,MAAM;;;;wBACN,MAAM;;2BAOP,OAAO,SAAS,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoO7B,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhB/B;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAmGjB;IAtFC;;;OAGG;IACH,oBAAkC;IAIlC;;;OAGG;IACH,uBAA2C;IAE3C;;;OAGG;IACH,uBAA2C;IAE3C;;;OAGG;IACH,2BAA+C;IAE/C;;;OAGG;IACH,yBAAqB;IAErB;;;OAGG;IACH,sBAAkB;IAElB;;;OAGG;IACH,kBAAc;IAEd;;;OAGG;IACH,mBAA6C;IAE7C;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,eAAkB;IAElB;;OAEG;IACH,aAFU,aAAa,GAAG,SAAS,CAEgC;IAuBrE;;;;;;;;;;;OAWG;IACH,YAXY,KAAK,CAahB;IAED;;;;;;OAMG;IACH,mBA2MC;IAED,sEAwJC;CACF"}
+{"version":3,"file":"GeoTIFF.d.ts","sourceRoot":"","sources":["GeoTIFF.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmFc,MAAM;;;;wBACN,MAAM;;;;4BACN,MAAM;;;;6BACN,MAAM;;;;6BACN,MAAM;;;;0BACN,MAAM;;;;2BACN,MAAM;;;;2BACN,MAAM;;sBAIP,OAAO,SAAS,EAAE,OAAO;2BAIzB,OAAO,SAAS,EAAE,YAAY;;;;;wBAK7B,MAAM;;;;wBACN,MAAM;;2BAOP,OAAO,SAAS,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoO7B,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhB/B;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAyGjB;IA5FC;;;OAGG;IACH,oBAAkC;IAIlC;;;OAGG;IACH,uBAA2C;IAE3C;;;OAGG;IACH,uBAA2C;IAE3C;;;OAGG;IACH,qBAAyC;IAEzC;;;OAGG;IACH,2BAA+C;IAE/C;;;OAGG;IACH,yBAAqB;IAErB;;;OAGG;IACH,sBAAkB;IAElB;;;OAGG;IACH,kBAAc;IAEd;;;OAGG;IACH,mBAA6C;IAE7C;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,eAAkB;IAElB;;OAEG;IACH,eAFU,IAAI,GAAC,KAAK,GAAC,MAAM,CAEuB;IAuBpD;;;;;;;;;;;OAWG;IACH,YAXY,KAAK,CAahB;IAED;;;;;;OAMG;IACH,mBAoOC;IAED;;;;;;OAMG;IACH,kBA6EC;IAED;;;;;OAKG;IACH,qBA4GC;CACF"}

package/source/GeoTIFF.js

@@ -5,6 +5,7 @@ import DataTile from './DataTile.js';
 import TileGrid from '../tilegrid/TileGrid.js';
 import {
   Pool,
+  globals as geotiffGlobals,
   fromBlob as tiffFromBlob,
   fromUrl as tiffFromUrl,
   fromUrls as tiffFromUrls,
@@ -19,6 +20,43 @@ import {clamp} from '../math.js';
 import {getCenter, getIntersection} from '../extent.js';
 import {fromCode as unitsFromCode} from '../proj/Units.js';
 
+/**
+ * Determine if an image type is a mask.
+ * See https://www.awaresystems.be/imaging/tiff/tifftags/newsubfiletype.html
+ * @param {GeoTIFFImage} image The image.
+ * @return {boolean} The image is a mask.
+ */
+function isMask(image) {
+  const fileDirectory = image.fileDirectory;
+  const type = fileDirectory.NewSubfileType || 0;
+  return (type & 4) === 4;
+}
+
+/**
+ * @param {true|false|'auto'} preference The convertToRGB option.
+ * @param {GeoTIFFImage} image The image.
+ * @return {boolean} Use the `image.readRGB()` method.
+ */
+function readRGB(preference, image) {
+  if (!preference) {
+    return false;
+  }
+  if (preference === true) {
+    return true;
+  }
+  if (image.getSamplesPerPixel() !== 3) {
+    return false;
+  }
+  const interpretation = image.fileDirectory.PhotometricInterpretation;
+  const interpretations = geotiffGlobals.photometricInterpretations;
+  return (
+    interpretation === interpretations.CMYK ||
+    interpretation === interpretations.YCbCr ||
+    interpretation === interpretations.CIELab ||
+    interpretation === interpretations.ICCLab
+  );
+}
+
 /**
  * @typedef {Object} SourceInfo
  * @property {string} [url] URL for the source GeoTIFF.
@@ -308,9 +346,10 @@ function getMaxForDataType(array) {
  * another with 1 band, the resulting data tiles will have 5 bands: 3 from the first source, 1 alpha
  * band from the first source, and 1 band from the second source.
  * @property {GeoTIFFSourceOptions} [sourceOptions] Additional options to be passed to [geotiff.js](https://geotiffjs.github.io/geotiff.js/module-geotiff.html)'s `fromUrl` or `fromUrls` methods.
- * @property {boolean} [convertToRGB = false] By default, bands from the sources are read as-is. When
+ * @property {true|false|'auto'} [convertToRGB=false] By default, bands from the sources are read as-is. When
  * reading GeoTIFFs with the purpose of displaying them as RGB images, setting this to `true` will
- * convert other color spaces (YCbCr, CMYK) to RGB.
+ * convert other color spaces (YCbCr, CMYK) to RGB.  Setting the option to `'auto'` will make it so CMYK, YCbCr,
+ * CIELab, and ICCLab images will automatically be converted to RGB.
  * @property {boolean} [normalize=true] By default, the source data is normalized to values between
  * 0 and 1 with scaling factors based on the raster statistics or `min` and `max` properties of each source.
  * If instead you want to work with the raw values in a style expression, set this to `false`.  Setting this option
@@ -363,6 +402,12 @@ class GeoTIFFSource extends DataTile {
      */
     this.sourceImagery_ = new Array(numSources);
 
+    /**
+     * @type {Array<Array<GeoTIFFImage>>}
+     * @private
+     */
+    this.sourceMasks_ = new Array(numSources);
+
     /**
      * @type {Array<number>}
      * @private
@@ -406,9 +451,9 @@ class GeoTIFFSource extends DataTile {
     this.error_ = null;
 
     /**
-     * @type {'readRasters' | 'readRGB'}
+     * @type {true|false|'auto'}
      */
-    this.readMethod_ = options.convertToRGB ? 'readRGB' : 'readRasters';
+    this.convertToRGB_ = options.convertToRGB || false;
 
     this.setKey(this.sourceInfo_.map((source) => source.url).join(','));
 
@@ -467,8 +512,22 @@ class GeoTIFFSource extends DataTile {
 
     const sourceCount = sources.length;
     for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) {
-      const images = sources[sourceIndex];
+      const images = [];
+      const masks = [];
+      sources[sourceIndex].forEach((item) => {
+        if (isMask(item)) {
+          masks.push(item);
+        } else {
+          images.push(item);
+        }
+      });
+
       const imageCount = images.length;
+      if (masks.length > 0 && masks.length !== imageCount) {
+        throw new Error(
+          `Expected one mask per image found ${masks.length} masks and ${imageCount} images`
+        );
+      }
 
       let sourceExtent;
       let sourceOrigin;
@@ -574,6 +633,7 @@ class GeoTIFFSource extends DataTile {
       }
 
       this.sourceImagery_[sourceIndex] = images.reverse();
+      this.sourceMasks_[sourceIndex] = masks.reverse();
     }
 
     for (let i = 0, ii = this.sourceImagery_.length; i < ii; ++i) {
@@ -606,6 +666,10 @@ class GeoTIFFSource extends DataTile {
         this.addAlpha_ = true;
         break;
       }
+      if (this.sourceMasks_[sourceIndex].length) {
+        this.addAlpha_ = true;
+        break;
+      }
 
       const values = nodataValues[sourceIndex];
 
@@ -630,12 +694,11 @@ class GeoTIFFSource extends DataTile {
       }
     }
 
-    const additionalBands = this.addAlpha_ ? 1 : 0;
-    this.bandCount =
-      samplesPerPixel.reduce((accumulator, value) => {
-        accumulator += value;
-        return accumulator;
-      }, 0) + additionalBands;
+    let bandCount = this.addAlpha_ ? 1 : 0;
+    for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) {
+      bandCount += samplesPerPixel[sourceIndex];
+    }
+    this.bandCount = bandCount;
 
     const tileGrid = new TileGrid({
       extent: extent,
@@ -650,24 +713,36 @@ class GeoTIFFSource extends DataTile {
 
     this.setLoader(this.loadTile_.bind(this));
     this.setState('ready');
+
+    let zoom = 0;
+    if (resolutions.length === 1) {
+      resolutions = [resolutions[0] * 2, resolutions[0]];
+      zoom = 1;
+    }
     this.viewResolver({
+      showFullExtent: true,
       projection: this.projection,
       resolutions: resolutions,
       center: toUserCoordinate(getCenter(extent), this.projection),
       extent: toUserExtent(extent, this.projection),
-      zoom: 0,
+      zoom: zoom,
     });
   }
 
+  /**
+   * @param {number} z The z tile index.
+   * @param {number} x The x tile index.
+   * @param {number} y The y tile index.
+   * @return {Promise} The composed tile data.
+   * @private
+   */
   loadTile_(z, x, y) {
     const sourceTileSize = this.getTileSize(z);
     const sourceCount = this.sourceImagery_.length;
-    const requests = new Array(sourceCount);
-    const addAlpha = this.addAlpha_;
-    const bandCount = this.bandCount;
-    const samplesPerPixel = this.samplesPerPixel_;
+    const requests = new Array(sourceCount * 2);
     const nodataValues = this.nodataValues_;
     const sourceInfo = this.sourceInfo_;
+    const pool = getWorkerPool();
     for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) {
       const source = sourceInfo[sourceIndex];
       const resolutionFactor = this.resolutionFactors_[sourceIndex];
@@ -699,118 +774,161 @@ class GeoTIFFSource extends DataTile {
         }
       }
 
-      requests[sourceIndex] = image[this.readMethod_]({
+      const readOptions = {
         window: pixelBounds,
         width: sourceTileSize[0],
         height: sourceTileSize[1],
         samples: samples,
         fillValue: fillValue,
-        pool: getWorkerPool(),
+        pool: pool,
+        interleave: false,
+      };
+      if (readRGB(this.convertToRGB_, image)) {
+        requests[sourceIndex] = image.readRGB(readOptions);
+      } else {
+        requests[sourceIndex] = image.readRasters(readOptions);
+      }
+
+      // requests after `sourceCount` are for mask data (if any)
+      const maskIndex = sourceCount + sourceIndex;
+      const mask = this.sourceMasks_[sourceIndex][z];
+      if (!mask) {
+        requests[maskIndex] = Promise.resolve(null);
+        continue;
+      }
+
+      requests[maskIndex] = mask.readRasters({
+        window: pixelBounds,
+        width: sourceTileSize[0],
+        height: sourceTileSize[1],
+        samples: [0],
+        pool: pool,
         interleave: false,
       });
     }
 
+    return Promise.all(requests)
+      .then(this.composeTile_.bind(this, sourceTileSize))
+      .catch(function (error) {
+        console.error(error); // eslint-disable-line no-console
+        throw error;
+      });
+  }
+
+  /**
+   * @param {import("../size.js").Size} sourceTileSize The source tile size.
+   * @param {Array} sourceSamples The source samples.
+   * @return {import("../DataTile.js").Data} The composed tile data.
+   * @private
+   */
+  composeTile_(sourceTileSize, sourceSamples) {
+    const metadata = this.metadata_;
+    const sourceInfo = this.sourceInfo_;
+    const sourceCount = this.sourceImagery_.length;
+    const bandCount = this.bandCount;
+    const samplesPerPixel = this.samplesPerPixel_;
+    const nodataValues = this.nodataValues_;
+    const normalize = this.normalize_;
+    const addAlpha = this.addAlpha_;
+
     const pixelCount = sourceTileSize[0] * sourceTileSize[1];
     const dataLength = pixelCount * bandCount;
-    const normalize = this.normalize_;
-    const metadata = this.metadata_;
 
-    return Promise.all(requests)
-      .then(function (sourceSamples) {
-        /** @type {Uint8Array|Float32Array} */
-        let data;
-        if (normalize) {
-          data = new Uint8Array(dataLength);
-        } else {
-          data = new Float32Array(dataLength);
-        }
+    /** @type {Uint8Array|Float32Array} */
+    let data;
+    if (normalize) {
+      data = new Uint8Array(dataLength);
+    } else {
+      data = new Float32Array(dataLength);
+    }
 
-        let dataIndex = 0;
-        for (let pixelIndex = 0; pixelIndex < pixelCount; ++pixelIndex) {
-          let transparent = addAlpha;
-          for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) {
-            const source = sourceInfo[sourceIndex];
-
-            let min = source.min;
-            let max = source.max;
-            let gain, bias;
-            if (normalize) {
-              const stats = metadata[sourceIndex][0];
-              if (min === undefined) {
-                if (stats && STATISTICS_MINIMUM in stats) {
-                  min = parseFloat(stats[STATISTICS_MINIMUM]);
-                } else {
-                  min = getMinForDataType(sourceSamples[sourceIndex][0]);
-                }
-              }
-              if (max === undefined) {
-                if (stats && STATISTICS_MAXIMUM in stats) {
-                  max = parseFloat(stats[STATISTICS_MAXIMUM]);
-                } else {
-                  max = getMaxForDataType(sourceSamples[sourceIndex][0]);
-                }
-              }
+    let dataIndex = 0;
+    for (let pixelIndex = 0; pixelIndex < pixelCount; ++pixelIndex) {
+      let transparent = addAlpha;
+      for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) {
+        const source = sourceInfo[sourceIndex];
 
-              gain = 255 / (max - min);
-              bias = -min * gain;
+        let min = source.min;
+        let max = source.max;
+        let gain, bias;
+        if (normalize) {
+          const stats = metadata[sourceIndex][0];
+          if (min === undefined) {
+            if (stats && STATISTICS_MINIMUM in stats) {
+              min = parseFloat(stats[STATISTICS_MINIMUM]);
+            } else {
+              min = getMinForDataType(sourceSamples[sourceIndex][0]);
+            }
+          }
+          if (max === undefined) {
+            if (stats && STATISTICS_MAXIMUM in stats) {
+              max = parseFloat(stats[STATISTICS_MAXIMUM]);
+            } else {
+              max = getMaxForDataType(sourceSamples[sourceIndex][0]);
             }
+          }
 
-            for (
-              let sampleIndex = 0;
-              sampleIndex < samplesPerPixel[sourceIndex];
-              ++sampleIndex
-            ) {
-              const sourceValue =
-                sourceSamples[sourceIndex][sampleIndex][pixelIndex];
+          gain = 255 / (max - min);
+          bias = -min * gain;
+        }
 
-              let value;
-              if (normalize) {
-                value = clamp(gain * sourceValue + bias, 0, 255);
-              } else {
-                value = sourceValue;
-              }
+        for (
+          let sampleIndex = 0;
+          sampleIndex < samplesPerPixel[sourceIndex];
+          ++sampleIndex
+        ) {
+          const sourceValue =
+            sourceSamples[sourceIndex][sampleIndex][pixelIndex];
+
+          let value;
+          if (normalize) {
+            value = clamp(gain * sourceValue + bias, 0, 255);
+          } else {
+            value = sourceValue;
+          }
 
-              if (!addAlpha) {
-                data[dataIndex] = value;
+          if (!addAlpha) {
+            data[dataIndex] = value;
+          } else {
+            let nodata = source.nodata;
+            if (nodata === undefined) {
+              let bandIndex;
+              if (source.bands) {
+                bandIndex = source.bands[sampleIndex] - 1;
               } else {
-                let nodata = source.nodata;
-                if (nodata === undefined) {
-                  let bandIndex;
-                  if (source.bands) {
-                    bandIndex = source.bands[sampleIndex] - 1;
-                  } else {
-                    bandIndex = sampleIndex;
-                  }
-                  nodata = nodataValues[sourceIndex][bandIndex];
-                }
-
-                const nodataIsNaN = isNaN(nodata);
-                if (
-                  (!nodataIsNaN && sourceValue !== nodata) ||
-                  (nodataIsNaN && !isNaN(sourceValue))
-                ) {
-                  transparent = false;
-                  data[dataIndex] = value;
-                }
+                bandIndex = sampleIndex;
               }
-              dataIndex++;
+              nodata = nodataValues[sourceIndex][bandIndex];
             }
-          }
-          if (addAlpha) {
-            if (!transparent) {
-              data[dataIndex] = 255;
+
+            const nodataIsNaN = isNaN(nodata);
+            if (
+              (!nodataIsNaN && sourceValue !== nodata) ||
+              (nodataIsNaN && !isNaN(sourceValue))
+            ) {
+              transparent = false;
+              data[dataIndex] = value;
             }
-            dataIndex++;
+          }
+          dataIndex++;
+        }
+        if (!transparent) {
+          const maskIndex = sourceCount + sourceIndex;
+          const mask = sourceSamples[maskIndex];
+          if (mask && !mask[0][pixelIndex]) {
+            transparent = true;
           }
         }
+      }
+      if (addAlpha) {
+        if (!transparent) {
+          data[dataIndex] = 255;
+        }
+        dataIndex++;
+      }
+    }
 
-        return data;
-      })
-      .catch(function (error) {
-        // output then rethrow
-        console.error(error); // eslint-disable-line no-console
-        throw error;
-      });
+    return data;
   }
 }
 

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '7.0.1-dev.1661646168074';
+export const VERSION = '7.0.1-dev.1661715723847';