@cogeotiff/core 7.2.1 → 8.0.2

package/src/__test__/cog.image.test.ts

@@ -1,214 +1,205 @@
-import o from 'ospec';
-import * as path from 'path';
 import { promises as fs } from 'fs';
-
-import 'source-map-support/register.js';
-
-import { TestFileChunkSource } from '@chunkd/core/build/__test__/chunk.source.fake.js';
+import assert from 'node:assert';
+import { beforeEach, describe, it } from 'node:test';
+import { TestFileSource } from '../__benchmark__/source.file.js';
+import { SourceMemory } from '../__benchmark__/source.memory.js';
+import { ByteSize } from '../util/bytes.js';
 import { CogTiff } from '../cog.tiff.js';
-import { TiffMimeType } from '../const/index.js';
-import { ByteSize, SourceMemory } from '@chunkd/core';
-import { fileURLToPath } from 'url';
+import { TiffMimeType } from '../const/tiff.mime.js';
 
-const __dirname = fileURLToPath(import.meta.url);
 // 900913 properties.
 const A = 6378137.0;
 const InitialResolution = (2 * Math.PI * A) / 256;
 
 function getResolution(zoom: number): number {
-    return InitialResolution / 2 ** zoom;
+  return InitialResolution / 2 ** zoom;
 }
 
