Spaces:

multimodalart
/

gpt-yellow-tint-corrector

Running

App Files Files Community

multimodalart HF Staff commited on Aug 11

Commit

62b2e90

verified ·

1 Parent(s): 2435420

Update index.html

Browse files

Files changed (1) hide show

index.html +127 -36

index.html CHANGED Viewed

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>ChatGPT Yellow Tint Corrector</title>
     <style>
         * {
             margin: 0;
@@ -280,7 +280,7 @@
 </head>
 <body>
     <div class="container">
-        <h1>ChatGPT Yellow Tint Corrector</h1>
         <div class="upload-area" id="uploadArea">
             <p>Drop image(s) here or click to upload</p>
@@ -562,40 +562,8 @@
                 const width = imageData.width;
                 const height = imageData.height;
-                // Step 1: Robust color correction
-                const { avgR, avgG, avgB } = this.robustMean(data);
-                // Detect yellow tint severity
-                const yellowFactor = ((avgR + avgG) / 2) / (avgB + 1);
-                const yellowSeverity = Math.min(Math.max((yellowFactor - 1.0) / 0.5, 0), 1);
-                // Adaptive correction based on tint level
-                const targetGray = 165 + yellowSeverity * 20;
-                const blueBoost = 1.08 + yellowSeverity * 0.12;
-                const redReduction = 0.96 - yellowSeverity * 0.04;
-                let scaleB = (targetGray * blueBoost) / avgB;
-                let scaleG = targetGray / avgG;
-                let scaleR = (targetGray * redReduction) / avgR;
-                // Apply safety limits
-                scaleB = Math.min(Math.max(scaleB, 0.7), 3.0);
-                scaleG = Math.min(Math.max(scaleG, 0.7), 2.5);
-                scaleR = Math.min(Math.max(scaleR, 0.7), 2.5);
-                // Apply channel scaling
-                for (let i = 0; i < data.length; i += 4) {
-                    data[i] *= scaleR;
-                    data[i + 1] *= scaleG;
-                    data[i + 2] *= scaleB;
-                }
-                // Clip
-                for (let i = 0; i < data.length; i += 4) {
-                    data[i] = Math.min(255, Math.max(0, data[i]));
-                    data[i + 1] = Math.min(255, Math.max(0, data[i + 1]));
-                    data[i + 2] = Math.min(255, Math.max(0, data[i + 2]));
-                }
                 // Step 2: Adaptive exposure compensation
                 const meanBrightness = this.calculateMeanBrightness(data);
@@ -640,6 +608,129 @@
                 return new ImageData(result, width, height);
             }
             robustMean(data) {
                 const rValues = [];
                 const gValues = [];

 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ChatGPT yellow tint corrector</title>
     <style>
         * {
             margin: 0;
 </head>
 <body>
     <div class="container">
+        <h1>ChatGPT yellow tint corrector</h1>
         <div class="upload-area" id="uploadArea">
             <p>Drop image(s) here or click to upload</p>
                 const width = imageData.width;
                 const height = imageData.height;
+                // Step 1: Smart white balance with feedback
+                this.smartWhiteBalance(data);
                 // Step 2: Adaptive exposure compensation
                 const meanBrightness = this.calculateMeanBrightness(data);
                 return new ImageData(result, width, height);
             }
+            smartWhiteBalance(data) {
+                // Find what should be white in the image
+                const whitePoint = this.findWhitePoint(data);
+                if (!whitePoint) {
+                    // No clear white point, use robust mean method with full correction
+                    this.fallbackWhiteBalance(data);
+                    return;
+                }
+                // Calculate correction needed to make the white point actually white
+                const targetWhite = 255; // Pure white target
+                // Calculate multipliers
+                let scaleR = targetWhite / whitePoint.r;
+                let scaleG = targetWhite / whitePoint.g;
+                let scaleB = targetWhite / whitePoint.b;
+                // Normalize scales relative to green (most accurate channel)
+                const baseScale = scaleG;
+                scaleR = scaleR / baseScale;
+                scaleB = scaleB / baseScale;
+                scaleG = scaleG / baseScale;
+                // Apply overall brightness adjustment to reach target
+                const brightnessFactor = baseScale;
+                scaleR *= brightnessFactor;
+                scaleG *= brightnessFactor;
+                scaleB *= brightnessFactor;
+                // Apply safety limits but allow more aggressive correction
+                scaleR = Math.min(Math.max(scaleR, 0.5), 3.0);
+                scaleG = Math.min(Math.max(scaleG, 0.5), 3.0);
+                scaleB = Math.min(Math.max(scaleB, 0.5), 3.5); // Allow more blue boost
+                // Apply correction
+                for (let i = 0; i < data.length; i += 4) {
+                    data[i] *= scaleR;
+                    data[i + 1] *= scaleG;
+                    data[i + 2] *= scaleB;
+                    data[i] = Math.min(255, Math.max(0, data[i]));
+                    data[i + 1] = Math.min(255, Math.max(0, data[i + 1]));
+                    data[i + 2] = Math.min(255, Math.max(0, data[i + 2]));
+                }
+            }
+            findWhitePoint(data) {
+                // Find pixels that should be white
+                // These are bright pixels with low color variation
+                const candidates = [];
+                for (let i = 0; i < data.length; i += 40) { // Sample every 10th pixel for speed
+                    const r = data[i];
+                    const g = data[i + 1];
+                    const b = data[i + 2];
+                    const brightness = 0.299 * r + 0.587 * g + 0.114 * b;
+                    const max = Math.max(r, g, b);
+                    const min = Math.min(r, g, b);
+                    const saturation = max > 0 ? (max - min) / max : 0;
+                    // Look for bright, desaturated pixels
+                    if (brightness > 190 && saturation < 0.2) { // Slightly lower threshold to catch more whites
+                        candidates.push({ r, g, b, brightness });
+                    }
+                }
+                if (candidates.length === 0) {
+                    return null;
+                }
+                // Sort by brightness and take top 2% (more selective)
+                candidates.sort((a, b) => b.brightness - a.brightness);
+                const topCount = Math.max(1, Math.floor(candidates.length * 0.02));
+                // Average the top candidates
+                let sumR = 0, sumG = 0, sumB = 0;
+                for (let i = 0; i < topCount; i++) {
+                    sumR += candidates[i].r;
+                    sumG += candidates[i].g;
+                    sumB += candidates[i].b;
+                }
+                return {
+                    r: sumR / topCount,
+                    g: sumG / topCount,
+                    b: sumB / topCount
+                };
+            }
+            fallbackWhiteBalance(data) {
+                // Full correction when no clear white point (not conservative)
+                const { avgR, avgG, avgB } = this.robustMean(data);
+                // Detect yellow tint severity
+                const yellowFactor = ((avgR + avgG) / 2) / (avgB + 1);
+                const yellowSeverity = Math.min(Math.max((yellowFactor - 1.0) / 0.5, 0), 1);
+                // Full correction strength (same as original)
+                const targetGray = 165 + yellowSeverity * 20;
+                const blueBoost = 1.08 + yellowSeverity * 0.12;
+                const redReduction = 0.96 - yellowSeverity * 0.04;
+                let scaleB = (targetGray * blueBoost) / avgB;
+                let scaleG = targetGray / avgG;
+                let scaleR = (targetGray * redReduction) / avgR;
+                // Safety limits
+                scaleB = Math.min(Math.max(scaleB, 0.7), 3.0);
+                scaleG = Math.min(Math.max(scaleG, 0.7), 2.5);
+                scaleR = Math.min(Math.max(scaleR, 0.7), 2.5);
+                // Apply correction
+                for (let i = 0; i < data.length; i += 4) {
+                    data[i] *= scaleR;
+                    data[i + 1] *= scaleG;
+                    data[i + 2] *= scaleB;
+                    data[i] = Math.min(255, Math.max(0, data[i]));
+                    data[i + 1] = Math.min(255, Math.max(0, data[i + 1]));
+                    data[i + 2] = Math.min(255, Math.max(0, data[i + 2]));
+                }
+            }
             robustMean(data) {
                 const rValues = [];
                 const gValues = [];