@cogeotiff/core 8.0.1 → 8.0.2

package/src/cog.tiff.image.ts

@@ -1,7 +1,7 @@
 import { getUint } from './util/bytes.js';
 import { CogTiff } from './cog.tiff.js';
 import { TiffCompression, TiffMimeType } from './const/tiff.mime.js';
-import { TagId, TagGeoId } from './const/tiff.tag.id.js';
+import { TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
 import { Tag, TagInline, TagOffset } from './read/tiff.tag.js';
 import { BoundingBox, Size } from './vector.js';
 import { fetchLazy, getValueAt } from './read/tiff.tag.factory.js';
@@ -21,18 +21,18 @@ export interface CogTiffImageTiledCount {
 
 /** Tags that are commonly accessed for geotiffs */
 export const ImportantTags = new Set([
-  TagId.Compression,
-  TagId.ImageHeight,
-  TagId.ImageWidth,
-  TagId.ModelPixelScale,
-  TagId.ModelTiePoint,
-  TagId.ModelTransformation,
-  TagId.TileHeight,
-  TagId.TileWidth,
-  TagId.GeoKeyDirectory,
-  TagId.GeoAsciiParams,
-  TagId.GeoDoubleParams,
-  TagId.TileOffsets,
+  TiffTag.Compression,
+  TiffTag.ImageHeight,
+  TiffTag.ImageWidth,
+  TiffTag.ModelPixelScale,
+  TiffTag.ModelTiePoint,
+  TiffTag.ModelTransformation,
+  TiffTag.TileHeight,
+  TiffTag.TileWidth,
+  TiffTag.GeoKeyDirectory,
+  TiffTag.GeoAsciiParams,
+  TiffTag.GeoDoubleParams,
+  TiffTag.TileOffsets,
 ]);
 
 /**
@@ -47,7 +47,7 @@ export interface CogTiffImageTileSize {
 
 export class CogTiffImage {
   /** All IFD tags that have been read for the image */
-  tags: Map<TagId, Tag>;
+  tags: Map<TiffTag, Tag>;
 
   /** Id of the tif image, generally the image index inside the tif */
   id: number;
@@ -57,9 +57,9 @@ export class CogTiffImage {
   /** Has loadGeoTiffTags been called */
   isGeoTagsLoaded = false;
   /** Sub tags stored in TiffTag.GeoKeyDirectory */
-  tagsGeo: Map<TagGeoId, string | number> = new Map();
+  tagsGeo: Map<TiffTagGeo, string | number> = new Map();
 
-  constructor(tiff: CogTiff, id: number, tags: Map<TagId, Tag>) {
+  constructor(tiff: CogTiff, id: number, tags: Map<TiffTag, Tag>) {
     this.tiff = tiff;
     this.id = id;
     this.tags = tags;
@@ -72,20 +72,20 @@ export class CogTiffImage {
    */
   async init(loadGeoTags = true): Promise<void> {
     const requiredTags = [
-      this.fetch(TagId.Compression),
-      this.fetch(TagId.ImageHeight),
-      this.fetch(TagId.ImageWidth),
-      this.fetch(TagId.ModelPixelScale),
-      this.fetch(TagId.ModelTiePoint),
-      this.fetch(TagId.ModelTransformation),
-      this.fetch(TagId.TileHeight),
-      this.fetch(TagId.TileWidth),
+      this.fetch(TiffTag.Compression),
+      this.fetch(TiffTag.ImageHeight),
+      this.fetch(TiffTag.ImageWidth),
+      this.fetch(TiffTag.ModelPixelScale),
+      this.fetch(TiffTag.ModelTiePoint),
+      this.fetch(TiffTag.ModelTransformation),
+      this.fetch(TiffTag.TileHeight),
+      this.fetch(TiffTag.TileWidth),
     ];
 
     if (loadGeoTags) {
-      requiredTags.push(this.fetch(TagId.GeoKeyDirectory));
-      requiredTags.push(this.fetch(TagId.GeoAsciiParams));
-      requiredTags.push(this.fetch(TagId.GeoDoubleParams));
+      requiredTags.push(this.fetch(TiffTag.GeoKeyDirectory));
+      requiredTags.push(this.fetch(TiffTag.GeoAsciiParams));
+      requiredTags.push(this.fetch(TiffTag.GeoDoubleParams));
     }
 
     await Promise.all(requiredTags);
@@ -95,7 +95,7 @@ export class CogTiffImage {
   /**
    * Get the value of a TiffTag if it exists null otherwise
    */
-  value<T>(tag: TagId): T | null {
+  value<T>(tag: TiffTag): T | null {
     const sourceTag = this.tags.get(tag);
     if (sourceTag == null) return null;
     if (sourceTag.type === 'offset' && sourceTag.isLoaded === false) return null;
@@ -108,7 +108,7 @@ export class CogTiffImage {
   async loadGeoTiffTags(): Promise<void> {
     // Already loaded
     if (this.isGeoTagsLoaded) return;
-    const sourceTag = this.tags.get(TagId.GeoKeyDirectory);
+    const sourceTag = this.tags.get(TiffTag.GeoKeyDirectory);
     if (sourceTag == null) {
       this.isGeoTagsLoaded = true;
       return;
@@ -116,9 +116,9 @@ export class CogTiffImage {
     if (sourceTag.type === 'lazy' && sourceTag.value == null) {
       // Load all the required keys
       await Promise.all([
-        this.fetch(TagId.GeoKeyDirectory),
-        this.fetch(TagId.GeoAsciiParams),
-        this.fetch(TagId.GeoDoubleParams),
+        this.fetch(TiffTag.GeoKeyDirectory),
+        this.fetch(TiffTag.GeoAsciiParams),
+        this.fetch(TiffTag.GeoDoubleParams),
       ]);
     }
     this.isGeoTagsLoaded = true;
@@ -126,7 +126,7 @@ export class CogTiffImage {
     const geoTags = sourceTag.value as Uint16Array;
     if (typeof geoTags === 'number') throw new Error('Invalid geo tags found');
     for (let i = 4; i <= geoTags[3] * 4; i += 4) {
-      const key = geoTags[i] as TagGeoId;
+      const key = geoTags[i] as TiffTagGeo;
       const location = geoTags[i + 1];
 
       const offset = geoTags[i + 3];
@@ -149,7 +149,7 @@ export class CogTiffImage {
   /**
    * Get the associated GeoTiffTags
    */
-  valueGeo(tag: TagGeoId): string | number | undefined {
+  valueGeo(tag: TiffTagGeo): string | number | undefined {
     if (this.isGeoTagsLoaded === false) throw new Error('loadGeoTiffTags() has not been called');
     return this.tagsGeo.get(tag);
   }
@@ -158,7 +158,7 @@ export class CogTiffImage {
    * Load a tag, if it is not currently loaded, fetch the required data for the tag.
    * @param tag tag to fetch
    */
-  public async fetch<T>(tag: TagId): Promise<T | null> {
+  public async fetch<T>(tag: TiffTag): Promise<T | null> {
     const sourceTag = this.tags.get(tag);
     if (sourceTag == null) return null;
     if (sourceTag.type === 'inline') return sourceTag.value as unknown as T;
@@ -173,18 +173,18 @@ export class CogTiffImage {
    * @returns origin point of the image
    */
   get origin(): [number, number, number] {
-    const tiePoints: number[] | null = this.value<number[]>(TagId.ModelTiePoint);
+    const tiePoints: number[] | null = this.value<number[]>(TiffTag.ModelTiePoint);
     if (tiePoints != null && tiePoints.length === 6) {
       return [tiePoints[3], tiePoints[4], tiePoints[5]];
     }
 
-    const modelTransformation = this.value<number[]>(TagId.ModelTransformation);
+    const modelTransformation = this.value<number[]>(TiffTag.ModelTransformation);
     if (modelTransformation != null) {
       return [modelTransformation[3], modelTransformation[7], modelTransformation[11]];
     }
 
     // If this is a sub image, use the origin from the top level image
-    if (this.value(TagId.NewSubFileType) === 1 && this.id !== 0) {
+    if (this.value(TiffTag.NewSubFileType) === 1 && this.id !== 0) {
       return this.tiff.images[0].origin;
     }
 
@@ -193,10 +193,11 @@ export class CogTiffImage {
 
   /** Is there enough geo information on this image to figure out where its actually located */
   get isGeoLocated(): boolean {
-    const isImageLocated = this.value(TagId.ModelPixelScale) != null || this.value(TagId.ModelTransformation) != null;
+    const isImageLocated =
+      this.value(TiffTag.ModelPixelScale) != null || this.value(TiffTag.ModelTransformation) != null;
     if (isImageLocated) return true;
     // If this is a sub image, use the isGeoLocated from the top level image
-    if (this.value(TagId.NewSubFileType) === 1 && this.id !== 0) return this.tiff.images[0].isGeoLocated;
+    if (this.value(TiffTag.NewSubFileType) === 1 && this.id !== 0) return this.tiff.images[0].isGeoLocated;
     return false;
   }
 
@@ -206,17 +207,17 @@ export class CogTiffImage {
    * @returns [x,y,z] pixel scale
    */
   get resolution(): [number, number, number] {
-    const modelPixelScale: number[] | null = this.value(TagId.ModelPixelScale);
+    const modelPixelScale: number[] | null = this.value(TiffTag.ModelPixelScale);
     if (modelPixelScale != null) {
       return [modelPixelScale[0], -modelPixelScale[1], modelPixelScale[2]];
     }
-    const modelTransformation: number[] | null = this.value(TagId.ModelTransformation);
+    const modelTransformation: number[] | null = this.value(TiffTag.ModelTransformation);
     if (modelTransformation != null) {
       return [modelTransformation[0], modelTransformation[5], modelTransformation[10]];
     }
 
     // If this is a sub image, use the resolution from the top level image
-    if (this.value(TagId.NewSubFileType) === 1 && this.id !== 0) {
+    if (this.value(TiffTag.NewSubFileType) === 1 && this.id !== 0) {
       const firstImg = this.tiff.images[0];
       const [resX, resY, resZ] = firstImg.resolution;
       const firstImgSize = firstImg.size;
@@ -259,7 +260,7 @@ export class CogTiffImage {
    * @returns Compression type eg webp
    */
   get compression(): TiffMimeType | null {
-    const compression = this.value(TagId.Compression);
+    const compression = this.value(TiffTag.Compression);
     if (compression == null || typeof compression !== 'number') return null;
     return TiffCompression[compression];
   }
@@ -270,7 +271,7 @@ export class CogTiffImage {
    * @returns EPSG Code if it exists
    */
   get epsg(): number | null {
-    const projection = this.valueGeo(TagGeoId.ProjectedCSTypeGeoKey) as number;
+    const projection = this.valueGeo(TiffTagGeo.ProjectedCSTypeGeoKey) as number;
     if (projection === InvalidProjectionCode) return null;
     return projection;
   }
@@ -282,8 +283,8 @@ export class CogTiffImage {
    */
   get size(): Size {
     return {
-      width: this.value<number>(TagId.ImageWidth) as number,
-      height: this.value<number>(TagId.ImageHeight) as number,
+      width: this.value<number>(TiffTag.ImageWidth) as number,
+      height: this.value<number>(TiffTag.ImageHeight) as number,
     };
   }
 
@@ -291,7 +292,7 @@ export class CogTiffImage {
    * Determine if this image is tiled
    */
   public isTiled(): boolean {
-    return this.value(TagId.TileWidth) !== null;
+    return this.value(TiffTag.TileWidth) !== null;
   }
 
   /**
@@ -299,8 +300,8 @@ export class CogTiffImage {
    */
   get tileSize(): CogTiffImageTileSize {
     return {
-      width: this.value<number>(TagId.TileWidth) as number,
-      height: this.value<number>(TagId.TileHeight) as number,
+      width: this.value<number>(TiffTag.TileWidth) as number,
+      height: this.value<number>(TiffTag.TileHeight) as number,
     };
   }
 
@@ -323,7 +324,7 @@ export class CogTiffImage {
    * @returns file offset to where the tiffs are stored
    */
   get tileOffset(): TagOffset {
-    const tileOffset = this.tags.get(TagId.TileOffsets) as TagOffset;
+    const tileOffset = this.tags.get(TiffTag.TileOffsets) as TagOffset;
     if (tileOffset == null) throw new Error('No tile offsets found');
     return tileOffset;
   }
@@ -336,7 +337,7 @@ export class CogTiffImage {
    * @returns number of strips present
    */
   get stripCount(): number {
-    const tileOffset = this.tags.get(TagId.StripByteCounts) as TagOffset;
+    const tileOffset = this.tags.get(TiffTag.StripByteCounts) as TagOffset;
     if (tileOffset == null) return 0;
     return tileOffset.count;
   }
@@ -359,8 +360,8 @@ export class CogTiffImage {
   async getStrip(index: number): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer } | null> {
     if (this.isTiled()) throw new Error('Cannot read stripes, tiff is tiled: ' + index);
 
-    const byteCounts = this.tags.get(TagId.StripByteCounts) as TagOffset;
-    const offsets = this.tags.get(TagId.StripOffsets) as TagOffset;
+    const byteCounts = this.tags.get(TiffTag.StripByteCounts) as TagOffset;
+    const offsets = this.tags.get(TiffTag.StripOffsets) as TagOffset;
 
     if (index >= byteCounts.count) throw new Error('Cannot read strip, index out of bounds');
 
@@ -375,7 +376,7 @@ export class CogTiffImage {
   private getJpegHeader(bytes: ArrayBuffer): ArrayBuffer {
     // Both the JPEGTable and the Bytes with have the start of image and end of image markers
     // StartOfImage 0xffd8 EndOfImage 0xffd9
-    const tables = this.value<number[]>(TagId.JPEGTables);
+    const tables = this.value<number[]>(TiffTag.JPEGTables);
     if (tables == null) throw new Error('Unable to find Jpeg header');
 
     // Remove EndOfImage marker
@@ -392,7 +393,7 @@ export class CogTiffImage {
     byteCount: number,
   ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer } | null> {
     const mimeType = this.compression;
-    if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TagId.Compression));
+    if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TiffTag.Compression));
     if (byteCount === 0) return null;
 
     const bytes = await this.tiff.source.fetch(offset, byteCount);
@@ -417,7 +418,7 @@ export class CogTiffImage {
     const tiles = this.tileSize;
 
     if (tiles == null) throw new Error('Tiff is not tiled');
-    if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TagId.Compression));
+    if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TiffTag.Compression));
 
     // TODO support GhostOptionTileOrder
     const nyTiles = Math.ceil(size.height / tiles.height);
@@ -476,7 +477,7 @@ export class CogTiffImage {
       return { offset, imageSize: getUint(new DataView(bytes), 0, leaderBytes, this.tiff.isLittleEndian) };
     }
 
-    const byteCounts = this.tags.get(TagId.TileByteCounts) as TagOffset;
+    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),

package/src/cog.tiff.ts

@@ -1,8 +1,8 @@
 import { CogTiffImage } from './cog.tiff.image.js';
 import { TiffEndian } from './const/tiff.endian.js';
-import { TagId } from './const/tiff.tag.id.js';
+import { TiffTag } from './const/tiff.tag.id.js';
 import { TiffVersion } from './const/tiff.version.js';
-import { TiffTag } from './index.js';
+import { Tag } from './index.js';
 import { DataViewOffset, hasBytes } from './read/data.view.offset.js';
 import { CogTifGhostOptions } from './read/tiff.gdal.js';
 import { TagTiffBigConfig, TagTiffConfig, TiffIfdConfig } from './read/tiff.ifd.config.js';
@@ -141,7 +141,7 @@ export class CogTiff {
     const viewOffset = offset - view.sourceOffset;
     const tagCount = getUint(view, viewOffset, this.ifdConfig.offset, this.isLittleEndian);
 
-    const tags: Map<TagId, TiffTag> = new Map();
+    const tags: Map<TiffTag, Tag> = new Map();
 
     // We now know how many bytes we need so ensure the ifd bytes are all read
     const ifdBytes = tagCount * this.ifdConfig.ifd;

package/src/const/index.ts

@@ -1,5 +1,5 @@
 export { TiffEndian } from './tiff.endian.js';
 export { TiffCompression, TiffMimeType } from './tiff.mime.js';
-export { TagId as TiffTag, TagGeoId as TiffTagGeo } from './tiff.tag.id.js';
+export { TiffTag as TiffTag, TiffTagGeo as TiffTagGeo } from './tiff.tag.id.js';
 export { TiffTagValueType } from './tiff.tag.value.js';
 export { TiffVersion } from './tiff.version.js';

package/src/const/tiff.tag.id.ts

@@ -1,5 +1,5 @@
 // Stolen from geotiff.js
-export enum TagId {
+export enum TiffTag {
   // TIFF Baseline
   Artist = 0x013b,
   BitsPerSample = 0x0102,
@@ -120,7 +120,7 @@ export enum TagId {
   GeoAsciiParams = 0x87b1,
 }
 
-export enum TagGeoId {
+export enum TiffTagGeo {
   GTModelTypeGeoKey = 1024,
   GTRasterTypeGeoKey = 1025,
   GTCitationGeoKey = 1026,

package/src/index.ts

@@ -1,10 +1,10 @@
 export { CogTiff } from './cog.tiff.js';
 export { TiffEndian } from './const/tiff.endian.js';
 export { TiffCompression, TiffMimeType } from './const/tiff.mime.js';
-export { TagGeoId as TiffTagGeo, TagId as TiffTagId } from './const/tiff.tag.id.js';
+export { TiffTagGeo, TiffTag } from './const/tiff.tag.id.js';
 export { TiffTagValueType } from './const/tiff.tag.value.js';
 export { TiffVersion } from './const/tiff.version.js';
-export { TagInline, TagLazy, TagOffset, Tag as TiffTag } from './read/tiff.tag.js';
+export { TagInline, TagLazy, TagOffset, Tag } from './read/tiff.tag.js';
 export { getTiffTagSize } from './read/tiff.value.reader.js';
 export { Source } from './source.js';
 export { toHex } from './util/util.hex.js';

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

@@ -1,5 +1,5 @@
 import { CogTiff } from '../cog.tiff.js';
-import { TagId } from '../const/tiff.tag.id.js';
+import { TiffTag } from '../const/tiff.tag.id.js';
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
 import { getUint, getUint64 } from '../util/bytes.js';
 import { DataViewOffset, hasBytes } from './data.view.offset.js';
@@ -100,10 +100,10 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
 
   const dataOffset = getUint(view, offset + 4 + tiff.ifdConfig.pointer, tiff.ifdConfig.pointer, tiff.isLittleEndian);
   switch (tagId) {
-    case TagId.TileOffsets:
-    case TagId.TileByteCounts:
-    case TagId.StripByteCounts:
-    case TagId.StripOffsets:
+    case TiffTag.TileOffsets:
+    case TiffTag.TileByteCounts:
+    case TiffTag.StripByteCounts:
+    case TiffTag.StripOffsets:
       const tag: TagOffset = {
         type: 'offset',
         id: tagId,
@@ -114,7 +114,7 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
         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 === TagId.TileOffsets && hasBytes(view, dataOffset, dataLength)) setBytes(tag, view);
+      if (tagId === TiffTag.TileOffsets && hasBytes(view, dataOffset, dataLength)) setBytes(tag, view);
       return tag;
   }
 

package/src/read/tiff.tag.ts

@@ -1,12 +1,13 @@
-import { TagId } from '../const/tiff.tag.id.js';
+import { TiffTag } from '../const/tiff.tag.id.js';
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
 import { DataViewOffset } from './data.view.offset.js';
 
+/** Tiff tag interfaces */
 export type Tag<T = unknown> = TagLazy<T> | TagInline<T> | TagOffset;
 
 export interface TagBase {
   /** Id of the Tag */
-  id: TagId;
+  id: TiffTag;
   /** Offset in bytes to where this tag was read from */
   tagOffset: number;
   /** Number of values */
@@ -15,6 +16,7 @@ export interface TagBase {
   dataType: TiffTagValueType;
 }
 
+/** Tiff tag value is not inline and will be loaded later when requested */
 export interface TagLazy<T> extends TagBase {
   type: 'lazy';
   /** Value if loaded undefined otherwise */
@@ -29,6 +31,7 @@ export interface TagInline<T> extends TagBase {
   value: T;
 }
 
+/** Tiff tag that is a list of offsets this can be partially read */
 export interface TagOffset extends TagBase {
   type: 'offset';
   /** Values of the offest's this is a sparse array unless @see {isLoaded} is true */