Update app.py

app.py

@@ -2,10 +2,8 @@ import gradio as gr
 from PIL import Image
 import numpy as np
 
-# Fixed matrices for proper red/cyan anaglyph viewing
 matrices = {
-    # 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 ] ],
+    '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 ] ],
     '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 ] ],
@@ -18,19 +16,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).convert('RGB')
-    right = Image.fromarray(right_img).convert('RGB')
+    left = Image.fromarray(left_img)
+    right = Image.fromarray(right_img)
     
     # 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 new blank image to put the anaglyph into
-    width, height = left.size
-    result = Image.new('RGB', (width, height))
+    # Create a copy of the left image to modify
+    result = left.copy()
     
     # Get the pixel maps
+    width, height = left.size
     leftMap = left.load()
     rightMap = right.load()
     resultMap = result.load()
@@ -43,18 +41,11 @@ 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]
-            
-            # 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)
+            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])
+            )
     
     # Convert back to numpy array for Gradio
     return np.array(result)
@@ -65,8 +56,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).convert('RGB')
-    right = Image.fromarray(right_img).convert('RGB')
+    left = Image.fromarray(left_img)
+    right = Image.fromarray(right_img)
     
     # Check if both images have the same dimensions
     if left.size != right.size:
@@ -74,13 +65,18 @@ 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()
     
-    # Paste the left and right images side by side
-    pair.paste(left, (0, 0))
-    pair.paste(right, (width, 0))
+    # 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]
     
     # Convert to monochrome if required
     if color_method == 'mono':
@@ -128,9 +124,9 @@ with gr.Blocks(css=css) as app:
                 )
                     
                 color_method = gr.Radio(
-                    ["true", "color", "optimized", "halfcolor", "mono"], 
+                    ["optimized", "true", "mono", "color", "halfcolor"], 
                     label="Color Method", 
-                    value="true",
+                    value="optimized",
                     info="Select the color processing method"
                 )
         
@@ -143,11 +139,11 @@ with gr.Blocks(css=css) as app:
                 - **crossed**: Creates side-by-side images for cross-eyed viewing
                 
                 ### Color Methods:
-                - **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
+                - **optimized**: Best for most images (default)
+                - **true**: True color anaglyph
                 - **mono**: Monochrome output
+                - **color**: Full color (may cause ghosting)
+                - **halfcolor**: Balance between color and depth
                 """)
     
             output = gr.Image(label="Generated 3D Anaglyph Image")