@cogeotiff/core 9.2.0 → 9.4.0

package/src/read/tiff.tag.factory.ts

@@ -5,6 +5,7 @@ import type { Tiff } from '../tiff.js';
 import { getUint, getUint64 } from '../util/bytes.js';
 import type { DataViewOffset } from './data.view.offset.js';
 import { hasBytes } from './data.view.offset.js';
+import { isLittleEndian } from './endian.js';
 import type { Tag, TagLazy, TagOffset } from './tiff.tag.js';
 import { getTiffTagSize } from './tiff.value.reader.js';
 
@@ -57,6 +58,42 @@ function readTagValue(
   }
 }
 
+/**
+ * Convert a tiff tag value to a typed array if the local endian matches the tiff endian
+ *
+ * @param tiff
+ * @param bytes
+ * @param offset Offset in the data view to read from
+ * @param length Number of bytes to read
+ * @param type type of tiff tag
+ * @returns the value if the type is a typed array and the endianness matches otherwise null
+ */
+export function readTypedValue<T>(
+  tiff: Tiff,
+  bytes: DataView,
+  offset: number,
+  length: number,
+  type: TiffTagValueType,
+): T | null {
+  switch (type) {
+    case TiffTagValueType.Uint8:
+      return new Uint8Array(
+        bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length),
+      ) as unknown as T;
+    case TiffTagValueType.Uint16:
+      if (tiff.isLittleEndian !== isLittleEndian) return null;
+      return new Uint16Array(
+        bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length),
+      ) as unknown as T;
+    case TiffTagValueType.Uint32:
+      if (tiff.isLittleEndian !== isLittleEndian) return null;
+      return new Uint32Array(
+        bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length),
+      ) as unknown as T;
+  }
+  return null;
+}
+
 function readValue<T>(
   tiff: Tiff,
   tagId: TiffTag | undefined,
@@ -84,6 +121,17 @@ function readValue<T>(
       ) as unknown as T;
   }
 
+  // TODO should we convert all tag values to typed arrays if possible?
+  if (
+    tagId === TiffTag.TileOffsets ||
+    tagId === TiffTag.TileByteCounts ||
+    tagId === TiffTag.StripOffsets ||
+    tagId === TiffTag.StripByteCounts
+  ) {
+    const typedOutput = readTypedValue(tiff, bytes, offset, dataLength, type);
+    if (typedOutput) return typedOutput as unknown as T;
+  }
+
   const output = [];
   for (let i = 0; i < dataLength; i += typeSize) {
     output.push(readTagValue(type, bytes, offset + i, tiff.isLittleEndian));
@@ -133,8 +181,17 @@ export function createTag(tiff: Tiff, view: DataViewOffset, offset: number): Tag
         value: [],
         tagOffset: offset,
       };
-      // Some offsets are quite long and don't need to read them often, so only read the tags we are interested in when we need to
-      if (tagId === TiffTag.TileOffsets && hasBytes(view, dataOffset, dataLength)) setBytes(tag, view);
+
+      if (hasBytes(view, dataOffset, dataLength)) {
+        const val = readTypedValue(tiff, view, dataOffset - view.sourceOffset, dataLength, dataType);
+        if (val) {
+          tag.value = val as number[] | Uint32Array | Uint16Array;
+          tag.isLoaded = true;
+        } else {
+          setBytes(tag, view);
+        }
+      }
+
       return tag;
   }
 
