Image Night Vision Filter Effect Tool

function processImage(originalImg, amplification = 1.5, blueTintFactor = 0.2) {
    // Parse and validate parameters to ensure they are numbers and within expected ranges
    let numAmplification = Number(amplification);
    if (isNaN(numAmplification) || numAmplification < 0) {
        numAmplification = 1.5; // Default amplification if parsing fails or value is invalid
    }

    let numBlueTintFactor = Number(blueTintFactor);
    if (isNaN(numBlueTintFactor) || numBlueTintFactor < 0 || numBlueTintFactor > 1) {
        numBlueTintFactor = 0.2; // Default blueTintFactor if parsing fails or value is out of [0,1] range
    }

    const canvas = document.createElement('canvas');
    // Optimization hint for frequent readbacks, though for a single operation effect might be minor.
    const ctx = canvas.getContext('2d', { willReadFrequently: true });

    const imageWidth = originalImg.naturalWidth;
    const imageHeight = originalImg.naturalHeight;

    canvas.width = imageWidth;
    canvas.height = imageHeight;

    // If image dimensions are zero (e.g., image not loaded), return an empty canvas.
    if (imageWidth === 0 || imageHeight === 0) {
        return canvas;
    }

    ctx.drawImage(originalImg, 0, 0, imageWidth, imageHeight);

    // Get the image data from the canvas.
    // Note: This can throw a security error if the image is cross-origin and lacks CORS headers.
    // The problem implies originalImg is usable.
    let imageData;
    try {
        imageData = ctx.getImageData(0, 0, imageWidth, imageHeight);
    } catch (e) {
        console.error("Error getting image data: ", e);
        // Return the canvas with the original image drawn, if processing fails
        return canvas;
    }
    
    const data = imageData.data;
    
    // Iterate over each pixel (RGBA)
    for (let i = 0; i < data.length; i += 4) {
        const r = data[i];
        const g = data[i + 1];
        const b = data[i + 2];
        // const alpha = data[i + 3]; // Alpha channel is preserved

        // Calculate luminance (perceived brightness) using the standard NTSC conversion formula
        const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
        
        // Amplify luminance for the night vision effect
        const amplifiedLuminance = luminance * numAmplification;
        
        // Calculate the green channel value, clamping to the 0-255 range
        // This is the primary color for the night vision effect
        const greenValue = Math.max(0, Math.min(255, Math.floor(amplifiedLuminance)));
        
        // Calculate the blue channel value, also clamped
        // This adds a common cyan-ish tint to the green, based on the blueTintFactor
        const blueValue = Math.max(0, Math.min(255, Math.floor(amplifiedLuminance * numBlueTintFactor)));

        // Apply the night vision colors
        data[i] = 0;           // Set Red channel to 0 (or a very dark green component if desired)
        data[i + 1] = greenValue;  // Set Green channel to the calculated amplified luminance
        data[i + 2] = blueValue;   // Set Blue channel to introduce a tint
        // data[i + 3] (alpha) remains unchanged
    }

    // Put the modified image data back onto the canvas
    ctx.putImageData(imageData, 0, 0);

    return canvas;
}