cross-image 0.2.1 → 0.2.3

package/script/src/formats/tiff.js

@@ -135,18 +135,49 @@ class TIFFFormat {
         const { width, height, data, metadata } = imageData;
         const opts = options;
         const compression = opts?.compression ?? "none";
+        const grayscale = opts?.grayscale ?? false;
+        const rgb = opts?.rgb ?? false;
+        // Convert RGBA to grayscale if requested
+        let sourceData;
+        let samplesPerPixel;
+        if (grayscale) {
+            sourceData = new Uint8Array(width * height);
+            samplesPerPixel = 1;
+            for (let i = 0; i < width * height; i++) {
+                const r = data[i * 4];
+                const g = data[i * 4 + 1];
+                const b = data[i * 4 + 2];
+                // Use standard luminance formula
+                sourceData[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+            }
+        }
+        else if (rgb) {
+            // Convert RGBA to RGB (strip alpha channel)
+            sourceData = new Uint8Array(width * height * 3);
+            samplesPerPixel = 3;
+            for (let i = 0; i < width * height; i++) {
+                sourceData[i * 3] = data[i * 4]; // R
+                sourceData[i * 3 + 1] = data[i * 4 + 1]; // G
+                sourceData[i * 3 + 2] = data[i * 4 + 2]; // B
+            }
+        }
+        else {
+            // Keep as RGBA
+            sourceData = data;
+            samplesPerPixel = 4;
+        }
         // Prepare pixel data (compress if needed)
         let pixelData;
         let compressionCode;
         if (compression === "lzw") {
             // LZW compress the pixel data
             const encoder = new tiff_lzw_js_1.TIFFLZWEncoder();
-            pixelData = encoder.compress(data);
+            pixelData = encoder.compress(sourceData);
             compressionCode = 5;
         }
         else {
             // Uncompressed
-            pixelData = data;
+            pixelData = sourceData;
             compressionCode = 1;
         }
         const result = [];
@@ -164,7 +195,10 @@ class TIFFFormat {
         // IFD (Image File Directory)
         const ifdStart = result.length;
         // Count number of entries (including metadata)
-        let numEntries = 12; // Base entries (including ExtraSamples)
+        // Grayscale: 10 entries (no ExtraSamples)
+        // RGB: 11 entries (no ExtraSamples)
+        // RGBA: 12 entries (includes ExtraSamples)
+        let numEntries = grayscale ? 10 : (rgb ? 11 : 12);
         if (metadata?.description)
             numEntries++;
         if (metadata?.author)
@@ -182,16 +216,28 @@ class TIFFFormat {
         // ImageHeight (0x0101)
         this.writeIFDEntry(result, 0x0101, 4, 1, height);
         // BitsPerSample (0x0102) - 8 bits per channel
-        this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
-        dataOffset += 8; // 4 x 2-byte values
+        if (grayscale) {
+            // Single value for grayscale
+            this.writeIFDEntry(result, 0x0102, 3, 1, 8);
+        }
+        else if (rgb) {
+            // 3 values for RGB
+            this.writeIFDEntry(result, 0x0102, 3, 3, dataOffset);
+            dataOffset += 6; // 3 x 2-byte values
+        }
+        else {
+            // 4 values for RGBA
+            this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
+            dataOffset += 8; // 4 x 2-byte values
+        }
         // Compression (0x0103) - 1 = uncompressed, 5 = LZW
         this.writeIFDEntry(result, 0x0103, 3, 1, compressionCode);
-        // PhotometricInterpretation (0x0106) - 2 = RGB
-        this.writeIFDEntry(result, 0x0106, 3, 1, 2);
+        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB
+        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : 2);
         // StripOffsets (0x0111)
         this.writeIFDEntry(result, 0x0111, 4, 1, 8);
-        // SamplesPerPixel (0x0115) - 4 (RGBA)
-        this.writeIFDEntry(result, 0x0115, 3, 1, 4);
+        // SamplesPerPixel (0x0115) - 1 for grayscale, 3 for RGB, 4 for RGBA
+        this.writeIFDEntry(result, 0x0115, 3, 1, samplesPerPixel);
         // RowsPerStrip (0x0116)
         this.writeIFDEntry(result, 0x0116, 4, 1, height);
         // StripByteCounts (0x0117)
@@ -204,8 +250,10 @@ class TIFFFormat {
         const yResOffset = dataOffset;
         this.writeIFDEntry(result, 0x011b, 5, 1, yResOffset);
         dataOffset += 8;
-        // ExtraSamples (0x0152) - 2 = unassociated alpha
-        this.writeIFDEntry(result, 0x0152, 3, 1, 2);
+        // ExtraSamples (0x0152) - 2 = unassociated alpha (only for RGBA)
+        if (!grayscale && !rgb) {
+            this.writeIFDEntry(result, 0x0152, 3, 1, 2);
+        }
         // Optional metadata entries
         if (metadata?.description) {
             const descBytes = new TextEncoder().encode(metadata.description + "\0");
@@ -232,11 +280,18 @@ class TIFFFormat {
         // Next IFD offset (0 = no more IFDs)
         this.writeUint32LE(result, 0);
         // Write variable-length data
-        // BitsPerSample values (must be written first to match offset calculation)
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
+        // BitsPerSample values (only for RGB and RGBA, not for grayscale)
+        if (rgb) {
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+        }
+        else if (!grayscale) {
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+        }
         // XResolution value (rational)
         const dpiX = metadata?.dpiX ?? DEFAULT_DPI;
         this.writeUint32LE(result, dpiX);
@@ -699,14 +754,23 @@ class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 2) {
-            // Only support RGB (photometric = 2)
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
-        if (!samplesPerPixel || (samplesPerPixel !== 3 && samplesPerPixel !== 4)) {
-            // Only support RGB (3) or RGBA (4)
+        // For grayscale (photometric 0 or 1), expect 1 sample per pixel
+        // For RGB, expect 3 or 4 samples per pixel
+        if (!samplesPerPixel) {
+            return null;
+        }
+        if ((photometric === 0 || photometric === 1) && samplesPerPixel !== 1) {
+            // Grayscale requires 1 sample per pixel
+            return null;
+        }
+        if (photometric === 2 && samplesPerPixel !== 3 && samplesPerPixel !== 4) {
+            // RGB requires 3 or 4 samples per pixel
             return null;
         }
         // Get strip offset
@@ -736,17 +800,40 @@ class TIFFFormat {
         // Convert to RGBA
         const rgba = new Uint8Array(width * height * 4);
         let srcPos = 0;
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const dstIdx = (y * width + x) * 4;
-                if (srcPos + samplesPerPixel > pixelData.length) {
-                    return null; // Not enough data
+        if (photometric === 0 || photometric === 1) {
+            // Grayscale image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos >= pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    let gray = pixelData[srcPos++];
+                    // WhiteIsZero (0) means 0=white, 255=black, so invert
+                    if (photometric === 0) {
+                        gray = 255 - gray;
+                    }
+                    rgba[dstIdx] = gray; // R
+                    rgba[dstIdx + 1] = gray; // G
+                    rgba[dstIdx + 2] = gray; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
+        else {
+            // RGB/RGBA image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + samplesPerPixel > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores RGB(A) in order
+                    rgba[dstIdx] = pixelData[srcPos++]; // R
+                    rgba[dstIdx + 1] = pixelData[srcPos++]; // G
+                    rgba[dstIdx + 2] = pixelData[srcPos++]; // B
+                    rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
                 }
-                // TIFF stores RGB(A) in order
-                rgba[dstIdx] = pixelData[srcPos++]; // R
-                rgba[dstIdx + 1] = pixelData[srcPos++]; // G
-                rgba[dstIdx + 2] = pixelData[srcPos++]; // B
-                rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
             }
         }
         return rgba;
@@ -764,14 +851,23 @@ class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 2) {
-            // Only support RGB (photometric = 2)
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
-        if (!samplesPerPixel || (samplesPerPixel !== 3 && samplesPerPixel !== 4)) {
-            // Only support RGB (3) or RGBA (4)
+        // For grayscale (photometric 0 or 1), expect 1 sample per pixel
+        // For RGB, expect 3 or 4 samples per pixel
+        if (!samplesPerPixel) {
+            return null;
+        }
+        if ((photometric === 0 || photometric === 1) && samplesPerPixel !== 1) {
+            // Grayscale requires 1 sample per pixel
+            return null;
+        }
+        if (photometric === 2 && samplesPerPixel !== 3 && samplesPerPixel !== 4) {
+            // RGB requires 3 or 4 samples per pixel
             return null;
         }
         // Get strip offset
@@ -801,20 +897,74 @@ class TIFFFormat {
         // Convert to RGBA
         const rgba = new Uint8Array(width * height * 4);
         let srcPos = 0;
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const dstIdx = (y * width + x) * 4;
-                if (srcPos + samplesPerPixel > pixelData.length) {
-                    return null; // Not enough data
+        if (photometric === 0 || photometric === 1) {
+            // Grayscale image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos >= pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    let gray = pixelData[srcPos++];
+                    // WhiteIsZero (0) means 0=white, 255=black, so invert
+                    if (photometric === 0) {
+                        gray = 255 - gray;
+                    }
+                    rgba[dstIdx] = gray; // R
+                    rgba[dstIdx + 1] = gray; // G
+                    rgba[dstIdx + 2] = gray; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
+        else {
+            // RGB/RGBA image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + samplesPerPixel > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores RGB(A) in order
+                    rgba[dstIdx] = pixelData[srcPos++]; // R
+                    rgba[dstIdx + 1] = pixelData[srcPos++]; // G
+                    rgba[dstIdx + 2] = pixelData[srcPos++]; // B
+                    rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
                 }
-                // TIFF stores RGB(A) in order
-                rgba[dstIdx] = pixelData[srcPos++]; // R
-                rgba[dstIdx + 1] = pixelData[srcPos++]; // G
-                rgba[dstIdx + 2] = pixelData[srcPos++]; // B
-                rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
             }
         }
         return rgba;
     }
+    /**
+     * Get list of metadata fields supported by TIFF format
+     * TIFF supports extensive EXIF metadata including GPS and InteropIFD
+     */
+    getSupportedMetadata() {
+        return [
+            "creationDate",
+            "description",
+            "author",
+            "copyright",
+            "cameraMake",
+            "cameraModel",
+            "orientation",
+            "software",
+            "iso",
+            "exposureTime",
+            "fNumber",
+            "focalLength",
+            "flash",
+            "whiteBalance",
+            "lensMake",
+            "lensModel",
+            "userComment",
+            "latitude",
+            "longitude",
+            "dpiX",
+            "dpiY",
+            "physicalWidth",
+            "physicalHeight",
+        ];
+    }
 }
 exports.TIFFFormat = TIFFFormat;

package/script/src/formats/webp.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, WebPEncodeOptions } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata, WebPEncodeOptions } from "../types.js";
 /**
  * WebP format handler
  * Implements a basic WebP decoder and encoder
@@ -30,10 +30,17 @@ export declare class WebPFormat implements ImageFormat {
     private readUint24LE;
     private decodeUsingRuntime;
     private parseEXIF;
+    private parseGPSIFD;
+    private readRational;
     private parseXMP;
     private injectMetadata;
     private createEXIFChunk;
+    private createGPSIFD;
+    private writeRational;
     private createXMPChunk;
-    private escapeXML;
+    /**
+     * Get the list of metadata fields supported by WebP format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
 }
 //# sourceMappingURL=webp.d.ts.map