@@ -161,7 +218,7 @@ export async function fetchLazy<T>(tag: TagLazy<T>, tiff: Tiff): Promise<T> {
 /**
  * Fetch all the values from a {@link TagOffset}
  */
-export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<number[]> {
+export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<TagOffset['value']> {
   const dataTypeSize = getTiffTagSize(tag.dataType);
 
   if (tag.view == null) {
@@ -171,6 +228,7 @@ export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<numbe
   }
 
   tag.value = readValue(tiff, tag.id, tag.view, 0, tag.dataType, tag.count);
+  tag.view = undefined;
   tag.isLoaded = true;
   return tag.value;
 }
@@ -204,3 +262,15 @@ export async function getValueAt(tiff: Tiff, tag: TagOffset, index: number): Pro
   tag.value[index] = value;
   return value;
 }
+
+export function getValueAtSync(tiff: Tiff, tag: TagOffset, index: number): number | null {
+  if (index > tag.count || index < 0) throw new Error('TagOffset: out of bounds :' + index);
+  if (tag.value[index] != null) return tag.value[index];
+  if (tag.view == null) return null;
+  const dataTypeSize = getTiffTagSize(tag.dataType);
+
+  const value = readValue(tiff, undefined, tag.view, index * dataTypeSize, tag.dataType, 1);
+  if (typeof value !== 'number') throw new Error('Value is not a number');
+  tag.value[index] = value;
+  return value;
+}

package/src/read/tiff.tag.ts

@@ -38,7 +38,7 @@ export interface TagInline<T> extends TagBase {
 export interface TagOffset extends TagBase {
   type: 'offset';
   /** Values of the offsets this is a sparse array unless @see {TagOffset.isLoaded} is true */
-  value: number[];
+  value: number[] | Uint32Array | Uint16Array;
   /** Have all the values been read */
   isLoaded: boolean;
   /** Raw buffer of the values for lazy decoding, as reading 100,000s of uint64s can take quite a long time */

package/src/tiff.image.ts

@@ -1,7 +1,7 @@
 import { getCompressionMimeType, TiffCompressionMimeType, TiffMimeType } from './const/tiff.mime.js';
 import type { TiffTagGeoType, TiffTagType } from './const/tiff.tag.id.js';
 import { Compression, ModelTypeCode, SubFileType, TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
-import { fetchAllOffsets, fetchLazy, getValueAt } from './read/tiff.tag.factory.js';
+import { fetchAllOffsets, fetchLazy, getValueAt, getValueAtSync } from './read/tiff.tag.factory.js';
 import type { Tag, TagInline, TagOffset } from './read/tiff.tag.js';
 import type { Tiff } from './tiff.js';
 import { getUint } from './util/bytes.js';
@@ -556,15 +556,25 @@ export class TiffImage {
 
   /**
    * Load the offset and byteCount of a tile
+   *
+   * if the tiff is sparse, offset and byteCount will be zero if the tile is empty
+   *
    * @param index index in the tile array
    * @returns Offset and byteCount for the tile
    */
   async getTileSize(index: number): Promise<{ offset: number; imageSize: number }> {
+    // If both the tile offset and tile byte counts are loaded,
+    // we can get the offset and byte count synchronously without needing to fetch any additional data
+    const byteCounts = this.tags.get(TiffTag.TileByteCounts) as TagOffset | TagInline<number[]>;
+    const tileOffset = getOffsetSync(this.tiff, this.tileOffset, index);
+    const tileSize = getOffsetSync(this.tiff, byteCounts, index);
+    if (tileOffset != null && tileSize != null) return { offset: tileOffset, imageSize: tileSize };
+
     // GDAL optimizes tiles by storing the size of the tile in
     // the few bytes leading up to the tile
     const leaderBytes = this.tiff.options?.tileLeaderByteSize;
     if (leaderBytes) {
-      const offset = await getOffset(this.tiff, this.tileOffset, index);
+      const offset = tileOffset ?? (await getOffset(this.tiff, this.tileOffset, index));
       // Sparse tiff no data found
       if (offset === 0) return { offset: 0, imageSize: 0 };
 
@@ -574,22 +584,29 @@ export class TiffImage {
       return { offset, imageSize: getUint(new DataView(bytes), 0, leaderBytes, this.tiff.isLittleEndian) };
     }
 
-    const byteCounts = this.tags.get(TiffTag.TileByteCounts) as TagOffset;
     if (byteCounts == null) throw new Error('No tile byte counts found');
     const [offset, imageSize] = await Promise.all([
-      getOffset(this.tiff, this.tileOffset, index),
-      getOffset(this.tiff, byteCounts, index),
+      tileOffset ?? getOffset(this.tiff, this.tileOffset, index),
+      tileSize ?? getOffset(this.tiff, byteCounts, index),
     ]);
     return { offset, imageSize };
   }
 }
 
 function getOffset(tiff: Tiff, x: TagOffset | TagInline<number[]>, index: number): number | Promise<number> {
+  const val = getOffsetSync(tiff, x, index);
+  if (val != null) return Promise.resolve(val);
+  return getValueAt(tiff, x as TagOffset, index);
+}
+
+function getOffsetSync(tiff: Tiff, x: TagOffset | TagInline<number[]>, index: number): number | null {
   if (index < 0) {
     throw new Error(`Tiff: ${tiff.source.url.href} out of bounds ${TiffTag[x.id]} index:${index} total:${x.count}`);
   }
   // Sparse tiffs may not have the full tileWidth * tileHeight in their offset arrays
   if (index >= x.count) return 0;
   if (x.type === 'inline') return x.value[index];
-  return getValueAt(tiff, x, index);
+  if (x.isLoaded) return x.value[index];
+
+  return getValueAtSync(tiff, x, index);
 }

package/src/tiff.ts

@@ -13,6 +13,11 @@ import { TiffImage } from './tiff.image.js';
 import { getUint } from './util/bytes.js';
 import { toHex } from './util/util.hex.js';
 
+export interface TiffCreationOptions {
+  /** When initializing the tiff, read data in blocks of this size (in KB) */
+  defaultReadSize: number;
+}
+
 export class Tiff {
   /** Read 16KB blocks at a time */
   static DefaultReadSize = 16 * 1024;
@@ -36,13 +41,17 @@ export class Tiff {
   private _initPromise?: Promise<Tiff>;
 
   /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
-  constructor(source: Source) {
+  constructor(source: Source, options: TiffCreationOptions = { defaultReadSize: Tiff.DefaultReadSize }) {
     this.source = source;
+    this.defaultReadSize = options.defaultReadSize;
   }
 
   /** Create a tiff and initialize it by reading the tiff headers */
-  static create(source: Source): Promise<Tiff> {
-    return new Tiff(source).init();
+  static create(
+    source: Source,
+    options: TiffCreationOptions = { defaultReadSize: Tiff.DefaultReadSize },
+  ): Promise<Tiff> {
+    return new Tiff(source, options).init();
   }
 
   /**