-o.spec('CogTiled', () => {
-    const cogSourceFile = new TestFileChunkSource(path.join(__dirname, '../../../data/rgba8_tiled.tiff'));
-    const cog = new CogTiff(cogSourceFile);
-
-    o.beforeEach(() => cog.init());
-
-    o('should match resolutions to web mercator zoom levels', () => {
-        for (let i = 0; i < 14; i++) {
-            o(cog.getImageByResolution(getResolution(i)).id).equals(4);
-        }
-
-        o(cog.getImageByResolution(getResolution(14)).id).equals(3);
-        o(cog.getImageByResolution(getResolution(15)).id).equals(2);
-        o(cog.getImageByResolution(getResolution(16)).id).equals(1);
-        o(cog.getImageByResolution(getResolution(17)).id).equals(0);
-        o(cog.getImageByResolution(getResolution(18)).id).equals(0);
-
-        for (let i = 19; i < 32; i++) {
-            o(cog.getImageByResolution(getResolution(i)).id).equals(0);
-        }
-    });
-
-    o('should get origin from all images', () => {
-        const baseOrigin = cog.images[0].origin;
-        for (const img of cog.images) {
-            o(img.origin).deepEquals(baseOrigin);
-        }
-    });
-
-    o('should get bounding box from all images', () => {
-        const baseOrigin = cog.images[0].bbox;
-        for (const img of cog.images) {
-            o(img.bbox).deepEquals(baseOrigin);
-        }
-    });
-
-    o('should be geolocated', () => {
-        for (const img of cog.images) o(img.isGeoLocated).equals(true);
-    });
-
-    o('should scale image resolution for all images', () => {
-        const [resX, resY, resZ] = cog.images[0].resolution;
-        for (let i = 0; i < cog.images.length; i++) {
-            const img = cog.images[i];
-            const scale = 2 ** i; // This tiff is scaled at a factor of two per zoom level
-            o(img.resolution).deepEquals([resX * scale, resY * scale, resZ]);
-        }
-    });
-
-    o('should have tile information', () => {
-        const [firstImage] = cog.images;
-        o(firstImage.stripCount).equals(0);
-        o(firstImage.isTiled()).equals(true);
-    });
-
-    o('should hasTile for every tile', async () => {
-        const [firstImage] = cog.images;
-
-        for (let x = 0; x < firstImage.tileCount.x; x++) {
-            for (let y = 0; y < firstImage.tileCount.y; y++) {
-                o(await firstImage.hasTile(x, y)).equals(true);
-            }
-        }
-    });
+describe('CogTiled', () => {
+  const cogSourceFile = new TestFileSource(new URL('../../data/rgba8_tiled.tiff', import.meta.url));
+  const cog = new CogTiff(cogSourceFile);
+
+  beforeEach(() => cog.init());
+
+  it('should match resolutions to web mercator zoom levels', () => {
+    for (let i = 0; i < 14; i++) {
+      assert.equal(cog.getImageByResolution(getResolution(i)).id, 4);
+    }
+
+    assert.equal(cog.getImageByResolution(getResolution(14)).id, 3);
+    assert.equal(cog.getImageByResolution(getResolution(15)).id, 2);
+    assert.equal(cog.getImageByResolution(getResolution(16)).id, 1);
+    assert.equal(cog.getImageByResolution(getResolution(17)).id, 0);
+    assert.equal(cog.getImageByResolution(getResolution(18)).id, 0);
+
+    for (let i = 19; i < 32; i++) {
+      assert.equal(cog.getImageByResolution(getResolution(i)).id, 0);
+    }
+  });
+
+  it('should get origin from all images', () => {
+    const baseOrigin = cog.images[0].origin;
+    for (const img of cog.images) {
+      assert.deepEqual(img.origin, baseOrigin);
+    }
+  });
+
+  it('should get bounding box from all images', () => {
+    const baseOrigin = cog.images[0].bbox;
+    for (const img of cog.images) {
+      assert.deepEqual(img.bbox, baseOrigin);
+    }
+  });
+
+  it('should be geolocated', () => {
+    for (const img of cog.images) assert.equal(img.isGeoLocated, true);
+  });
+
+  it('should scale image resolution for all images', () => {
+    const [resX, resY, resZ] = cog.images[0].resolution;
+    for (let i = 0; i < cog.images.length; i++) {
+      const img = cog.images[i];
+      const scale = 2 ** i; // This tiff is scaled at a factor of two per zoom level
+      assert.deepEqual(img.resolution, [resX * scale, resY * scale, resZ]);
+    }
+  });
+
+  it('should have tile information', () => {
+    const [firstImage] = cog.images;
+    assert.equal(firstImage.stripCount, 0);
+    assert.equal(firstImage.isTiled(), true);
+  });
+
+  it('should hasTile for every tile', async () => {
+    const [firstImage] = cog.images;
+
+    for (let x = 0; x < firstImage.tileCount.x; x++) {
+      for (let y = 0; y < firstImage.tileCount.y; y++) {
+        assert.equal(await firstImage.hasTile(x, y), true);
+      }
+    }
+  });
 });
 
-o.spec('Cog.Big', () => {
-    o('should support reading from memory', async () => {
-        const fullSource = new TestFileChunkSource(path.join(__dirname, '../../../data/sparse.tiff'));
-        fullSource.chunkSize = 27902;
-        await fullSource.loadBytes(0, 27902);
-        const cog = new CogTiff(fullSource);
-        await cog.init();
-
-        o(fullSource.chunkSize).equals(27902);
-        o(fullSource.chunks.size).equals(1);
-        const [firstImage] = cog.images;
-        o(firstImage.stripCount).equals(0);
-        o(firstImage.isTiled()).equals(true);
-
-        const img = cog.getImage(4);
-        o(img.tileCount).deepEquals({ x: 2, y: 2 });
-    });
-
-    o('should read using a memory source', async () => {
-        const bytes = await fs.readFile(path.join(__dirname, '../../../data/sparse.tiff'));
-        const source = new SourceMemory('Sparse.tiff', bytes.buffer);
-        const cog = new CogTiff(source);
-        await cog.init();
-
-        o(source.chunkSize).equals(27902);
-        o(source.chunks.size).equals(1);
-        const [firstImage] = cog.images;
-        o(firstImage.stripCount).equals(0);
-        o(firstImage.isTiled()).equals(true);
-
-        const img = cog.getImage(4);
-        o(img.tileCount).deepEquals({ x: 2, y: 2 });
-    });
+describe('Cog.Big', () => {
+  it('should support reading from memory', async () => {
+    const fullSource = new TestFileSource(new URL('../../data/sparse.tiff', import.meta.url));
+
+    const cog = new CogTiff(fullSource);
+    await cog.init();
+
+    const [firstImage] = cog.images;
+    assert.equal(firstImage.stripCount, 0);
+    assert.equal(firstImage.isTiled(), true);
+
+    const img = cog.images[4];
+    assert.deepEqual(img.tileCount, { x: 2, y: 2 });
+  });
+
+  it('should read using a memory source', async () => {
+    const bytes = await fs.readFile(new URL('../../data/sparse.tiff', import.meta.url));
+    const source = new SourceMemory(bytes.buffer);
+    const cog = new CogTiff(source);
+    await cog.init();
+
+    const [firstImage] = cog.images;
+    assert.equal(firstImage.stripCount, 0);
+    assert.equal(firstImage.isTiled(), true);
+
+    const img = cog.images[4];
+    assert.deepEqual(img.tileCount, { x: 2, y: 2 });
+  });
 });
 
-o.spec('Cog.Sparse', () => {
-    const cogSourceFile = new TestFileChunkSource(path.join(__dirname, '../../../data/sparse.tiff'));
-    const cog = new CogTiff(cogSourceFile);
-    o.beforeEach(() => cog.init(true));
-
-    o('should read metadata', () => {
-        o(cog.getImage(0).epsg).equals(2193);
-    });
-
-    o('should be geolocated', () => {
-        for (const img of cog.images) o(img.isGeoLocated).equals(true);
-    });
-
-    o('should support sparse cogs', async () => {
-        const z = 4;
-        const img = cog.getImage(z);
-
-        const { tileCount } = img;
-        o(tileCount).deepEquals({ x: 2, y: 2 });
-
-        for (let x = 0; x < tileCount.x; x++) {
-            for (let y = 0; y < tileCount.y; y++) {
-                const hasTile = await img.hasTile(x, y);
-                o(hasTile).equals(false);
-                const tileXy = await img.getTile(x, y);
-                const tileXyz = await cog.getTile(x, y, z);
-                o(tileXy).equals(null)(`Tile x:${x} y:${y} should be empty`);
-                o(tileXyz).equals(null)(`Tile x:${x} y:${y} z: ${z} should be empty`);
-            }
-        }
-    });
-
-    o('should have ghost options', () => {
-        o(cog.options.options.size).equals(6);
-        o(cog.options.tileLeaderByteSize).equals(ByteSize.UInt32);
-        o(cog.options.isCogOptimized).equals(true);
-
-        const entries = [...cog.options.options.entries()];
-        o(entries).deepEquals([
-            ['GDAL_STRUCTURAL_METADATA_SIZE', '000140 bytes'],
-            ['LAYOUT', 'IFDS_BEFORE_DATA'],
-            ['BLOCK_ORDER', 'ROW_MAJOR'],
-            ['BLOCK_LEADER', 'SIZE_AS_UINT4'],
-            ['BLOCK_TRAILER', 'LAST_4_BYTES_REPEATED'],
-            ['KNOWN_INCOMPATIBLE_EDITION', 'NO'],
-        ]);
-    });
+describe('Cog.Sparse', () => {
+  const cogSourceFile = new TestFileSource(new URL('../../data/sparse.tiff', import.meta.url));
+  const cog = new CogTiff(cogSourceFile);
+
+  it('should read metadata', async () => {
+    await cog.init();
+    assert.equal(cog.images[0].epsg, 2193);
+  });
+
+  it('should be geolocated', () => {
+    for (const img of cog.images) assert.equal(img.isGeoLocated, true);
+  });
+
+  it('should support sparse cogs', async () => {
+    const z = 4;
+    const img = cog.images[z];
+
+    const { tileCount } = img;
+    assert.deepEqual(tileCount, { x: 2, y: 2 });
+
+    for (let x = 0; x < tileCount.x; x++) {
+      for (let y = 0; y < tileCount.y; y++) {
+        const hasTile = await img.hasTile(x, y);
+        assert.equal(hasTile, false);
+        const tileXy = await img.getTile(x, y);
+        const tileXyz = await cog.images[z].getTile(x, y);
+        assert.equal(tileXy, null, `Tile x:${x} y:${y} should be empty`);
+        assert.equal(tileXyz, null, `Tile x:${x} y:${y} z: ${z} should be empty`);
+      }
+    }
+  });
+
+  it('should have ghost options', () => {
+    assert.equal(cog.options?.options.size, 6);
+    assert.equal(cog.options?.tileLeaderByteSize, ByteSize.UInt32);
+    assert.equal(cog.options?.isCogOptimized, true);
+
+    const entries = [...(cog.options?.options.entries() ?? [])];
+    assert.deepEqual(entries, [
+      ['GDAL_STRUCTURAL_METADATA_SIZE', '000140 bytes'],
+      ['LAYOUT', 'IFDS_BEFORE_DATA'],
+      ['BLOCK_ORDER', 'ROW_MAJOR'],
+      ['BLOCK_LEADER', 'SIZE_AS_UINT4'],
+      ['BLOCK_TRAILER', 'LAST_4_BYTES_REPEATED'],
+      ['KNOWN_INCOMPATIBLE_EDITION', 'NO'],
+    ]);
+  });
 });
 
-o.spec('CogStrip', () => {
-    const cogSourceFile = new TestFileChunkSource(path.join(__dirname, '../../../data/rgba8_strip.tiff'));
-    const cog = new CogTiff(cogSourceFile);
-
-    o.beforeEach(() => cog.init());
-
-    o('should get origin from all images', () => {
-        const baseOrigin = cog.images[0].origin;
-        for (const img of cog.images) {
-            o(img.origin).deepEquals(baseOrigin);
-        }
-    });
-
-    o('should get bounding box from all images', () => {
-        const baseOrigin = cog.images[0].bbox;
-        for (const img of cog.images) {
-            o(img.bbox).deepEquals(baseOrigin);
-        }
-    });
-
-    o('should scale image resolution for all images', () => {
-        const [resX, resY, resZ] = cog.images[0].resolution;
-        for (let i = 0; i < cog.images.length; i++) {
-            const img = cog.images[i];
-            const scale = 2 ** i; // This tiff is scaled at a factor of two per zoom level
-            o(img.resolution).deepEquals([resX * scale, resY * scale, resZ]);
-        }
-    });
-
-    o('should have strip information', async () => {
-        const [firstImage] = cog.images;
-        o(firstImage.isTiled()).equals(false);
-        o(firstImage.stripCount).equals(2);
-
-        const stripA = await firstImage.getStrip(0);
-        o(stripA?.mimeType).equals(TiffMimeType.WEBP);
-        o(stripA?.bytes.byteLength).equals(152);
-
-        const stripB = await firstImage.getStrip(1);
-        o(stripB?.mimeType).equals(TiffMimeType.WEBP);
-        o(stripB?.bytes.byteLength).equals(152);
-    });
+describe('CogStrip', () => {
+  const cogSourceFile = new TestFileSource(new URL('../../data/rgba8_strip.tiff', import.meta.url));
+  const cog = new CogTiff(cogSourceFile);
+
+  beforeEach(() => cog.init());
+
+  it('should get origin from all images', () => {
+    const baseOrigin = cog.images[0].origin;
+    for (const img of cog.images) {
+      assert.deepEqual(img.origin, baseOrigin);
+    }
+  });
+
+  it('should get bounding box from all images', () => {
+    const baseOrigin = cog.images[0].bbox;
+    for (const img of cog.images) {
+      assert.deepEqual(img.bbox, baseOrigin);
+    }
+  });
+
+  it('should scale image resolution for all images', () => {
+    const [resX, resY, resZ] = cog.images[0].resolution;
+    for (let i = 0; i < cog.images.length; i++) {
+      const img = cog.images[i];
+      const scale = 2 ** i; // This tiff is scaled at a factor of two per zoom level
+      assert.deepEqual(img.resolution, [resX * scale, resY * scale, resZ]);
+    }
+  });
+
+  it('should have strip information', async () => {
+    const [firstImage] = cog.images;
+    assert.equal(firstImage.isTiled(), false);
+    assert.equal(firstImage.stripCount, 2);
+
+    const stripA = await firstImage.getStrip(0);
+    assert.equal(stripA?.mimeType, TiffMimeType.Webp);
+    assert.equal(stripA?.bytes.byteLength, 152);
+
+    const stripB = await firstImage.getStrip(1);
+    assert.equal(stripB?.mimeType, TiffMimeType.Webp);
+    assert.equal(stripB?.bytes.byteLength, 152);
+  });
 });

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

@@ -1,90 +1,68 @@
-import o from 'ospec';
-import * as path from 'path';
-import 'source-map-support/register.js';
-
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
 import { CogTiff } from '../cog.tiff.js';
-import { TiffVersion } from '../const/tiff.version.js';
 import { TiffMimeType } from '../const/tiff.mime.js';
-import { TestFileChunkSource } from '@chunkd/core/build/__test__/chunk.source.fake.js';
-import { fileURLToPath } from 'url';
-
-const __dirname = fileURLToPath(import.meta.url);
-
-o.spec('CogRead', () => {
-    // TODO this does not load 100% yet
-    // o('should read big endian', async () => {
-    //     const source = new TestFileChunkSource(path.join(__dirname, '../../../test/data/be_cog.tif'))
-    //     const tif = new CogTif(source);
-
-    //     await tif.init();
+import { TestFileSource } from '../__benchmark__/source.file.js';
+import { TiffVersion } from '../const/tiff.version.js';
 
-    //     o(source.isLittleEndian).equals(false);
-    //     o(source.version).equals(TiffVersion.Tiff);
-    //     o(tif.images.length).equals(5)
-    //     const [firstTif] = tif.images;
-    //     o(firstTif.isTiled()).equals(true);
-    //
-    //     // o(firstTif.compression).equals('image/jpeg')
-    // })
+function validate(tif: CogTiff): void {
+  assert.equal(tif.images.length, 5);
 
-    function validate(tif: CogTiff): void {
-        o(tif.images.length).equals(5);
+  const [firstTif] = tif.images;
+  assert.equal(firstTif.isTiled(), true);
+  assert.deepEqual(firstTif.tileSize, { width: 256, height: 256 });
+  assert.deepEqual(firstTif.size, { width: 64, height: 64 });
+}
 
-        const [firstTif] = tif.images;
-        o(firstTif.isTiled()).equals(true);
-        o(firstTif.tileSize).deepEquals({ width: 256, height: 256 });
-        o(firstTif.size).deepEquals({ width: 64, height: 64 });
-    }
+describe('CogRead', () => {
+  // TODO this does not load 100% yet
+  // it('should read big endian', async () => {
+  //     const source = new TestFileSource(new URL('../../data/big_cog.tiff', import.meta.url));
+  //     const tiff = new CogTiff(source);
 
-    o('should read big tiff', async () => {
-        const source = new TestFileChunkSource(path.join(__dirname, '../../../data/big_cog.tif'));
-        const tiff = new CogTiff(source);
+  //     await tiff.init();
 
-        await tiff.init();
+  //     assert.equal(tiff.isLittleEndian, false);
+  //     assert.equal(tiff.version, TiffVersion.BigTiff);
+  //     validate(tiff);
+  // });
 
-        o(source.isLittleEndian).equals(true);
-        o(tiff.version).equals(TiffVersion.BigTiff);
-        validate(tiff);
-    });
+  it('should read big tiff', async () => {
+    const source = new TestFileSource(new URL('../../data/big_cog.tiff', import.meta.url));
+    const tiff = new CogTiff(source);
 
-    o('should read tiff', async () => {
-        const source = new TestFileChunkSource(path.join(__dirname, '../../../data/cog.tif'));
-        const tiff = new CogTiff(source);
+    await tiff.init();
 
-        await tiff.init();
+    assert.equal(tiff.isLittleEndian, true);
+    assert.equal(tiff.version, TiffVersion.BigTiff);
+    validate(tiff);
+  });
 
-        o(source.isLittleEndian).equals(true);
-        o(tiff.version).equals(TiffVersion.Tiff);
-        validate(tiff);
+  it('should read tiff', async () => {
+    const source = new TestFileSource(new URL('../../data/cog.tiff', import.meta.url));
+    const tiff = new CogTiff(source);
 
-        const [firstTif] = tiff.images;
-        o(firstTif.compression).equals(TiffMimeType.JPEG);
-    });
+    await tiff.init();
 
-    o('should allow multiple init', async () => {
-        const source = new TestFileChunkSource(path.join(__dirname, '../../../data/cog.tif'));
-        const tiff = new CogTiff(source);
+    assert.equal(tiff.isLittleEndian, true);
+    assert.equal(tiff.version, TiffVersion.Tiff);
+    validate(tiff);
 
-        o(tiff.isInitialized).equals(false);
-        await tiff.init();
-        o(tiff.isInitialized).equals(true);
-        o(tiff.images.length).equals(5);
+    const [firstTif] = tiff.images;
+    assert.equal(firstTif.compression, TiffMimeType.Jpeg);
+  });
 
-        o(tiff.isInitialized).equals(true);
-        await tiff.init();
-        o(tiff.images.length).equals(5);
-    });
+  it('should allow multiple init', async () => {
+    const source = new TestFileSource(new URL('../../data/cog.tiff', import.meta.url));
+    const tiff = new CogTiff(source);
 
-    o('should close a source', async () => {
-        const source = new TestFileChunkSource(path.join(__dirname, '../../../data/cog.tif'));
-        const tiff = new CogTiff(source);
-        // Should not close if there is no close
-        source.close = undefined;
-        await tiff.close();
+    assert.equal(tiff.isInitialized, false);
+    await tiff.init();
+    assert.equal(tiff.isInitialized, true);
+    assert.equal(tiff.images.length, 5);
 
-        const closeSpy = o.spy(() => Promise.resolve());
-        source.close = closeSpy;
-        await tiff.close();
-        o(closeSpy.callCount).equals(1);
-    });
+    assert.equal(tiff.isInitialized, true);
+    await tiff.init();
+    assert.equal(tiff.images.length, 5);
+  });
 });

package/src/__test__/example.ts

@@ -0,0 +1,31 @@
+import { SourceHttp } from '@chunkd/source-http';
+import { CogTiff } from '../index.js';
+
+async function main(): Promise<void> {
+  const source = new SourceHttp('https://example.com/cog.tif');
+  const tiff = await CogTiff.create(source);
+
+  /** Load a specific tile from a specific image */
+  const tile = await tiff.images[5].getTile(2, 2);
+  if (tile != null) {
+    tile.bytes; // Raw image buffer or null if tile doesn't exist
+  }
+
+  /** Load the 5th image in the Tiff */
+  const img = tiff.images[5];
+  if (img.isTiled()) {
+    /** Load tile x:10 y:10 */
+    const tile = await img.getTile(10, 10);
+    if (tile != null) {
+      tile.mimeType; // image/jpeg
+      tile.bytes; // Raw image buffer
+    }
+  }
+
+  /** Get the origin point of the tiff */
+  img.origin;
+  /** Bounding box of the tiff */
+  img.bbox;
+}
+
+main();