@cogeotiff/core 6.0.2 → 7.0.0

package/src/cog.tiff.image.ts

@@ -1,4 +1,3 @@
-import { LogType } from '@chunkd/core';
 import { CogTiff } from './cog.tiff.js';
 import { TiffCompression, TiffMimeType } from './const/tiff.mime.js';
 import { TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
@@ -56,27 +55,27 @@ export class CogTiffImage {
      *
      * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
      */
-    async init(loadGeoTags = false, l: LogType = null as any): Promise<void> {
+    async init(loadGeoTags = false): Promise<void> {
         const requiredTags = [
-            this.fetch(TiffTag.Compression, l),
-            this.fetch(TiffTag.ImageHeight, l),
-            this.fetch(TiffTag.ImageWidth, l),
-            this.fetch(TiffTag.ModelPixelScale, l),
-            this.fetch(TiffTag.ModelTiePoint, l),
-            this.fetch(TiffTag.ModelTransformation, l),
-            this.fetch(TiffTag.TileHeight, l),
-            this.fetch(TiffTag.TileWidth, l),
+            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(TiffTag.GeoKeyDirectory, l));
-            requiredTags.push(this.fetch(TiffTag.GeoAsciiParams, l));
-            requiredTags.push(this.fetch(TiffTag.GeoDoubleParams, l));
+            requiredTags.push(this.fetch(TiffTag.GeoKeyDirectory));
+            requiredTags.push(this.fetch(TiffTag.GeoAsciiParams));
+            requiredTags.push(this.fetch(TiffTag.GeoDoubleParams));
         }
 
         await Promise.all(requiredTags);
         if (loadGeoTags) {
-            await this.loadGeoTiffTags(l);
+            await this.loadGeoTiffTags();
         }
     }
 
@@ -92,7 +91,7 @@ export class CogTiffImage {
     /**
      * Load and unpack the GeoKeyDirectory
      */
-    async loadGeoTiffTags(l: LogType): Promise<void> {
+    async loadGeoTiffTags(): Promise<void> {
         // Already loaded
         if (this.tagsGeoLoaded) return;
         const sourceTag = this.tags.get(TiffTag.GeoKeyDirectory);
@@ -103,9 +102,9 @@ export class CogTiffImage {
         if (!sourceTag.isReady && sourceTag instanceof CogTiffTagLazy) {
             // Load all the required keys
             await Promise.all([
-                this.fetch(TiffTag.GeoKeyDirectory, l),
-                this.fetch(TiffTag.GeoAsciiParams, l),
-                this.fetch(TiffTag.GeoDoubleParams, l),
+                this.fetch(TiffTag.GeoKeyDirectory),
+                this.fetch(TiffTag.GeoAsciiParams),
+                this.fetch(TiffTag.GeoDoubleParams),
             ]);
         }
         this.tagsGeoLoaded = true;
@@ -145,10 +144,10 @@ 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: TiffTag, l: LogType): Promise<T | null> {
+    public async fetch<T>(tag: TiffTag): Promise<T | null> {
         const sourceTag = this.tags.get(tag);
         if (sourceTag == null) return null;
-        if (CogTiffTag.isLazy(sourceTag)) return sourceTag.fetch(l) as any;
+        if (CogTiffTag.isLazy(sourceTag)) return sourceTag.fetch() as any;
         return sourceTag.value as T;
     }
 
@@ -270,8 +269,8 @@ export class CogTiffImage {
      */
     get size(): Size {
         return {
-            width: this.value<number>(TiffTag.ImageWidth)!,
-            height: this.value<number>(TiffTag.ImageHeight)!,
+            width: this.value<number>(TiffTag.ImageWidth) as number,
+            height: this.value<number>(TiffTag.ImageHeight) as number,
         };
     }
 
@@ -294,8 +293,8 @@ export class CogTiffImage {
      */
     get tileSize(): CogTiffImageTileSize {
         return {
-            width: this.value<number>(TiffTag.TileWidth)!,
-            height: this.value<number>(TiffTag.TileHeight)!,
+            width: this.value<number>(TiffTag.TileWidth) as number,
+            height: this.value<number>(TiffTag.TileHeight) as number,
         };
     }
 
@@ -342,14 +341,14 @@ export class CogTiffImage {
      * @param index tile index
      * @returns file offset of the specified tile
      */
-    protected async getTileOffset(index: number, l?: LogType): Promise<number> {
+    protected async getTileOffset(index: number): Promise<number> {
         const tileOffset = this.tileOffset;
         if (index < 0 || index > tileOffset.dataCount) {
             throw new Error(`Tile offset: ${index} out of range: 0 -> ${tileOffset.dataCount}`);
         }
 
         // Fetch only the part of the offsets that are needed
-        return tileOffset.getValueAt(index, l);
+        return tileOffset.getValueAt(index);
     }
 
     // Clamp the bounds of the output image to the size of the image, as sometimes the edge tiles are not full tiles
@@ -398,13 +397,12 @@ export class CogTiffImage {
     private async getBytes(
         offset: number,
         byteCount: number,
-        l?: LogType,
     ): Promise<{ mimeType: TiffMimeType; bytes: Uint8Array } | null> {
         const mimeType = this.compression;
         if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TiffTag.Compression));
         if (byteCount === 0) return null;
 
-        await this.tif.source.loadBytes(offset, byteCount, l);
+        await this.tif.source.loadBytes(offset, byteCount);
         const bytes = this.tif.source.bytes(offset, byteCount);
 
         if (this.compression === TiffMimeType.JPEG) {
@@ -421,7 +419,7 @@ export class CogTiffImage {
      * @param x Tile x offset
      * @param y Tile y offset
      */
-    async getTile(x: number, y: number, l?: LogType): Promise<{ mimeType: TiffMimeType; bytes: Uint8Array } | null> {
+    async getTile(x: number, y: number): Promise<{ mimeType: TiffMimeType; bytes: Uint8Array } | null> {
         const mimeType = this.compression;
         const size = this.size;
         const tiles = this.tileSize;
@@ -441,22 +439,22 @@ export class CogTiffImage {
         const totalTiles = nxTiles * nyTiles;
         if (idx >= totalTiles) throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
 
-        const { offset, imageSize } = await this.getTileSize(idx, l);
-        return this.getBytes(offset, imageSize, l);
+        const { offset, imageSize } = await this.getTileSize(idx);
+        return this.getBytes(offset, imageSize);
     }
 
-    protected async getTileSize(index: number, l?: LogType): Promise<{ offset: number; imageSize: number }> {
+    protected async getTileSize(index: number): Promise<{ offset: number; imageSize: number }> {
         // GDAL optimizes tiles by storing the size of the tile in
         // the few bytes leading up to the tile
         if (this.tif.options.tileLeaderByteSize) {
-            const offset = await this.getTileOffset(index, l);
+            const offset = await this.getTileOffset(index);
             // Sparse COG no data found
             if (offset === 0) return { offset: 0, imageSize: 0 };
 
             const leaderBytes = this.tif.options.tileLeaderByteSize;
             // This fetch will generally load in the bytes needed for the image too
             // provided the image size is less than the size of a chunk
-            await this.tif.source.loadBytes(offset - leaderBytes, leaderBytes, l);
+            await this.tif.source.loadBytes(offset - leaderBytes, leaderBytes);
             return { offset, imageSize: this.tif.source.getUint(offset - leaderBytes, leaderBytes) };
         }
 
@@ -464,7 +462,7 @@ export class CogTiffImage {
         if (byteCounts == null) {
             throw new Error('No tile byte counts found');
         }
-        const [offset, imageSize] = await Promise.all([this.getTileOffset(index, l), byteCounts.getValueAt(index, l)]);
+        const [offset, imageSize] = await Promise.all([this.getTileOffset(index), byteCounts.getValueAt(index)]);
         return { offset, imageSize };
     }
 }

package/src/cog.tiff.ts

@@ -1,4 +1,4 @@
-import { ChunkSource, LogType } from '@chunkd/core';
+import { ChunkSource } from '@chunkd/core';
 import { CogTiffImage } from './cog.tiff.image.js';
 import { TiffEndian } from './const/tiff.endian.js';
 import { TiffTag } from './const/tiff.tag.id.js';
@@ -38,24 +38,24 @@ export class CogTiff {
      *
      * @param loadGeoKeys Whether to also initialize the GeoKeyDirectory
      */
-    init(loadGeoKeys = false, logger?: LogType): Promise<CogTiff> {
+    init(loadGeoKeys = false): Promise<CogTiff> {
         if (this._initPromise) return this._initPromise;
-        this._initPromise = this.doInit(loadGeoKeys, logger);
+        this._initPromise = this.doInit(loadGeoKeys);
         return this._initPromise;
     }
 
-    private async doInit(loadGeoKeys = false, logger?: LogType): Promise<CogTiff> {
+    private async doInit(loadGeoKeys = false): Promise<CogTiff> {
         if (this.isInitialized) return this;
         // Load the first few KB in, more loads will run as more data is required
-        await this.source.loadBytes(0, this.source.chunkSize, logger);
-        await this.fetchIfd(logger);
-        await Promise.all(this.images.map((c) => c.init(loadGeoKeys, logger)));
+        await this.source.loadBytes(0, this.source.chunkSize);
+        await this.fetchIfd();
+        await Promise.all(this.images.map((c) => c.init(loadGeoKeys)));
 
         this.isInitialized = true;
         return this;
     }
 
-    private async fetchIfd(logger?: LogType): Promise<void> {
+    private async fetchIfd(): Promise<void> {
         const view = this.cursor.seekTo(0);
         const endian = view.uint16();
         this.source.isLittleEndian = endian === TiffEndian.Little;
@@ -79,14 +79,14 @@ export class CogTiff {
         const ghostSize = nextOffsetIfd - this.cursor.currentOffset;
         // GDAL now stores metadata between the IFD inside a ghost storage area
         if (ghostSize > 0 && ghostSize < 16 * 1024) {
-            logger?.debug(
-                { offset: toHexString(this.cursor.currentOffset), length: toHexString(ghostSize) },
-                'GhostOptions',
-            );
+            // logger?.debug(
+            //     { offset: toHexString(this.cursor.currentOffset), length: toHexString(ghostSize) },
+            //     'GhostOptions',
+            // );
             // this.options.process(this.source, view.currentOffset, ghostSize);
         }
 
-        return this.processIfd(nextOffsetIfd, logger);
+        return this.processIfd(nextOffsetIfd);
     }
 
     getImage(z: number): CogTiffImage {
@@ -135,38 +135,20 @@ export class CogTiff {
         return image.getTile(x, y);
     }
 
-    private async processIfd(offset: number, logger?: LogType): Promise<void> {
-        logger?.trace({ offset: toHexString(offset) }, 'NextImageOffset');
+    private async processIfd(offset: number): Promise<void> {
+        if (!this.source.hasBytes(offset, 4096)) await this.source.loadBytes(offset, 4096);
 
-        if (!this.source.hasBytes(offset, 4096)) {
-            await this.source.loadBytes(offset, 4096, logger);
-        }
-
-        const { image, nextOffset } = await this.readIfd(offset, logger);
+        const { image, nextOffset } = await this.readIfd(offset);
         this.images.push(image);
-        const size = image.size;
-        if (image.isTiled()) {
-            const tile = image.tileSize;
-            logger?.debug(
-                {
-                    ...size,
-                    tileWidth: tile.width,
-                    tileHeight: tile.height,
-                    tileCount: Math.ceil(size.width / tile.width),
-                },
-                'GotImage',
-            );
-        }
 
-        if (nextOffset) await this.processIfd(nextOffset, logger);
+        if (nextOffset) await this.processIfd(nextOffset);
     }
 
-    private async readIfd(offset: number, log?: LogType): Promise<{ nextOffset: number; image: CogTiffImage }> {
-        if (!this.source.hasBytes(offset, 1024)) await this.source.loadBytes(offset, this.source.chunkSize, log);
+    private async readIfd(offset: number): Promise<{ nextOffset: number; image: CogTiffImage }> {
+        if (!this.source.hasBytes(offset, 1024)) await this.source.loadBytes(offset, this.source.chunkSize);
         const view = this.cursor.seekTo(offset);
         const tagCount = view.offset();
         const byteStart = offset + this.ifdConfig.offset;
-        const logger = log?.child({ imageId: this.images.length });
         const tags: Map<TiffTag, CogTiffTagBase> = new Map();
 
         let pos = byteStart;
@@ -174,33 +156,7 @@ export class CogTiff {
             const tag = CogTiffTag.create(this, pos);
             pos += tag.size;
 
-            if (tag.name == null) {
-                logger?.error({ code: toHexString(tag.id) }, `IFDUnknown`);
-                continue;
-            }
-
-            if (!tag.isReady) {
-                logger?.trace(
-                    {
-                        offset: toHexString(pos - offset),
-                        code: toHexString(tag.id),
-                        tagName: tag.name,
-                        ptr: toHexString(tag.valuePointer),
-                    },
-                    'PartialReadIFD',
-                );
-            } else {
-                logger?.trace(
-                    {
-                        offset: toHexString(pos - offset),
-                        code: toHexString(tag.id),
-                        tagName: tag.name,
-                        value: Array.isArray(tag.value) ? `[${tag.value.length}]` : tag.value,
-                    },
-                    'ReadIFD',
-                );
-            }
-
+            if (tag.name == null) throw new Error('Unknown IFD Tag: ' + toHexString(tag.id));
             tags.set(tag.id, tag);
         }
 

package/src/const/tiff.mime.ts

@@ -2,6 +2,7 @@
  * MimeType conversion for common tif image types
  */
 export enum TiffMimeType {
+    NONE = 'application/octet-stream',
     JPEG = 'image/jpeg',
     JP2 = 'image/jp2',
     WEBP = 'image/webp',
@@ -10,6 +11,7 @@ export enum TiffMimeType {
 }
 
 export const TiffCompression: { [key: number]: TiffMimeType } = {
+    1: TiffMimeType.NONE,
     5: TiffMimeType.LZW,
     6: TiffMimeType.JPEG,
     7: TiffMimeType.JPEG,

package/src/read/tag/__test__/tag.test.ts

@@ -10,7 +10,7 @@ o.spec('TiffTag', () => {
     const cogSourceFile = new TestFileChunkSource(path.join(dirName, '../../../../../data/rgba8_tiled.tiff'));
 
     o.beforeEach(() => {
-        cogSourceFile.chunks.clear();
+        (cogSourceFile.chunks as Map<unknown, unknown>).clear();
     });
 
     o('should load lazy tags', async () => {

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

@@ -34,7 +34,7 @@ export abstract class CogTiffTagBase<T = unknown> {
         this.name = TiffTag[this.id];
 
         this.dataType = this.tiff.source.getUint16(offset + 2);
-        this.dataCount = this.tiff.source.getUint(offset + 4, this.tiff.ifdConfig.offset);
+        this.dataCount = this.tiff.source.getUint(offset + 4, this.tiff.ifdConfig.pointer);
         this.dataTypeSize = getTiffTagSize(this.dataType);
         this.dataLength = this.dataTypeSize * this.dataCount;
     }

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

@@ -1,4 +1,3 @@
-import { LogType } from '@chunkd/core';
 import { CogTiffTagBase } from './tiff.tag.base.js';
 
 export class CogTiffTagLazy<T> extends CogTiffTagBase<T> {
@@ -8,9 +7,9 @@ export class CogTiffTagLazy<T> extends CogTiffTagBase<T> {
         return this.value != null;
     }
 
-    async fetch(l?: LogType): Promise<T> {
+    async fetch(): Promise<T> {
         if (this.tiff.source.hasBytes(this.valuePointer, this.dataLength) === false) {
-            await this.tiff.source.loadBytes(this.valuePointer, this.dataLength, l);
+            await this.tiff.source.loadBytes(this.valuePointer, this.dataLength);
         }
         this.value = this.readValue();
         return this.value;

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

@@ -1,4 +1,3 @@
-import { LogType } from '@chunkd/core';
 import { CogTiff } from '../../cog.tiff.js';
 import { getTiffTagValueReader } from '../tiff.value.reader.js';
 import { CogTiffTagBase } from './tiff.tag.base.js';
@@ -27,8 +26,8 @@ export class CogTiffTagOffset extends CogTiffTagBase<number[]> {
     }
 
     /** Load the entire index into memory */
-    async load(l: LogType): Promise<void> {
-        await this.tiff.source.loadBytes(this.valuePointer, this.dataLength, l);
+    async load(): Promise<void> {
+        await this.tiff.source.loadBytes(this.valuePointer, this.dataLength);
         this.readValue();
     }
 
@@ -47,7 +46,7 @@ export class CogTiffTagOffset extends CogTiffTagBase<number[]> {
      * Read a specific value from the offset array
      * @param index index to read at
      */
-    async getValueAt(index: number, l?: LogType): Promise<number> {
+    async getValueAt(index: number): Promise<number> {
         if (this.loadedValues) return this.loadedValues[index];
 
         const dataSize = this.dataTypeSize;
@@ -55,7 +54,7 @@ export class CogTiffTagOffset extends CogTiffTagBase<number[]> {
         const convert = getTiffTagValueReader(this.dataType);
 
         if (!this.tiff.source.hasBytes(valueOffset, dataSize)) {
-            await this.tiff.source.loadBytes(valueOffset, dataSize, l);
+            await this.tiff.source.loadBytes(valueOffset, dataSize);
         }
         return convert(this.tiff.source, valueOffset) as number;
     }

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

@@ -10,6 +10,6 @@ export class CogTifTagStatic<T> extends CogTiffTagBase<T> {
             this._value = this.readValue();
             this._isRead = true;
         }
-        return this._value!;
+        return this._value as T;
     }
 }