Upload 17 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assests/left.jpg filter=lfs diff=lfs merge=lfs -text
+assests/left1.jpg filter=lfs diff=lfs merge=lfs -text
+assests/right.jpg filter=lfs diff=lfs merge=lfs -text
+assests/right1.jpg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,16 @@
+from src.gradio_interface import generate_anaglyph
+import gradio as gr
+
+iface = gr.Interface(
+    fn=generate_anaglyph,
+    inputs=[
+        gr.Image(type="filepath", label="Upload Person Image"),
+        gr.Image(type="filepath", label="Upload Left Stereoscopic Image"),
+        gr.Image(type="filepath", label="Upload Right Stereoscopic Image"),
+        gr.Dropdown(["", "close", "medium", "far"], label="Depth Level"),
+    ],
+    outputs=gr.Image(label="Anaglyph Image"),
+)
+
+if __name__ == "__main__":
+    iface.launch()

requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+opencv-python
+Pillow
+gradio

src/anaglyph_converter.py

@@ -0,0 +1,21 @@
+import cv2
+import numpy as np
+
+
+def create_anaglyph(left_image, right_image):
+    # Ensure both images have the same dimensions
+    height, width = left_image.shape[:2]
+    right_image_resized = cv2.resize(right_image, (width, height))
+
+    # Extract the red channel from the left image and green-blue channels from the resized right image
+    left_red = left_image[:, :, 2]  # Red channel from left image
+    right_green_blue = right_image_resized[
+        :, :, :2
+    ]  # Green and blue channels from right image
+
+    # Combine channels into a single anaglyph image
+    anaglyph = np.zeros_like(left_image)
+    anaglyph[:, :, 2] = left_red  # Red channel from left image
+    anaglyph[:, :, :2] = right_green_blue  # Green and blue channels from right image
+
+    return anaglyph

src/gradio_interface.py

@@ -0,0 +1,41 @@
+from src.segmentation import segment_person
+from src.stereoscopic_insert import insert_person
+from src.anaglyph_converter import create_anaglyph
+import cv2
+from PIL import Image
+
+
+def generate_anaglyph(
+    person_image_path, left_image_path, right_image_path, depth="medium"
+):
+    """
+    Generate an anaglyph 3D image by segmenting a person from an uploaded image,
+    inserting the segmented person into a stereoscopic pair, and converting the result
+    to an anaglyph format.
+
+    Parameters:
+    - person_image_path: file path to the uploaded person image.
+    - left_image_path: file path to the uploaded left stereoscopic image.
+    - right_image_path: file path to the uploaded right stereoscopic image.
+    - depth: depth level for the person in the 3D scene ("close", "medium", or "far").
+
+    Returns:
+    - Anaglyph PIL image ready for display.
+    """
+
+    # Segment the person from the uploaded image
+    person_image = segment_person(person_image_path)
+
+    # Save the segmented image temporarily for overlay purposes
+    person_image.save("temp_person.png")
+
+    # Insert the segmented person into the stereoscopic images
+    left_image, right_image = insert_person(
+        left_image_path, right_image_path, "temp_person.png", depth
+    )
+
+    # Create the final anaglyph image from the left and right images
+    anaglyph_image = create_anaglyph(left_image, right_image)
+    anaglyph_pil = Image.fromarray(cv2.cvtColor(anaglyph_image, cv2.COLOR_BGR2RGB))
+
+    return anaglyph_pil

src/segmentation.py

@@ -0,0 +1,28 @@
+import torch
+from torchvision import models, transforms
+from PIL import Image
+import numpy as np
+
+
+def segment_person(image_path):
+    # Load the pre-trained DeepLabV3 model
+    model = models.segmentation.deeplabv3_resnet101(pretrained=True).eval()
+
+    # Load and preprocess the input image
+    input_image = Image.open(image_path).convert("RGB")
+    preprocess = transforms.Compose(
+        [
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ]
+    )
+    input_tensor = preprocess(input_image).unsqueeze(0)
+
+    with torch.no_grad():
+        output = model(input_tensor)["out"][0]
+        mask = output.argmax(0).byte().numpy()
+
+    # Convert mask to an image with transparency
+    segmented_image = np.array(input_image)
+    segmented_image = np.dstack([segmented_image, mask * 255])  # Add alpha channel
+    return Image.fromarray(segmented_image)

