cross-image 0.4.0 → 0.4.2

package/esm/src/formats/png_base.js

@@ -141,18 +141,211 @@ export class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    filterData(data, width, height) {
-        // Use filter type 0 (None) for simplicity
-        const filtered = new Uint8Array(height * (1 + width * 4));
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    filterData(data, width, height, compressionLevel = 6) {
+        // Choose filtering strategy based on compression level
+        if (compressionLevel <= 2) {
+            // Fast: No filtering
+            return this.applyNoFilter(data, width, height);
+        }
+        else if (compressionLevel <= 6) {
+            // Balanced: Sub filter
+            return this.applySubFilter(data, width, height);
+        }
+        else {
+            // Best: Adaptive filtering (choose best filter per scanline)
+            return this.applyAdaptiveFilter(data, width, height);
+        }
+    }
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    applyNoFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
         let pos = 0;
         for (let y = 0; y < height; y++) {
             filtered[pos++] = 0; // Filter type: None
-            for (let x = 0; x < width * 4; x++) {
-                filtered[pos++] = data[y * width * 4 + x];
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                filtered[pos++] = data[scanlineStart + x];
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    applySubFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 1; // Filter type: Sub
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                filtered[pos++] = (current - left) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    applyUpFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 2; // Filter type: Up
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                filtered[pos++] = (current - up) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    applyAverageFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 3; // Filter type: Average
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const avg = Math.floor((left + up) / 2);
+                filtered[pos++] = (current - avg) & 0xff;
             }
         }
         return filtered;
     }
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    applyPaethFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 4; // Filter type: Paeth
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+                const paeth = this.paethPredictor(left, up, upLeft);
+                filtered[pos++] = (current - paeth) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    calculateFilterScore(filtered) {
+        let sum = 0;
+        for (let i = 1; i < filtered.length; i++) {
+            const byte = filtered[i];
+            // Penalize larger absolute values
+            sum += byte < 128 ? byte : (256 - byte);
+        }
+        return sum;
+    }
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    applyAdaptiveFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let outPos = 0;
+        // Try each filter type and choose the best for each scanline
+        const filters = [
+            (y) => this.filterScanline(data, y, width, 0), // None
+            (y) => this.filterScanline(data, y, width, 1), // Sub
+            (y) => this.filterScanline(data, y, width, 2), // Up
+            (y) => this.filterScanline(data, y, width, 3), // Average
+            (y) => this.filterScanline(data, y, width, 4), // Paeth
+        ];
+        for (let y = 0; y < height; y++) {
+            let bestFilter = null;
+            let bestScore = Infinity;
+            // Try each filter type
+            for (const filterFn of filters) {
+                const result = filterFn(y);
+                const score = this.calculateFilterScore(result);
+                if (score < bestScore) {
+                    bestScore = score;
+                    bestFilter = result;
+                }
+            }
+            // Copy best filter result
+            if (bestFilter) {
+                filtered.set(bestFilter, outPos);
+                outPos += bestFilter.length;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    filterScanline(data, y, width, filterType) {
+        const bytesPerScanline = width * 4;
+        const result = new Uint8Array(1 + bytesPerScanline);
+        result[0] = filterType;
+        const scanlineStart = y * bytesPerScanline;
+        const prevScanlineStart = (y - 1) * bytesPerScanline;
+        for (let x = 0; x < bytesPerScanline; x++) {
+            const current = data[scanlineStart + x];
+            const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+            const up = y > 0 ? data[prevScanlineStart + x] : 0;
+            const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+            let filtered;
+            switch (filterType) {
+                case 0: // None
+                    filtered = current;
+                    break;
+                case 1: // Sub
+                    filtered = (current - left) & 0xff;
+                    break;
+                case 2: // Up
+                    filtered = (current - up) & 0xff;
+                    break;
+                case 3: // Average
+                    filtered = (current - Math.floor((left + up) / 2)) & 0xff;
+                    break;
+                case 4: // Paeth
+                    filtered = (current - this.paethPredictor(left, up, upLeft)) & 0xff;
+                    break;
+                default:
+                    filtered = current;
+            }
+            result[x + 1] = filtered;
+        }
+        return result;
+    }
     /**
      * Get bytes per pixel for a given color type and bit depth
      */

package/esm/src/formats/tiff.js

@@ -2,6 +2,7 @@ import { TIFFLZWDecoder, TIFFLZWEncoder } from "../utils/tiff_lzw.js";
 import { packBitsCompress, packBitsDecompress } from "../utils/tiff_packbits.js";
 import { deflateCompress, deflateDecompress } from "../utils/tiff_deflate.js";
 import { validateImageDimensions } from "../utils/security.js";
+import { cmykToRgb, rgbaToCmyk } from "../utils/image_processing.js";
 // Constants for unit conversions
 const DEFAULT_DPI = 72;
 /**
@@ -136,6 +137,7 @@ export class TIFFFormat {
         const compression = opts?.compression ?? "none";
         const grayscale = opts?.grayscale ?? false;
         const rgb = opts?.rgb ?? false;
+        const cmyk = opts?.cmyk ?? false;
         // Convert RGBA to grayscale if requested
         let sourceData;
         let samplesPerPixel;
@@ -150,6 +152,16 @@ export class TIFFFormat {
                 sourceData[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
             }
         }
+        else if (cmyk) {
+            // Convert RGBA to CMYK
+            const cmykData = rgbaToCmyk(data);
+            sourceData = new Uint8Array(width * height * 4);
+            samplesPerPixel = 4;
+            // Convert Float32Array CMYK (0-1) to Uint8Array (0-255)
+            for (let i = 0; i < cmykData.length; i++) {
+                sourceData[i] = Math.round(cmykData[i] * 255);
+            }
+        }
         else if (rgb) {
             // Convert RGBA to RGB (strip alpha channel)
             sourceData = new Uint8Array(width * height * 3);
@@ -241,8 +253,8 @@ export class TIFFFormat {
         }
         // Compression (0x0103) - 1 = uncompressed, 5 = LZW
         this.writeIFDEntry(result, 0x0103, 3, 1, compressionCode);
-        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB
-        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : 2);
+        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB, 5 = CMYK
+        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : (cmyk ? 5 : 2));
         // StripOffsets (0x0111)
         this.writeIFDEntry(result, 0x0111, 4, 1, 8);
         // SamplesPerPixel (0x0115) - 1 for grayscale, 3 for RGB, 4 for RGBA
@@ -792,14 +804,16 @@ export class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
-            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2 &&
+            photometric !== 5) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB, 5 = CMYK
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
         // For grayscale (photometric 0 or 1), expect 1 sample per pixel
         // For RGB, expect 3 or 4 samples per pixel
+        // For CMYK, expect 4 samples per pixel
         if (!samplesPerPixel) {
             return null;
         }
@@ -811,6 +825,10 @@ export class TIFFFormat {
             // RGB requires 3 or 4 samples per pixel
             return null;
         }
+        if (photometric === 5 && samplesPerPixel !== 4) {
+            // CMYK requires 4 samples per pixel
+            return null;
+        }
         // Get strip offset
         const stripOffset = this.getIFDValue(data, ifdOffset, 0x0111, isLittleEndian);
         if (!stripOffset || stripOffset >= data.length) {
@@ -868,6 +886,29 @@ export class TIFFFormat {
                 }
             }
         }
+        else if (photometric === 5) {
+            // CMYK image - convert to RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + 4 > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores CMYK in order, values are 0-255
+                    // Convert to 0-1 range for conversion
+                    const c = pixelData[srcPos++] / 255;
+                    const m = pixelData[srcPos++] / 255;
+                    const yVal = pixelData[srcPos++] / 255;
+                    const k = pixelData[srcPos++] / 255;
+                    // Convert CMYK to RGB
+                    const [r, g, b] = cmykToRgb(c, m, yVal, k);
+                    rgba[dstIdx] = r; // R
+                    rgba[dstIdx + 1] = g; // G
+                    rgba[dstIdx + 2] = b; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
         else {
             // RGB/RGBA image
             for (let y = 0; y < height; y++) {
@@ -900,14 +941,16 @@ export class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
-            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2 &&
+            photometric !== 5) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB, 5 = CMYK
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
         // For grayscale (photometric 0 or 1), expect 1 sample per pixel
         // For RGB, expect 3 or 4 samples per pixel
+        // For CMYK, expect 4 samples per pixel
         if (!samplesPerPixel) {
             return null;
         }
@@ -919,6 +962,10 @@ export class TIFFFormat {
             // RGB requires 3 or 4 samples per pixel
             return null;
         }
+        if (photometric === 5 && samplesPerPixel !== 4) {
+            // CMYK requires 4 samples per pixel
+            return null;
+        }
         // Get strip offset
         const stripOffset = this.getIFDValue(data, ifdOffset, 0x0111, isLittleEndian);
         if (!stripOffset || stripOffset >= data.length) {
@@ -976,6 +1023,29 @@ export class TIFFFormat {
                 }
             }
         }
+        else if (photometric === 5) {
+            // CMYK image - convert to RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + 4 > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores CMYK in order, values are 0-255
+                    // Convert to 0-1 range for conversion
+                    const c = pixelData[srcPos++] / 255;
+                    const m = pixelData[srcPos++] / 255;
+                    const yVal = pixelData[srcPos++] / 255;
+                    const k = pixelData[srcPos++] / 255;
+                    // Convert CMYK to RGB
+                    const [r, g, b] = cmykToRgb(c, m, yVal, k);
+                    rgba[dstIdx] = r; // R
+                    rgba[dstIdx + 1] = g; // G
+                    rgba[dstIdx + 2] = b; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
         else {
             // RGB/RGBA image
             for (let y = 0; y < height; y++) {

package/esm/src/image.d.ts

@@ -1,4 +1,4 @@
-import type { ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
+import type { CoefficientData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
 /**
  * Main Image class for reading, manipulating, and saving images
  */
@@ -98,6 +98,44 @@ export declare class Image {
      * @returns Metadata extracted from the image, or undefined if extraction fails or format is unsupported
      */
     static extractMetadata(data: Uint8Array, format?: string): Promise<ImageMetadata | undefined>;
+    /**
+     * Extract coefficients from encoded image data
+     * For JPEG, this returns quantized DCT coefficients that can be modified for steganography
+     * and re-encoded using encodeFromCoefficients()
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "jpeg")
+     * @param options Optional decoder options
+     * @returns Format-specific coefficient structure or undefined if not supported
+     *
+     * @example
+     * ```ts
+     * // Extract JPEG coefficients for steganography
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * if (coeffs) {
+     *   // Modify coefficients for steganography...
+     *   const modified = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * }
+     * ```
+     */
+    static extractCoefficients(data: Uint8Array, format?: string, options?: ImageDecoderOptions): Promise<CoefficientData | undefined>;
+    /**
+     * Encode image from coefficients
+     * For JPEG, accepts quantized DCT coefficients and produces a valid JPEG file
+     * Useful for steganography where coefficients are extracted, modified, and re-encoded
+     * @param coeffs Format-specific coefficient structure
+     * @param format Optional format hint (auto-detected from coeffs.format if available)
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     *
+     * @example
+     * ```ts
+     * // Re-encode modified JPEG coefficients
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * // Modify coefficients...
+     * const encoded = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * ```
+     */
+    static encodeFromCoefficients(coeffs: CoefficientData, format?: string, options?: unknown): Promise<Uint8Array>;
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -350,5 +388,20 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     flipVertical(): this;
+    /**
+     * Convert the image to CMYK color space
+     * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+     * @returns CMYK image data as Float32Array
+     */
+    toCMYK(): Float32Array;
+    /**
+     * Create an Image from CMYK data
+     * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+     * @param width Image width
+     * @param height Image height
+     * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+     * @returns New Image instance
+     */
+    static fromCMYK(cmykData: Float32Array, width: number, height: number, alpha?: number): Image;
 }
 //# sourceMappingURL=image.d.ts.map

package/esm/src/image.js

@@ -1,5 +1,5 @@
 import { resizeBicubic, resizeBilinear, resizeNearest } from "./utils/resize.js";
-import { adjustBrightness, adjustContrast, adjustExposure, adjustHue, adjustSaturation, boxBlur, composite, crop, fillRect, flipHorizontal, flipVertical, gaussianBlur, grayscale, invert, medianFilter, rotate180, rotate270, rotate90, sepia, sharpen, } from "./utils/image_processing.js";
+import { adjustBrightness, adjustContrast, adjustExposure, adjustHue, adjustSaturation, boxBlur, cmykToRgba, composite, crop, fillRect, flipHorizontal, flipVertical, gaussianBlur, grayscale, invert, medianFilter, rgbaToCmyk, rotate180, rotate270, rotate90, 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";
@@ -230,6 +230,74 @@ export class Image {
         }
         return undefined;
     }
+    /**
+     * Extract coefficients from encoded image data
+     * For JPEG, this returns quantized DCT coefficients that can be modified for steganography
+     * and re-encoded using encodeFromCoefficients()
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "jpeg")
+     * @param options Optional decoder options
+     * @returns Format-specific coefficient structure or undefined if not supported
+     *
+     * @example
+     * ```ts
+     * // Extract JPEG coefficients for steganography
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * if (coeffs) {
+     *   // Modify coefficients for steganography...
+     *   const modified = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * }
+     * ```
+     */
+    static async extractCoefficients(data, format, options) {
+        // Try specified format first
+        if (format) {
+            const handler = Image.formats.find((f) => f.name === format);
+            if (handler && handler.canDecode(data) && handler.extractCoefficients) {
+                return await handler.extractCoefficients(data, options);
+            }
+        }
+        // Auto-detect format
+        for (const handler of Image.formats) {
+            if (handler.canDecode(data) && handler.extractCoefficients) {
+                return await handler.extractCoefficients(data, options);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Encode image from coefficients
+     * For JPEG, accepts quantized DCT coefficients and produces a valid JPEG file
+     * Useful for steganography where coefficients are extracted, modified, and re-encoded
+     * @param coeffs Format-specific coefficient structure
+     * @param format Optional format hint (auto-detected from coeffs.format if available)
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     *
+     * @example
+     * ```ts
+     * // Re-encode modified JPEG coefficients
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * // Modify coefficients...
+     * const encoded = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * ```
+     */
+    static async encodeFromCoefficients(coeffs, format, options) {
+        // Detect format from coefficient structure or use provided format
+        const detectedFormat = format ??
+            coeffs.format;
+        if (!detectedFormat) {
+            throw new Error("Format must be specified or present in coefficient data");
+        }
+        const handler = Image.formats.find((f) => f.name === detectedFormat);
+        if (!handler) {
+            throw new Error(`Unknown format: ${detectedFormat}`);
+        }
+        if (!handler.encodeFromCoefficients) {
+            throw new Error(`Format ${detectedFormat} does not support encoding from coefficients`);
+        }
+        return await handler.encodeFromCoefficients(coeffs, options);
+    }
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -864,6 +932,34 @@ export class Image {
         this.imageData.data = flipVertical(this.imageData.data, this.imageData.width, this.imageData.height);
         return this;
     }
+    /**
+     * Convert the image to CMYK color space
+     * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+     * @returns CMYK image data as Float32Array
+     */
+    toCMYK() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        return rgbaToCmyk(this.imageData.data);
+    }
+    /**
+     * Create an Image from CMYK data
+     * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+     * @param width Image width
+     * @param height Image height
+     * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+     * @returns New Image instance
+     */
+    static fromCMYK(cmykData, width, height, alpha = 255) {
+        const rgbaData = cmykToRgba(cmykData, alpha);
+        const image = new Image();
+        image.imageData = {
+            width,
+            height,
+            data: rgbaData,
+        };
+        return image;
+    }
 }
 Object.defineProperty(Image, "formats", {
     enumerable: true,