Update app.py

app.py

@@ -2,8 +2,10 @@ import gradio as gr
 from PIL import Image
 import numpy as np
 
+# Fixed matrices for proper red/cyan anaglyph viewing
 matrices = {
-    'true': [ [ 0.299, 0.587, 0.114, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0.299, 0.587, 0.114 ] ],
+    # For true red/cyan anaglyphs, we need strict channel separation
+    'true': [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ] ],
     'mono': [ [ 0.299, 0.587, 0.114, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0.299, 0.587, 0.114, 0.299, 0.587, 0.114 ] ],
     'color': [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ] ],
     'halfcolor': [ [ 0.299, 0.587, 0.114, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ] ],
@@ -16,19 +18,19 @@ def make_anaglyph(left_img, right_img, color_method):
         return None
     
     # Convert from numpy array (from Gradio) to PIL Image
-    left = Image.fromarray(left_img)
-    right = Image.fromarray(right_img)
+    left = Image.fromarray(left_img).convert('RGB')
+    right = Image.fromarray(right_img).convert('RGB')
     
     # Check if both images have the same dimensions
     if left.size != right.size:
         # Resize right image to match left image dimensions
         right = right.resize(left.size, Image.LANCZOS)
     
-    # Create a copy of the left image to modify
-    result = left.copy()
+    # Create a new blank image to put the anaglyph into
+    width, height = left.size
+    result = Image.new('RGB', (width, height))
     
     # Get the pixel maps
-    width, height = left.size
     leftMap = left.load()
     rightMap = right.load()
     resultMap = result.load()
@@ -41,11 +43,18 @@ def make_anaglyph(left_img, right_img, color_method):
         for x in range(0, width):
             r1, g1, b1 = leftMap[x, y]
             r2, g2, b2 = rightMap[x, y]
-            resultMap[x, y] = (
-                int(r1*m[0][0] + g1*m[0][1] + b1*m[0][2] + r2*m[1][0] + g2*m[1][1] + b2*m[1][2]),
-                int(r1*m[0][3] + g1*m[0][4] + b1*m[0][5] + r2*m[1][3] + g2*m[1][4] + b2*m[1][5]),
-                int(r1*m[0][6] + g1*m[0][7] + b1*m[0][8] + r2*m[1][6] + g2*m[1][7] + b2*m[1][8])
-            )
+            
+            # Calculate new RGB values
+            r = int(r1*m[0][0] + g1*m[0][1] + b1*m[0][2] + r2*m[1][0] + g2*m[1][1] + b2*m[1][2])
+            g = int(r1*m[0][3] + g1*m[0][4] + b1*m[0][5] + r2*m[1][3] + g2*m[1][4] + b2*m[1][5])
+            b = int(r1*m[0][6] + g1*m[0][7] + b1*m[0][8] + r2*m[1][6] + g2*m[1][7] + b2*m[1][8])
+            
+            # Ensure values are in valid range
+            r = max(0, min(255, r))
+            g = max(0, min(255, g))
+            b = max(0, min(255, b))
+            
+            resultMap[x, y] = (r, g, b)
     
     # Convert back to numpy array for Gradio
     return np.array(result)
@@ -56,8 +65,8 @@ def make_stereopair(left_img, right_img, color_method):
         return None
     
     # Convert from numpy array (from Gradio) to PIL Image
-    left = Image.fromarray(left_img)
-    right = Image.fromarray(right_img)
+    left = Image.fromarray(left_img).convert('RGB')
+    right = Image.fromarray(right_img).convert('RGB')
     
     # Check if both images have the same dimensions
     if left.size != right.size:
@@ -65,18 +74,13 @@ def make_stereopair(left_img, right_img, color_method):
         right = right.resize(left.size, Image.LANCZOS)
     
     width, height = left.size
-    leftMap = left.load()
-    rightMap = right.load()
     
     # Create a new image twice as wide
     pair = Image.new('RGB', (width * 2, height))
-    pairMap = pair.load()
     
-    # Copy the left and right images side by side
-    for y in range(0, height):
-        for x in range(0, width):
-            pairMap[x, y] = leftMap[x, y]
-            pairMap[x + width, y] = rightMap[x, y]
+    # Paste the left and right images side by side
+    pair.paste(left, (0, 0))
+    pair.paste(right, (width, 0))
     
     # Convert to monochrome if required
     if color_method == 'mono':
@@ -124,9 +128,9 @@ with gr.Blocks(css=css) as app:
                 )
                     
                 color_method = gr.Radio(
-                    ["optimized", "true", "mono", "color", "halfcolor"], 
+                    ["true", "color", "optimized", "halfcolor", "mono"], 
                     label="Color Method", 
-                    value="optimized",
+                    value="true",
                     info="Select the color processing method"
                 )
         
@@ -139,11 +143,11 @@ with gr.Blocks(css=css) as app:
                 - **crossed**: Creates side-by-side images for cross-eyed viewing
                 
                 ### Color Methods:
-                - **optimized**: Best for most images (default)
-                - **true**: True color anaglyph
-                - **mono**: Monochrome output
-                - **color**: Full color (may cause ghosting)
+                - **true**: Pure red-cyan anaglyph (best for 3D glasses)
+                - **color**: Same as true for red-cyan glasses
+                - **optimized**: Better color perception but may cause ghosting
                 - **halfcolor**: Balance between color and depth
+                - **mono**: Monochrome output
                 """)
     
             output = gr.Image(label="Generated 3D Anaglyph Image")