src/stereoscopic_insert.py

@@ -0,0 +1,69 @@
+import cv2
+import numpy as np
+
+
+def insert_person(left_image_path, right_image_path, person_image_path, depth="medium"):
+    # Load left and right stereoscopic images
+    left_image = cv2.imread(left_image_path)
+    right_image = cv2.imread(right_image_path)
+
+    # Load the segmented person image with alpha channel (transparency)
+    person = cv2.imread(person_image_path, cv2.IMREAD_UNCHANGED)
+
+    # Define scaling and disparity values for each depth level
+    depth_settings = {
+        "close": {
+            "scale": 1.2,
+            "disparity": 15,
+        },  # Larger size and greater disparity for closer placement
+        "medium": {
+            "scale": 1.0,
+            "disparity": 10,
+        },  # Moderate size and disparity for medium placement
+        "far": {
+            "scale": 0.7,
+            "disparity": 5,
+        },  # Smaller size and lesser disparity for farther placement
+    }
+
+    # Retrieve scale and disparity based on depth level
+    scale_factor = depth_settings[depth]["scale"]
+    disparity = depth_settings[depth]["disparity"]
+
+    # Resize the person image based on the scale factor
+    person_h, person_w = person.shape[:2]
+    new_size = (int(person_w * scale_factor), int(person_h * scale_factor))
+    person_resized = cv2.resize(person, new_size, interpolation=cv2.INTER_AREA)
+
+    # Determine the positions for placing the person in left and right images
+    # (You may adjust these values to match specific surfaces or alignments in your background)
+    left_x, left_y = (
+        50,
+        left_image.shape[0] - person_resized.shape[0] - 50,
+    )  # Place near bottom for realism
+    right_x = left_x + disparity  # Horizontal offset for depth effect
+
+    # Overlay the person onto both left and right images with adjusted position
+    for img, x in zip((left_image, right_image), (left_x, right_x)):
+        # Ensure the person fits within the bounds of the image
+        y, x = max(0, left_y), max(0, x)
+        y_end = min(y + person_resized.shape[0], img.shape[0])
+        x_end = min(x + person_resized.shape[1], img.shape[1])
+
+        # Extract the region of interest (ROI)
+        roi = img[y:y_end, x:x_end]
+
+        # Apply alpha blending to combine person image with background
+        person_alpha = (
+            person_resized[: y_end - y, : x_end - x, 3] / 255.0
+        )  # Alpha channel mask
+        for c in range(3):
+            roi[:, :, c] = (1 - person_alpha) * roi[
+                :, :, c
+            ] + person_alpha * person_resized[: y_end - y, : x_end - x, c]
+
+        # Insert modified ROI back into the original image
+        img[y:y_end, x:x_end] = roi
+
+    # Return the modified left and right images
+    return left_image, right_image

utils/config.py

@@ -0,0 +1,5 @@
+# Constants for depth levels
+DISPARITY_LEVELS = {"close": 10, "medium": 5, "far": 2}
+
+# Default positions for overlaying segmented images
+DEFAULT_POSITION = (50, 100)

utils/image_processing.py

@@ -0,0 +1,16 @@
+import cv2
+
+
+def resize_image(image, width=None, height=None):
+    if width is None and height is None:
+        return image
+
+    (h, w) = image.shape[:2]
+    if width is None:
+        ratio = height / float(h)
+        width = int(w * ratio)
+    else:
+        ratio = width / float(w)
+        height = int(h * ratio)
+
+    return cv2.resize(image, (width, height))