cross-image 0.2.1 → 0.2.3

package/script/src/utils/image_processing.js

@@ -9,10 +9,21 @@ exports.adjustBrightness = adjustBrightness;
 exports.adjustContrast = adjustContrast;
 exports.adjustExposure = adjustExposure;
 exports.adjustSaturation = adjustSaturation;
+exports.adjustHue = adjustHue;
 exports.invert = invert;
 exports.grayscale = grayscale;
 exports.fillRect = fillRect;
 exports.crop = crop;
+exports.boxBlur = boxBlur;
+exports.gaussianBlur = gaussianBlur;
+exports.sharpen = sharpen;
+exports.sepia = sepia;
+exports.medianFilter = medianFilter;
+exports.rotate90 = rotate90;
+exports.rotate180 = rotate180;
+exports.rotate270 = rotate270;
+exports.flipHorizontal = flipHorizontal;
+exports.flipVertical = flipVertical;
 /**
  * Composite one image on top of another at a specified position
  * @param base Base image data (RGBA)
@@ -142,6 +153,99 @@ function adjustSaturation(data, amount) {
     }
     return result;
 }
+/**
+ * Convert RGB to HSL color space
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @returns HSL values: [h (0-360), s (0-1), l (0-1)]
+ */
+function rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const delta = max - min;
+    let h = 0;
+    let s = 0;
+    const l = (max + min) / 2;
+    if (delta !== 0) {
+        s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+        if (max === r) {
+            h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+        }
+        else if (max === g) {
+            h = ((b - r) / delta + 2) / 6;
+        }
+        else {
+            h = ((r - g) / delta + 4) / 6;
+        }
+    }
+    return [h * 360, s, l];
+}
+/**
+ * Convert HSL to RGB color space
+ * @param h Hue (0-360)
+ * @param s Saturation (0-1)
+ * @param l Lightness (0-1)
+ * @returns RGB values: [r (0-255), g (0-255), b (0-255)]
+ */
+function hslToRgb(h, s, l) {
+    h = h / 360;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // Achromatic
+    }
+    else {
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+/**
+ * Adjust hue of an image by rotating the hue wheel
+ * @param data Image data (RGBA)
+ * @param degrees Hue rotation in degrees (any value accepted, wraps at 360)
+ * @returns New image data with adjusted hue
+ */
+function adjustHue(data, degrees) {
+    const result = new Uint8Array(data.length);
+    // Normalize rotation to -180 to 180 range
+    const rotation = ((degrees % 360) + 360) % 360;
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const b = data[i + 2];
+        // Convert to HSL
+        const [h, s, l] = rgbToHsl(r, g, b);
+        // Rotate hue
+        const newH = (h + rotation) % 360;
+        // Convert back to RGB
+        const [newR, newG, newB] = hslToRgb(newH, s, l);
+        result[i] = newR;
+        result[i + 1] = newG;
+        result[i + 2] = newB;
+        result[i + 3] = data[i + 3]; // Preserve alpha
+    }
+    return result;
+}
 /**
  * Invert colors of an image
  * @param data Image data (RGBA)
@@ -240,3 +344,350 @@ 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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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;
+}
+/**
+ * Rotate image 90 degrees clockwise
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+function rotate90(data, width, height) {
+    const result = new Uint8Array(data.length);
+    const newWidth = height;
+    const newHeight = width;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = height - 1 - y;
+            const dstY = x;
+            const dstIdx = (dstY * newWidth + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return { data: result, width: newWidth, height: newHeight };
+}
+/**
+ * Rotate image 180 degrees
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with same dimensions
+ */
+function rotate180(data, width, height) {
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = width - 1 - x;
+            const dstY = height - 1 - y;
+            const dstIdx = (dstY * width + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return result;
+}
+/**
+ * Rotate image 270 degrees clockwise (or 90 degrees counter-clockwise)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+function rotate270(data, width, height) {
+    const result = new Uint8Array(data.length);
+    const newWidth = height;
+    const newHeight = width;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = y;
+            const dstY = width - 1 - x;
+            const dstIdx = (dstY * newWidth + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return { data: result, width: newWidth, height: newHeight };
+}
+/**
+ * Flip image horizontally (mirror)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+function flipHorizontal(data, width, height) {
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = width - 1 - x;
+            const dstIdx = (y * width + dstX) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return result;
+}
+/**
+ * Flip image vertically
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+function flipVertical(data, width, height) {
+    const result = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstY = height - 1 - y;
+            const dstIdx = (dstY * width + x) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return result;
+}

package/script/src/utils/metadata/xmp.d.ts

@@ -0,0 +1,52 @@
+/**
+ * XMP (Extensible Metadata Platform) parsing and writing utilities
+ *
+ * This module provides utilities for reading and writing XMP metadata in image files.
+ * It supports Dublin Core, EXIF, and Photoshop namespaces.
+ */
+import type { ImageMetadata } from "../../types.js";
+/**
+ * XMP namespace URIs
+ */
+export declare const XMP_NAMESPACES: {
+    readonly RDF: "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+    readonly DC: "http://purl.org/dc/elements/1.1/";
+    readonly XMP: "http://ns.adobe.com/xap/1.0/";
+    readonly EXIF: "http://ns.adobe.com/exif/1.0/";
+    readonly TIFF: "http://ns.adobe.com/tiff/1.0/";
+    readonly PHOTOSHOP: "http://ns.adobe.com/photoshop/1.0/";
+    readonly XMP_RIGHTS: "http://ns.adobe.com/xap/1.0/rights/";
+};
+/**
+ * XMP Dublin Core field mapping to ImageMetadata
+ */
+export interface XMPFieldMapping {
+    xmpPath: string;
+    metadataKey: keyof ImageMetadata;
+    namespace: string;
+}
+/**
+ * Supported XMP fields and their mappings
+ */
+export declare const XMP_FIELD_MAPPINGS: XMPFieldMapping[];
+/**
+ * Escape XML special characters
+ */
+export declare function escapeXML(str: string): string;
+/**
+ * Unescape XML special characters
+ */
+export declare function unescapeXML(str: string): string;
+/**
+ * Parse XMP metadata from XML string
+ */
+export declare function parseXMP(xmpStr: string): Partial<ImageMetadata>;
+/**
+ * Create XMP packet from metadata
+ */
+export declare function createXMP(metadata: Partial<ImageMetadata>): string;
+/**
+ * Get list of supported XMP metadata fields
+ */
+export declare function getSupportedXMPFields(): Array<keyof ImageMetadata>;
+//# sourceMappingURL=xmp.d.ts.map