MrHorseShoe Major Image Effect Generator

function processImage(originalImg, bendStrength = '75', applyMajorColor = 'true', backgroundColor = '#000000') {
    // The "MrHorseShoe Major" effect combines a geometric horseshoe distortion and a vivid G-Major (inverted high-contrast red) color filter.
    const intensity = Math.min(100, Math.max(0, parseFloat(bendStrength)));
    const doMajor = String(applyMajorColor).toLowerCase() === 'true';

    // Parse background color for areas out of bounds of the horseshoe warp
    let bgR = 0, bgG = 0, bgB = 0, bgA = 0;
    if (typeof backgroundColor === 'string' && backgroundColor.startsWith('#')) {
        let hex = backgroundColor.replace('#', '');
        if (hex.length === 3) {
            bgR = parseInt(hex[0] + hex[0], 16);
            bgG = parseInt(hex[1] + hex[1], 16);
            bgB = parseInt(hex[2] + hex[2], 16);
            bgA = 255;
        } else if (hex.length === 6) {
            bgR = parseInt(hex.substring(0, 2), 16);
            bgG = parseInt(hex.substring(2, 4), 16);
            bgB = parseInt(hex.substring(4, 6), 16);
            bgA = 255;
        }
    }

    const canvas = document.createElement('canvas');
    const W = originalImg.width;
    const H = originalImg.height;
    
    if (W === 0 || H === 0) return canvas;

    canvas.width = W;
    canvas.height = H;
    const ctx = canvas.getContext('2d');
    ctx.drawImage(originalImg, 0, 0);

    try {
        const srcData = ctx.getImageData(0, 0, W, H);
        const dstData = ctx.createImageData(W, H);

        const cx = W / 2;
        const cy = H * 0.8; // Lower center for horseshoe bend
        const R_in = H * 0.2;
        const R_out = H * 0.8;
        
        const maxAngle = Math.PI * (intensity / 100); 

        for (let y = 0; y < H; y++) {
            for (let x = 0; x < W; x++) {
                const dx = x - cx;
                const dy = cy - y; 
                
                // Polar coordinates map
                const r = Math.sqrt(dx * dx + dy * dy);
                const theta = Math.atan2(dx, dy);

                let srcY = y;
                let srcX = x;

                if (intensity > 0.1) {
                    srcY = H * (R_out - r) / (R_out - R_in);
                    srcX = W * ((theta / maxAngle) * 0.5 + 0.5);
                }

                const dstIdx = (y * W + x) * 4;

                // Bilinear Interpolation check for mapping
                if (srcX >= 0 && srcX <= W - 1 && srcY >= 0 && srcY <= H - 1) {
                    const x1 = Math.floor(srcX);
                    const y1 = Math.floor(srcY);
                    const x2 = Math.min(x1 + 1, W - 1);
                    const y2 = Math.min(y1 + 1, H - 1);

                    const fx = srcX - x1;
                    const fy = srcY - y1;

                    const p1 = (y1 * W + x1) * 4;
                    const p2 = (y1 * W + x2) * 4;
                    const p3 = (y2 * W + x1) * 4;
                    const p4 = (y2 * W + x2) * 4;

                    let vals = [0, 0, 0, 0];
                    for (let c = 0; c < 4; c++) {
                        vals[c] =
                            srcData.data[p1 + c] * (1 - fx) * (1 - fy) +
                            srcData.data[p2 + c] * fx * (1 - fy) +
                            srcData.data[p3 + c] * (1 - fx) * fy +
                            srcData.data[p4 + c] * fx * fy;
                    }

                    // Apply the "Major" aesthetic color filter
                    if (doMajor && vals[3] > 0) {
                        let currR = 255 - vals[0];
                        let currG = 255 - vals[1];
                        let currB = 255 - vals[2];
                        
                        // Heavily dramatize red channel contrast
                        currR = (currR - 128) * 1.5 + 128 + 50;
                        // Mute and darken green and blue channels
                        currG = (currG - 128) * 1.2 + 128 - 30;
                        currB = (currB - 128) * 1.2 + 128 - 30;
                        
                        vals[0] = Math.min(255, Math.max(0, currR));
                        vals[1] = Math.min(255, Math.max(0, currG));
                        vals[2] = Math.min(255, Math.max(0, currB));
                    }

                    for (let c = 0; c < 4; c++) {
                        dstData.data[dstIdx + c] = vals[c];
                    }
                } else {
                    // Paint background colors for undefined coordinate borders
                    dstData.data[dstIdx] = bgR;
                    dstData.data[dstIdx + 1] = bgG;
                    dstData.data[dstIdx + 2] = bgB;
                    dstData.data[dstIdx + 3] = bgA;
                }
            }
        }
        ctx.putImageData(dstData, 0, 0);
    } catch (err) {
        // Fallback for tainted canvas CORS issues
        console.error("MrHorseShoe Major Image Effect Generator encountered an error (likely a tainted Canvas/CORS image error):", err);
    }

    return canvas;
}