Update app.py

app.py

@@ -1,45 +1,92 @@
+from doctest import Example
 import gradio as gr
-from transformers import DPTFeatureExtractor, DPTForDepthEstimation
+from transformers import DPTImageProcessor, DPTForDepthEstimation
 import torch
 import numpy as np
-from PIL import Image
+from PIL import Image, ImageOps
+from pathlib import Path
+import glob
+from autostereogram.converter import StereogramConverter
+from datetime import datetime
+import time
+import tempfile
 
-#torch.hub.download_url_to_file('http://images.cocodataset.org/val2017/000000039769.jpg', 'cats.jpg')
-
-feature_extractor = DPTFeatureExtractor.from_pretrained("Intel/dpt-large")
+feature_extractor = DPTImageProcessor.from_pretrained("Intel/dpt-large")
 model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large")
 
-def process_image(image):
+stereo_converter = StereogramConverter()
+
+
+def process_image(image_path):
+    print("\n\n\n")
+    print("Processing image:", image_path)
+    last_time = time.time()
+    image_raw = Image.open(Path(image_path))
+
+    image = image_raw
+
     # prepare image for the model
     encoding = feature_extractor(image, return_tensors="pt")
-    
+
     # forward pass
     with torch.no_grad():
-       outputs = model(**encoding)
-       predicted_depth = outputs.predicted_depth
-    
+        outputs = model(**encoding)
+        predicted_depth = outputs.predicted_depth
+
     # interpolate to original size
     prediction = torch.nn.functional.interpolate(
-                        predicted_depth.unsqueeze(1),
-                        size=image.size[::-1],
-                        mode="bicubic",
-                        align_corners=False,
-                 ).squeeze()
+        predicted_depth.unsqueeze(1),
+        size=image.size[::-1],
+        mode="bicubic",
+        align_corners=False,
+    ).squeeze()
     output = prediction.cpu().numpy()
-    formatted = (output * 255 / np.max(output)).astype('uint8')
-    img = Image.fromarray(formatted)
-    return img
-    
-    return result
-    
-title = "Demo: zero-shot depth estimation with DPT"
-description = "Demo for Intel's DPT, a Dense Prediction Transformer for state-of-the-art dense prediction tasks such as semantic segmentation and depth estimation."
-
-
-iface = gr.Interface(fn=process_image, 
-                     inputs=gr.inputs.Image(type="pil"), 
-                     outputs=gr.outputs.Image(type="pil", label="predicted depth"),
-                     title=title,
-                     description=description,
-                     enable_queue=True)
-iface.launch(debug=True)
+    depth_image = (output * 255 / np.max(output)).astype("uint8")
+    depth_image_padded = np.array(
+      Image.fromarray(depth_image)
+    )
+
+
+    # Return as downloadable file
+    return depth_image_padded
+
+
+
+examples_images = [[f] for f in sorted(glob.glob("examples/*.jpg"))]
+
+
+with gr.Blocks() as blocks:
+    gr.Markdown(
+        """
+## Depth Image to Autostereogram (Magic Eye)
+This demo is a variation from the original [DPT Demo](https://huggingface.co/spaces/nielsr/dpt-depth-estimation).
+Zero-shot depth estimation from an image, then it uses [pystereogram](https://github.com/yxiao1996/pystereogram)
+to generate the autostereogram (Magic Eye)
+<base target="_blank">
+"""
+    )
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="filepath", label="Input Image")
+            button = gr.Button("Predict")
+        with gr.Column():
+            predicted_depth = gr.Image(label="Predicted Depth", type="pil")
+    with gr.Row():
+        autostereogram = gr.Image(label="Autostereogram", type="pil")
+    with gr.Row():
+        with gr.Column():
+            file_download = gr.File(label="Download Image")
+    with gr.Row():
+        gr.Examples(
+            examples=examples_images,
+            fn=process_image,
+            inputs=[input_image],
+            outputs=predicted_depth,
+            cache_examples=True,
+        )
+    button.click(
+        fn=process_image,
+        inputs=[input_image],
+        outputs=predicted_depth,
+    )
+blocks.launch(debug=True)