cross-image 0.2.1 → 0.2.2

package/esm/src/formats/tiff.js

@@ -132,18 +132,49 @@ export 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 TIFFLZWEncoder();
-            pixelData = encoder.compress(data);
+            pixelData = encoder.compress(sourceData);
             compressionCode = 5;
         }
         else {
             // Uncompressed
-            pixelData = data;
+            pixelData = sourceData;
             compressionCode = 1;
         }
         const result = [];
@@ -161,7 +192,10 @@ export 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)
@@ -179,16 +213,28 @@ export 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)
@@ -201,8 +247,10 @@ export 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");
@@ -229,11 +277,18 @@ export 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);
@@ -696,14 +751,23 @@ export 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
@@ -733,17 +797,40 @@ export 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;
@@ -761,14 +848,23 @@ export 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
@@ -798,17 +894,40 @@ export 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;

package/esm/src/image.d.ts

@@ -207,6 +207,36 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     grayscale(): this;
+    /**
+     * Apply sepia tone effect to the image
+     * @returns This image instance for chaining
+     */
+    sepia(): this;
+    /**
+     * Apply box blur filter to the image
+     * @param radius Blur radius (default: 1)
+     * @returns This image instance for chaining
+     */
+    blur(radius?: number): this;
+    /**
+     * Apply Gaussian blur filter to the image
+     * @param radius Blur radius (default: 1)
+     * @param sigma Optional standard deviation (if not provided, calculated from radius)
+     * @returns This image instance for chaining
+     */
+    gaussianBlur(radius?: number, sigma?: number): this;
+    /**
+     * Apply sharpen filter to the image
+     * @param amount Sharpening amount (0-1, default: 0.5)
+     * @returns This image instance for chaining
+     */
+    sharpen(amount?: number): this;
+    /**
+     * Apply median filter to reduce noise
+     * @param radius Filter radius (default: 1)
+     * @returns This image instance for chaining
+     */
+    medianFilter(radius?: number): this;
     /**
      * Fill a rectangular region with a color
      * @param x Starting X position

package/esm/src/image.js

@@ -1,5 +1,5 @@
 import { resizeBilinear, resizeNearest } from "./utils/resize.js";
-import { adjustBrightness, adjustContrast, adjustExposure, adjustSaturation, composite, crop, fillRect, grayscale, invert, } from "./utils/image_processing.js";
+import { adjustBrightness, adjustContrast, adjustExposure, adjustSaturation, boxBlur, composite, crop, fillRect, gaussianBlur, grayscale, invert, medianFilter, sepia, sharpen, } from "./utils/image_processing.js";
 import { PNGFormat } from "./formats/png.js";
 import { APNGFormat } from "./formats/apng.js";
 import { JPEGFormat } from "./formats/jpeg.js";
@@ -11,6 +11,7 @@ import { ICOFormat } from "./formats/ico.js";
 import { DNGFormat } from "./formats/dng.js";
 import { PAMFormat } from "./formats/pam.js";
 import { PCXFormat } from "./formats/pcx.js";
+import { PPMFormat } from "./formats/ppm.js";
 import { ASCIIFormat } from "./formats/ascii.js";
 import { validateImageDimensions } from "./utils/security.js";
 /**
@@ -458,6 +459,61 @@ export class Image {
         this.imageData.data = grayscale(this.imageData.data);
         return this;
     }
+    /**
+     * Apply sepia tone effect to the image
+     * @returns This image instance for chaining
+     */
+    sepia() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = sepia(this.imageData.data);
+        return this;
+    }
+    /**
+     * Apply box blur filter to the image
+     * @param radius Blur radius (default: 1)
+     * @returns This image instance for chaining
+     */
+    blur(radius = 1) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = boxBlur(this.imageData.data, this.imageData.width, this.imageData.height, radius);
+        return this;
+    }
+    /**
+     * Apply Gaussian blur filter to the image
+     * @param radius Blur radius (default: 1)
+     * @param sigma Optional standard deviation (if not provided, calculated from radius)
+     * @returns This image instance for chaining
+     */
+    gaussianBlur(radius = 1, sigma) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = gaussianBlur(this.imageData.data, this.imageData.width, this.imageData.height, radius, sigma);
+        return this;
+    }
+    /**
+     * Apply sharpen filter to the image
+     * @param amount Sharpening amount (0-1, default: 0.5)
+     * @returns This image instance for chaining
+     */
+    sharpen(amount = 0.5) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = sharpen(this.imageData.data, this.imageData.width, this.imageData.height, amount);
+        return this;
+    }
+    /**
+     * Apply median filter to reduce noise
+     * @param radius Filter radius (default: 1)
+     * @returns This image instance for chaining
+     */
+    medianFilter(radius = 1) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = medianFilter(this.imageData.data, this.imageData.width, this.imageData.height, radius);
+        return this;
+    }
     /**
      * Fill a rectangular region with a color
      * @param x Starting X position
@@ -563,6 +619,7 @@ Object.defineProperty(Image, "formats", {
         new DNGFormat(),
         new PAMFormat(),
         new PCXFormat(),
+        new PPMFormat(),
         new ASCIIFormat(),
     ]
 });

package/esm/src/utils/image_processing.d.ts

@@ -88,4 +88,47 @@ export declare function crop(data: Uint8Array, width: number, height: number, x:
     width: number;
     height: number;
 };
+/**
+ * Apply a box blur filter to an image
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @param radius Blur radius (default: 1)
+ * @returns New image data with box blur applied
+ */
+export declare function boxBlur(data: Uint8Array, width: number, height: number, radius?: number): Uint8Array;
+/**
+ * Apply Gaussian blur to an image
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @param radius Blur radius (default: 1)
+ * @param sigma Optional standard deviation (if not provided, calculated from radius)
+ * @returns New image data with Gaussian blur applied
+ */
+export declare function gaussianBlur(data: Uint8Array, width: number, height: number, radius?: number, sigma?: number): Uint8Array;
+/**
+ * Apply sharpen filter to an image
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @param amount Sharpening amount (0-1, default: 0.5)
+ * @returns New image data with sharpening applied
+ */
+export declare function sharpen(data: Uint8Array, width: number, height: number, amount?: number): Uint8Array;
+/**
+ * Apply sepia tone effect to an image
+ * @param data Image data (RGBA)
+ * @returns New image data with sepia tone applied
+ */
+export declare function sepia(data: Uint8Array): Uint8Array;
+/**
+ * Apply median filter to reduce noise
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @param radius Filter radius (default: 1)
+ * @returns New image data with median filter applied
+ */
+export declare function medianFilter(data: Uint8Array, width: number, height: number, radius?: number): Uint8Array;
 //# sourceMappingURL=image_processing.d.ts.map