Update app.py

app.py

@@ -2,12 +2,14 @@ import gradio as gr
 from PIL import Image
 import numpy as np
 
+# Modified 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 ] ],
+    # Red channel from left image, green/blue channels from right image
+    '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 ] ],
-    'optimized': [ [ 0, 0.7, 0.3, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ] ],
+    'optimized': [ [ 0.7, 0.3, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 1 ] ],
 }
 
 def make_anaglyph(left_img, right_img, color_method):
@@ -16,8 +18,8 @@ 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:
@@ -41,11 +43,24 @@ 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])
+            
+            # For true red/cyan anaglyph experience, ensure pure colors
+            if color_method == 'color' or color_method == 'true':
+                # Ensure pure red from left image (no green or blue)
+                g = 0 if r > 0 else g
+                b = 0 if r > 0 else b
+            
+            # Clamp values to 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 +71,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 +80,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':
@@ -95,59 +105,53 @@ def process_images(left_img, right_img, method, color_method):
         return make_stereopair(right_img, left_img, color_method)
     return None
 
-css="""
-div#col-container{
-    margin: 0 auto;
-    max-width: 1340px;
-}
-"""
 # Create the Gradio interface
-with gr.Blocks(css=css) as app:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown("# 3D Anaglyph Image Generator")
-        gr.Markdown("Upload left and right images to create 3D images using different methods.")
-        
-        with gr.Row():
-            with gr.Column():
-                 
-                with gr.Row():
-                    with gr.Column():
-                        left_input = gr.Image(label="Left Image")
-                    with gr.Column():
-                        right_input = gr.Image(label="Right Image")
-            
-                method = gr.Radio(
-                    ["anaglyph", "parallel", "crossed"], 
-                    label="Method", 
-                    value="anaglyph",
-                    info="Select the 3D image creation method"
-                )
-                    
-                color_method = gr.Radio(
-                    ["optimized", "true", "mono", "color", "halfcolor"], 
-                    label="Color Method", 
-                    value="optimized",
-                    info="Select the color processing method"
-                )
-        
-                generate_btn = gr.Button("Generate 3D Image", variant="primary")
-
-                gr.Markdown("""
-                ### Methods:
-                - **anaglyph**: Creates a red-cyan 3D image (requires 3D glasses)
-                - **parallel**: Creates side-by-side images for parallel viewing
-                - **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)
-                - **halfcolor**: Balance between color and depth
-                """)
-    
-            output = gr.Image(label="Generated 3D Anaglyph Image")
-        
+with gr.Blocks(title="3D Image Generator") as app:
+    gr.Markdown("# 3D Image Generator")
+    gr.Markdown("Upload left and right images to create 3D images using different methods.")
+    
+    with gr.Row():
+        with gr.Column():
+            left_input = gr.Image(label="Left Image")
+        with gr.Column():
+            right_input = gr.Image(label="Right Image")
+    
+    with gr.Row():
+        with gr.Column():
+            method = gr.Radio(
+                ["anaglyph", "parallel", "crossed"], 
+                label="Method", 
+                value="anaglyph",
+                info="Select the 3D image creation method"
+            )
+        with gr.Column():
+            color_method = gr.Radio(
+                ["true", "color", "optimized", "halfcolor", "mono"], 
+                label="Color Method", 
+                value="true",
+                info="Select the color processing method"
+            )
+    
+    generate_btn = gr.Button("Generate 3D Image", variant="primary")
+    
+    output = gr.Image(label="Generated 3D Image")
+    
+    gr.Markdown("""
+    ### Methods:
+    - **anaglyph**: Creates a red-cyan 3D image (requires 3D glasses)
+    - **parallel**: Creates side-by-side images for parallel viewing
+    - **crossed**: Creates side-by-side images for cross-eyed viewing
+    
+    ### Color Methods for Anaglyphs:
+    - **true**: Pure red-cyan anaglyph (best for 3D glasses, recommended)
+    - **color**: Full color anaglyph with pure red-cyan separation
+    - **optimized**: Balanced color and depth perception
+    - **halfcolor**: Preserves some color while maintaining depth
+    - **mono**: Monochrome output
+    
+    For best results with red-cyan glasses, use 'true' or 'color' methods.
+    """)
+    
     generate_btn.click(
         fn=process_images,
         inputs=[left_input, right_input, method, color_method],