cross-image 0.2.1 → 0.2.2

package/esm/src/utils/image_processing.js

@@ -229,3 +229,233 @@ export function crop(data, width, height, x, y, cropWidth, cropHeight) {
     }
     return { data: result, width: actualWidth, height: actualHeight };
 }
+/**
+ * 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 function boxBlur(data, width, height, radius = 1) {
+    const result = new Uint8Array(data.length);
+    const clampedRadius = Math.max(1, Math.floor(radius));
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let r = 0, g = 0, b = 0, a = 0;
+            let count = 0;
+            // Iterate over kernel
+            for (let ky = -clampedRadius; ky <= clampedRadius; ky++) {
+                for (let kx = -clampedRadius; kx <= clampedRadius; kx++) {
+                    const px = x + kx;
+                    const py = y + ky;
+                    // Check bounds
+                    if (px >= 0 && px < width && py >= 0 && py < height) {
+                        const idx = (py * width + px) * 4;
+                        r += data[idx];
+                        g += data[idx + 1];
+                        b += data[idx + 2];
+                        a += data[idx + 3];
+                        count++;
+                    }
+                }
+            }
+            const outIdx = (y * width + x) * 4;
+            result[outIdx] = Math.round(r / count);
+            result[outIdx + 1] = Math.round(g / count);
+            result[outIdx + 2] = Math.round(b / count);
+            result[outIdx + 3] = Math.round(a / count);
+        }
+    }
+    return result;
+}
+/**
+ * Generate a Gaussian kernel for blur
+ * @param radius Kernel radius
+ * @param sigma Standard deviation (if not provided, calculated from radius)
+ * @returns Gaussian kernel as 1D array
+ */
+function generateGaussianKernel(radius, sigma) {
+    const size = radius * 2 + 1;
+    const kernel = new Array(size);
+    const s = sigma ?? radius / 3;
+    const s2 = 2 * s * s;
+    let sum = 0;
+    for (let i = 0; i < size; i++) {
+        const x = i - radius;
+        kernel[i] = Math.exp(-(x * x) / s2);
+        sum += kernel[i];
+    }
+    // Normalize
+    for (let i = 0; i < size; i++) {
+        kernel[i] /= sum;
+    }
+    return kernel;
+}
+/**
+ * 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 function gaussianBlur(data, width, height, radius = 1, sigma) {
+    const clampedRadius = Math.max(1, Math.floor(radius));
+    const kernel = generateGaussianKernel(clampedRadius, sigma);
+    // Apply horizontal pass
+    const temp = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let r = 0, g = 0, b = 0, a = 0;
+            for (let kx = -clampedRadius; kx <= clampedRadius; kx++) {
+                const px = Math.max(0, Math.min(width - 1, x + kx));
+                const idx = (y * width + px) * 4;
+                const weight = kernel[kx + clampedRadius];
+                r += data[idx] * weight;
+                g += data[idx + 1] * weight;
+                b += data[idx + 2] * weight;
+                a += data[idx + 3] * weight;
+            }
+            const outIdx = (y * width + x) * 4;
+            temp[outIdx] = Math.round(r);
+            temp[outIdx + 1] = Math.round(g);
+            temp[outIdx + 2] = Math.round(b);
+            temp[outIdx + 3] = Math.round(a);
+        }
+    }
+    // Apply vertical pass
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let r = 0, g = 0, b = 0, a = 0;
+            for (let ky = -clampedRadius; ky <= clampedRadius; ky++) {
+                const py = Math.max(0, Math.min(height - 1, y + ky));
+                const idx = (py * width + x) * 4;
+                const weight = kernel[ky + clampedRadius];
+                r += temp[idx] * weight;
+                g += temp[idx + 1] * weight;
+                b += temp[idx + 2] * weight;
+                a += temp[idx + 3] * weight;
+            }
+            const outIdx = (y * width + x) * 4;
+            result[outIdx] = Math.round(r);
+            result[outIdx + 1] = Math.round(g);
+            result[outIdx + 2] = Math.round(b);
+            result[outIdx + 3] = Math.round(a);
+        }
+    }
+    return result;
+}
+/**
+ * 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 function sharpen(data, width, height, amount = 0.5) {
+    const result = new Uint8Array(data.length);
+    const clampedAmount = Math.max(0, Math.min(1, amount));
+    // Sharpen kernel (Laplacian-based)
+    // Center weight is 1 + 4*amount, neighbors are -amount
+    const center = 1 + 4 * clampedAmount;
+    const neighbor = -clampedAmount;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = (y * width + x) * 4;
+            let r = data[idx] * center;
+            let g = data[idx + 1] * center;
+            let b = data[idx + 2] * center;
+            // Apply kernel to neighbors (4-connected)
+            const neighbors = [
+                { dx: 0, dy: -1 }, // top
+                { dx: -1, dy: 0 }, // left
+                { dx: 1, dy: 0 }, // right
+                { dx: 0, dy: 1 }, // bottom
+            ];
+            for (const { dx, dy } of neighbors) {
+                const nx = x + dx;
+                const ny = y + dy;
+                if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+                    const nIdx = (ny * width + nx) * 4;
+                    r += data[nIdx] * neighbor;
+                    g += data[nIdx + 1] * neighbor;
+                    b += data[nIdx + 2] * neighbor;
+                }
+            }
+            result[idx] = Math.max(0, Math.min(255, Math.round(r)));
+            result[idx + 1] = Math.max(0, Math.min(255, Math.round(g)));
+            result[idx + 2] = Math.max(0, Math.min(255, Math.round(b)));
+            result[idx + 3] = data[idx + 3]; // Alpha unchanged
+        }
+    }
+    return result;
+}
+/**
+ * Apply sepia tone effect to an image
+ * @param data Image data (RGBA)
+ * @returns New image data with sepia tone applied
+ */
+export function sepia(data) {
+    const result = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const b = data[i + 2];
+        // Sepia transformation matrix
+        result[i] = Math.min(255, Math.round(r * 0.393 + g * 0.769 + b * 0.189));
+        result[i + 1] = Math.min(255, Math.round(r * 0.349 + g * 0.686 + b * 0.168));
+        result[i + 2] = Math.min(255, Math.round(r * 0.272 + g * 0.534 + b * 0.131));
+        result[i + 3] = data[i + 3]; // Alpha unchanged
+    }
+    return result;
+}
+/**
+ * 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 function medianFilter(data, width, height, radius = 1) {
+    const result = new Uint8Array(data.length);
+    const clampedRadius = Math.max(1, Math.floor(radius));
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const rValues = [];
+            const gValues = [];
+            const bValues = [];
+            const aValues = [];
+            // Collect values in kernel window
+            for (let ky = -clampedRadius; ky <= clampedRadius; ky++) {
+                for (let kx = -clampedRadius; kx <= clampedRadius; kx++) {
+                    const px = x + kx;
+                    const py = y + ky;
+                    if (px >= 0 && px < width && py >= 0 && py < height) {
+                        const idx = (py * width + px) * 4;
+                        rValues.push(data[idx]);
+                        gValues.push(data[idx + 1]);
+                        bValues.push(data[idx + 2]);
+                        aValues.push(data[idx + 3]);
+                    }
+                }
+            }
+            // Sort and get median
+            rValues.sort((a, b) => a - b);
+            gValues.sort((a, b) => a - b);
+            bValues.sort((a, b) => a - b);
+            aValues.sort((a, b) => a - b);
+            const mid = Math.floor(rValues.length / 2);
+            const outIdx = (y * width + x) * 4;
+            result[outIdx] = rValues[mid];
+            result[outIdx + 1] = gValues[mid];
+            result[outIdx + 2] = bValues[mid];
+            result[outIdx + 3] = aValues[mid];
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cross-image",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and Bun.",
   "keywords": [
     "image",

package/script/mod.d.ts

@@ -2,7 +2,7 @@
  * @module @cross/image
  *
  * A pure JavaScript, dependency-free, cross-runtime image processing library.
- * Supports decoding, resizing, and encoding common image formats (PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG, PAM, PCX).
+ * Supports decoding, resizing, and encoding common image formats (PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG, PAM, PPM, PCX).
  * Includes image processing capabilities like compositing, level adjustments, and pixel manipulation.
  *
  * @example
@@ -55,5 +55,6 @@ export { ICOFormat } from "./src/formats/ico.js";
 export { DNGFormat } from "./src/formats/dng.js";
 export { PAMFormat } from "./src/formats/pam.js";
 export { PCXFormat } from "./src/formats/pcx.js";
+export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.js";
 //# sourceMappingURL=mod.d.ts.map

package/script/mod.js

@@ -3,7 +3,7 @@
  * @module @cross/image
  *
  * A pure JavaScript, dependency-free, cross-runtime image processing library.
- * Supports decoding, resizing, and encoding common image formats (PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG, PAM, PCX).
+ * Supports decoding, resizing, and encoding common image formats (PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG, PAM, PPM, PCX).
  * Includes image processing capabilities like compositing, level adjustments, and pixel manipulation.
  *
  * @example
@@ -44,7 +44,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASCIIFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
+exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
 var image_js_1 = require("./src/image.js");
 Object.defineProperty(exports, "Image", { enumerable: true, get: function () { return image_js_1.Image; } });
 var png_js_1 = require("./src/formats/png.js");
@@ -69,5 +69,7 @@ var pam_js_1 = require("./src/formats/pam.js");
 Object.defineProperty(exports, "PAMFormat", { enumerable: true, get: function () { return pam_js_1.PAMFormat; } });
 var pcx_js_1 = require("./src/formats/pcx.js");
 Object.defineProperty(exports, "PCXFormat", { enumerable: true, get: function () { return pcx_js_1.PCXFormat; } });
+var ppm_js_1 = require("./src/formats/ppm.js");
+Object.defineProperty(exports, "PPMFormat", { enumerable: true, get: function () { return ppm_js_1.PPMFormat; } });
 var ascii_js_1 = require("./src/formats/ascii.js");
 Object.defineProperty(exports, "ASCIIFormat", { enumerable: true, get: function () { return ascii_js_1.ASCIIFormat; } });

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

@@ -0,0 +1,50 @@
+import type { ImageData, ImageFormat } from "../types.js";
+/**
+ * PPM format handler
+ * Implements the Netpbm PPM (Portable PixMap) format.
+ * This is a simple uncompressed RGB format supported by many image tools.
+ *
+ * Format structure:
+ * - P3 (ASCII format):
+ *   P3
+ *   <width> <height>
+ *   <maxval>
+ *   R G B R G B ... (space-separated decimal values)
+ *
+ * - P6 (Binary format):
+ *   P6
+ *   <width> <height>
+ *   <maxval>
+ *   RGB RGB RGB ... (binary byte data)
+ */
+export declare class PPMFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "ppm";
+    /** MIME type for PPM images */
+    readonly mimeType = "image/x-portable-pixmap";
+    /**
+     * Check if the given data is a PPM image
+     * @param data Raw image data to check
+     * @returns true if data has PPM signature (P3 or P6)
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode PPM image data to RGBA
+     * Supports both P3 (ASCII) and P6 (binary) formats
+     * @param data Raw PPM image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array): Promise<ImageData>;
+    /**
+     * Encode RGBA image data to PPM format (P6 binary)
+     * Note: Alpha channel is ignored as PPM doesn't support transparency
+     * @param imageData Image data to encode
+     * @returns Encoded PPM image bytes
+     */
+    encode(imageData: ImageData): Promise<Uint8Array>;
+    /**
+     * Check if a byte is whitespace (space, tab, CR, LF)
+     */
+    private isWhitespace;
+}
+//# sourceMappingURL=ppm.d.ts.map

