ol 7.0.1-dev.1661609353651 → 7.0.1-dev.1661713055938

package/README.md

@@ -23,7 +23,7 @@ new Map({
   layers: [
     new TileLayer({
       source: new XYZ({
-        url: 'https://{a-c}.tile.openstreetmap.org/{z}/{x}/{y}.png'
+        url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png'
       })
     })
   ],

package/package.json

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

package/source/GeoTIFF.d.ts

@@ -233,6 +233,11 @@ declare class GeoTIFFSource extends DataTile {
      * @private
      */
     private sourceImagery_;
+    /**
+     * @type {Array<Array<GeoTIFFImage>>}
+     * @private
+     */
+    private sourceMasks_;
     /**
      * @type {Array<number>}
      * @private
@@ -293,7 +298,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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAyDc,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,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,aAFU,aAAa,GAAG,SAAS,CAEgC;IAuBrE;;;;;;;;;;;OAWG;IACH,YAXY,KAAK,CAahB;IAED;;;;;;OAMG;IACH,mBAoOC;IAED;;;;;;OAMG;IACH,kBAwEC;IAED;;;;;OAKG;IACH,qBA4GC;CACF"}

package/source/GeoTIFF.js

@@ -19,6 +19,18 @@ 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;
+}
+
 /**
  * @typedef {Object} SourceInfo
  * @property {string} [url] URL for the source GeoTIFF.
@@ -363,6 +375,12 @@ class GeoTIFFSource extends DataTile {
      */
     this.sourceImagery_ = new Array(numSources);
 
+    /**
+     * @type {Array<Array<GeoTIFFImage>>}
+     * @private
+     */
+    this.sourceMasks_ = new Array(numSources);
+
     /**
      * @type {Array<number>}
      * @private
@@ -467,8 +485,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 +606,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 +639,10 @@ class GeoTIFFSource extends DataTile {
         this.addAlpha_ = true;
         break;
       }
+      if (this.sourceMasks_[sourceIndex].length) {
+        this.addAlpha_ = true;
+        break;
+      }
 
       const values = nodataValues[sourceIndex];
 
@@ -630,12 +667,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 +686,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];
@@ -705,112 +753,150 @@ class GeoTIFFSource extends DataTile {
         height: sourceTileSize[1],
         samples: samples,
         fillValue: fillValue,
-        pool: getWorkerPool(),
+        pool: pool,
+        interleave: false,
+      });
+
+      // 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/source/OSM.d.ts

@@ -90,7 +90,7 @@ export type Options = {
  * ```
  * @property {number} [transition=250] Duration of the opacity transition for rendering.
  * To disable the opacity transition, pass `transition: 0`.
- * @property {string} [url='https://{a-c}.tile.openstreetmap.org/{z}/{x}/{y}.png'] URL template.
+ * @property {string} [url='https://tile.openstreetmap.org/{z}/{x}/{y}.png'] URL template.
  * Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.
  * @property {boolean} [wrapX=true] Whether to wrap the world horizontally.
  * @property {number|import("../array.js").NearestDirectionFunction} [zDirection=0]

package/source/OSM.js

@@ -37,7 +37,7 @@ export const ATTRIBUTION =
  * ```
  * @property {number} [transition=250] Duration of the opacity transition for rendering.
  * To disable the opacity transition, pass `transition: 0`.
- * @property {string} [url='https://{a-c}.tile.openstreetmap.org/{z}/{x}/{y}.png'] URL template.
+ * @property {string} [url='https://tile.openstreetmap.org/{z}/{x}/{y}.png'] URL template.
  * Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.
  * @property {boolean} [wrapX=true] Whether to wrap the world horizontally.
  * @property {number|import("../array.js").NearestDirectionFunction} [zDirection=0]
@@ -70,7 +70,7 @@ class OSM extends XYZ {
     const url =
       options.url !== undefined
         ? options.url
-        : 'https://{a-c}.tile.openstreetmap.org/{z}/{x}/{y}.png';
+        : 'https://tile.openstreetmap.org/{z}/{x}/{y}.png';
 
     super({
       attributions: attributions,

package/util.js

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