Update app.py

app.py

@@ -2,14 +2,12 @@ import gradio as gr
 from PIL import Image
 import numpy as np
 
-# Modified matrices for proper red/cyan anaglyph viewing
 matrices = {
-    # 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 ] ],
+    '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 ] ],
-    'optimized': [ [ 0.7, 0.3, 0, 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 ] ],
 }
 
 def make_anaglyph(left_img, right_img, color_method):
@@ -18,8 +16,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).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:
@@ -43,24 +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])
-            
-            # 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)
+            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)
@@ -71,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:
@@ -80,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':
@@ -105,53 +95,59 @@ 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(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.
-    """)
-    
+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")
+        
     generate_btn.click(
         fn=process_images,
         inputs=[left_input, right_input, method, color_method],