Violent Vibration Image Effect Generator

function processImage(originalImg, intensity = "20", layers = "15", rgbSplitAmount = "0.4") {
    // Parse parameters
    const iIntensity = Math.abs(parseFloat(intensity)) || 20;
    const iLayers = Math.abs(parseInt(layers, 10)) || 15;
    const iRgbSplit = Math.abs(parseFloat(rgbSplitAmount)) || 0.4;

    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    const w = originalImg.width;
    const h = originalImg.height;

    canvas.width = w;
    canvas.height = h;

    // Scale up the image slightly to avoid exposing transparent edges when shifting
    const scale = 1 + (iIntensity * 2) / Math.min(w, h);

    // Draw the solid base image
    ctx.save();
    ctx.translate(w / 2, h / 2);
    ctx.scale(scale, scale);
    ctx.drawImage(originalImg, -w / 2, -h / 2, w, h);
    ctx.restore();

    // Draw overlapping vibrating 'ghost' layers for motion blur effect
    ctx.globalAlpha = Math.max(0.05, 2.0 / (iLayers || 1)); // Keeps ghost trails balanced
    for (let i = 0; i < iLayers; i++) {
        // Random offsets and slight angular rotation for a violent random shake
        const offsetX = (Math.random() - 0.5) * 2 * iIntensity;
        const offsetY = (Math.random() - 0.5) * 2 * iIntensity;
        const angle = (Math.random() - 0.5) * (iIntensity / 100);

        ctx.save();
        ctx.translate(w / 2 + offsetX, h / 2 + offsetY);
        ctx.rotate(angle);
        ctx.scale(scale, scale);
        ctx.drawImage(originalImg, -w / 2, -h / 2, w, h);
        ctx.restore();
    }

    // Apply Chromatic Aberration (RGB shift) to amplify the violent, jarring vibe
    const splitPixels = Math.floor(iIntensity * iRgbSplit);
    if (splitPixels > 0) {
        const imgData = ctx.getImageData(0, 0, w, h);
        const data = imgData.data;
        const outputData = new Uint8ClampedArray(data.length);

        for (let y = 0; y < h; y++) {
            for (let x = 0; x < w; x++) {
                const i = (y * w + x) * 4;

                // Shift red channel left and blue channel right
                const rx = Math.max(0, x - splitPixels);
                const bx = Math.min(w - 1, x + splitPixels);

                const iR = (y * w + rx) * 4;
                const iB = (y * w + bx) * 4;

                // Map RGB channels
                outputData[i]     = data[iR];     // Red
                outputData[i + 1] = data[i + 1];  // Green (centered)
                outputData[i + 2] = data[iB + 2]; // Blue

                // Max composite alpha to natively prevent transparent border clipping gaps
                outputData[i + 3] = Math.max(data[iR + 3], data[i + 3], data[iB + 3]);
            }
        }
        
        ctx.putImageData(new ImageData(outputData, w, h), 0, 0);
    }

    return canvas;
}