package/script/src/formats/ppm.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PPMFormat = void 0;
+const security_js_1 = require("../utils/security.js");
+/**
+ * PPM format handler
+ * Implements the Netpbm PPM (Portable PixMap) format.
+ * This is a simple uncompressed RGB format supported by many image tools.
+ *
+ * Format structure:
+ * - P3 (ASCII format):
+ *   P3
+ *   <width> <height>
+ *   <maxval>
+ *   R G B R G B ... (space-separated decimal values)
+ *
+ * - P6 (Binary format):
+ *   P6
+ *   <width> <height>
+ *   <maxval>
+ *   RGB RGB RGB ... (binary byte data)
+ */
+class PPMFormat {
+    constructor() {
+        /** Format name identifier */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ppm"
+        });
+        /** MIME type for PPM images */
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/x-portable-pixmap"
+        });
+    }
+    /**
+     * Check if the given data is a PPM image
+     * @param data Raw image data to check
+     * @returns true if data has PPM signature (P3 or P6)
+     */
+    canDecode(data) {
+        // Check if data has at least magic bytes
+        if (data.length < 3) {
+            return false;
+        }
+        // Check for P3 or P6 followed by whitespace
+        return data[0] === 0x50 && // P
+            (data[1] === 0x33 || data[1] === 0x36) && // 3 or 6
+            (data[2] === 0x0a || data[2] === 0x0d || data[2] === 0x20 ||
+                data[2] === 0x09); // \n, \r, space, or tab
+    }
+    /**
+     * Decode PPM image data to RGBA
+     * Supports both P3 (ASCII) and P6 (binary) formats
+     * @param data Raw PPM image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid PPM signature");
+        }
+        const isBinary = data[1] === 0x36; // P6
+        // Parse header
+        let offset = 0;
+        let width = 0;
+        let height = 0;
+        let maxval = 0;
+        let headerValues = 0; // Track how many values we've parsed (need 3: width, height, maxval)
+        // Skip magic number and whitespace
+        offset = 2;
+        while (offset < data.length && this.isWhitespace(data[offset])) {
+            offset++;
+        }
+        // Parse header values (width, height, maxval)
+        while (headerValues < 3 && offset < data.length) {
+            // Skip comments (lines starting with #)
+            if (data[offset] === 0x23) { // #
+                // Skip until newline
+                while (offset < data.length && data[offset] !== 0x0a) {
+                    offset++;
+                }
+                if (offset < data.length)
+                    offset++; // Skip the newline
+                continue;
+            }
+            // Skip whitespace
+            while (offset < data.length && this.isWhitespace(data[offset])) {
+                offset++;
+            }
+            // Read number
+            let numStr = "";
+            while (offset < data.length &&
+                !this.isWhitespace(data[offset]) &&
+                data[offset] !== 0x23) {
+                numStr += String.fromCharCode(data[offset]);
+                offset++;
+            }
+            if (numStr) {
+                const num = parseInt(numStr, 10);
+                if (isNaN(num) || num <= 0) {
+                    throw new Error(`Invalid PPM header value: ${numStr}`);
+                }
+                if (headerValues === 0) {
+                    width = num;
+                }
+                else if (headerValues === 1) {
+                    height = num;
+                }
+                else if (headerValues === 2) {
+                    maxval = num;
+                }
+                headerValues++;
+            }
+        }
+        if (headerValues < 3) {
+            throw new Error("Incomplete PPM header");
+        }
+        // Skip single whitespace character after maxval (required by spec)
+        if (offset < data.length && this.isWhitespace(data[offset])) {
+            offset++;
+        }
+        // Validate dimensions
+        (0, security_js_1.validateImageDimensions)(width, height);
+        // Validate maxval
+        if (maxval > 255) {
+            throw new Error(`Unsupported PPM maxval: ${maxval}. Only maxval <= 255 is supported.`);
+        }
+        const pixelCount = width * height;
+        const rgba = new Uint8Array(pixelCount * 4);
+        if (isBinary) {
+            // P6: Binary format
+            const expectedDataLength = pixelCount * 3;
+            const actualDataLength = data.length - offset;
+            if (actualDataLength < expectedDataLength) {
+                throw new Error(`Invalid PPM data length: expected ${expectedDataLength}, got ${actualDataLength}`);
+            }
+            // Read RGB data and convert to RGBA
+            for (let i = 0; i < pixelCount; i++) {
+                const srcIndex = offset + i * 3;
+                const dstIndex = i * 4;
+                rgba[dstIndex] = data[srcIndex]; // R
+                rgba[dstIndex + 1] = data[srcIndex + 1]; // G
+                rgba[dstIndex + 2] = data[srcIndex + 2]; // B
+                rgba[dstIndex + 3] = 255; // A (fully opaque)
+            }
+        }
+        else {
+            // P3: ASCII format
+            let pixelIndex = 0;
+            while (pixelIndex < pixelCount * 3 && offset < data.length) {
+                // Skip whitespace and comments
+                while (offset < data.length) {
+                    if (data[offset] === 0x23) { // #
+                        // Skip comment
+                        while (offset < data.length && data[offset] !== 0x0a) {
+                            offset++;
+                        }
+                        if (offset < data.length)
+                            offset++;
+                    }
+                    else if (this.isWhitespace(data[offset])) {
+                        offset++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // Read number
+                let numStr = "";
+                while (offset < data.length &&
+                    !this.isWhitespace(data[offset]) &&
+                    data[offset] !== 0x23) {
+                    numStr += String.fromCharCode(data[offset]);
+                    offset++;
+                }
+                if (numStr) {
+                    const value = parseInt(numStr, 10);
+                    if (isNaN(value) || value < 0 || value > maxval) {
+                        throw new Error(`Invalid PPM pixel value: ${numStr}`);
+                    }
+                    // Scale to 0-255 if needed
+                    const scaledValue = maxval === 255 ? value : Math.round((value * 255) / maxval);
+                    const component = pixelIndex % 3;
+                    const rgbaIndex = Math.floor(pixelIndex / 3) * 4;
+                    if (component === 0) {
+                        rgba[rgbaIndex] = scaledValue; // R
+                    }
+                    else if (component === 1) {
+                        rgba[rgbaIndex + 1] = scaledValue; // G
+                    }
+                    else {
+                        rgba[rgbaIndex + 2] = scaledValue; // B
+                        rgba[rgbaIndex + 3] = 255; // A
+                    }
+                    pixelIndex++;
+                }
+            }
+            if (pixelIndex < pixelCount * 3) {
+                throw new Error(`Incomplete PPM pixel data: expected ${pixelCount * 3} values, got ${pixelIndex}`);
+            }
+        }
+        return Promise.resolve({ width, height, data: rgba });
+    }
+    /**
+     * Encode RGBA image data to PPM format (P6 binary)
+     * Note: Alpha channel is ignored as PPM doesn't support transparency
+     * @param imageData Image data to encode
+     * @returns Encoded PPM image bytes
+     */
+    encode(imageData) {
+        const { width, height, data } = imageData;
+        // Validate input
+        if (data.length !== width * height * 4) {
+            throw new Error(`Data length mismatch: expected ${width * height * 4}, got ${data.length}`);
+        }
+        // Create header
+        const header = `P6\n${width} ${height}\n255\n`;
+        const encoder = new TextEncoder();
+        const headerBytes = encoder.encode(header);
+        // Create output buffer (header + RGB data)
+        const pixelCount = width * height;
+        const output = new Uint8Array(headerBytes.length + pixelCount * 3);
+        // Write header
+        output.set(headerBytes, 0);
+        // Write RGB pixel data (discard alpha channel)
+        let outputOffset = headerBytes.length;
+        for (let i = 0; i < pixelCount; i++) {
+            const srcIndex = i * 4;
+            output[outputOffset++] = data[srcIndex]; // R
+            output[outputOffset++] = data[srcIndex + 1]; // G
+            output[outputOffset++] = data[srcIndex + 2]; // B
+        }
+        return Promise.resolve(output);
+    }
+    /**
+     * Check if a byte is whitespace (space, tab, CR, LF)
+     */
+    isWhitespace(byte) {
+        return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
+    }
+}
+exports.PPMFormat = PPMFormat;

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

@@ -5,6 +5,10 @@ import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
 export interface TIFFEncodeOptions {
     /** Compression method: "none" for uncompressed (default), "lzw" for LZW compression */
     compression?: "none" | "lzw";
+    /** Encode as grayscale instead of RGB/RGBA */
+    grayscale?: boolean;
+    /** Encode as RGB without alpha channel (ignored if grayscale is true) */
+    rgb?: boolean;
 }
 /**
  * TIFF format handler