implement a custom image component with settings

change examples to route through the custom image rather than the slider
cleanup
fourth cat

gradio_dualvision/app_template.py

@@ -28,12 +28,12 @@ import re
 
 import gradio as gr
 import spaces
-from PIL import Image
-from gradio.components.base import Component
+from PIL import Image as PILImage
+from gradio import Component, ImageSlider
 
 from .gradio_patches.examples import Examples
 from .gradio_patches.gallery import Gallery
-from .gradio_patches.imageslider import ImageSlider
+from .gradio_patches.image import Image
 from .gradio_patches.radio import Radio
 from .version import __version__
 
@@ -281,7 +281,7 @@ class DualVisionApp(gr.Blocks):
         with self:
             self.make_interface()
 
-    def process(self, image_in: Image.Image, **kwargs):
+    def process(self, image_in: PILImage.Image, **kwargs):
         """
         Process an input image into multiple modalities using the provided arguments or default settings.
         Returns two dictionaries: one containing the modalities and another with the actual settings.
@@ -321,9 +321,9 @@ class DualVisionApp(gr.Blocks):
             if os.path.isfile(image_settings_path):
                 with open(image_settings_path, "r") as f:
                     image_settings = json.load(f)
-            image_in = Image.open(image_in).convert("RGB")
+            image_in = PILImage.open(image_in).convert("RGB")
         else:
-            if not isinstance(image_in, Image.Image):
+            if not isinstance(image_in, PILImage.Image):
                 raise gr.Error(f"Input must be a PIL image, got {type(image_in)}")
             image_in = image_in.convert("RGB")
         image_settings.update(kwargs)
@@ -345,7 +345,7 @@ class DualVisionApp(gr.Blocks):
                 raise gr.Error(
                     f"Output dict must not have an '{self.key_original_image}' key; it is reserved for the input"
                 )
-            if not isinstance(v, Image.Image):
+            if not isinstance(v, PILImage.Image):
                 raise gr.Error(
                     f"Value for key '{k}' must be a PIL Image, got type {type(v)}"
                 )
@@ -417,6 +417,21 @@ class DualVisionApp(gr.Blocks):
             image_in, modality_selector_left, modality_selector_right, **input_dict
         )
 
+    def on_process_example(
+        self,
+        dummy_image_input,
+        modality_selector_left=None,
+        modality_selector_right=None,
+        *args,
+    ):
+        image_in = dummy_image_input
+        input_dict = {}
+        if len(args) > 0:
+            input_dict = {k: v for k, v in zip(self.input_keys, args)}
+        return self.process_components(
+            image_in, modality_selector_left, modality_selector_right, **input_dict
+        )
+
     def on_process_subsequent(
         self, results_state, modality_selector_left, modality_selector_right, *args
     ):
@@ -449,6 +464,10 @@ class DualVisionApp(gr.Blocks):
 
         results_state = Gallery(visible=False)
 
+        dummy_image_input = Image(
+            visible=False,
+            type="filepath",
+        )
         image_slider = self.make_slider()
 
         if self.left_selector_visible or not self.advanced_settings_can_be_half_width:
@@ -469,7 +488,7 @@ class DualVisionApp(gr.Blocks):
                     )
 
         self.make_examples(
-            image_slider,
+            dummy_image_input,
             [
                 results_state,
                 image_slider,
@@ -580,15 +599,13 @@ class DualVisionApp(gr.Blocks):
             raise gr.Error("Not all example paths are valid files")
         examples_dirname = os.path.basename(os.path.normpath(self.examples_path))
         return Examples(
-            examples=[
-                (e, e) for e in examples
-            ],
+            examples=examples,
             inputs=inputs,
             outputs=outputs,
             examples_per_page=self.examples_per_page,
             cache_examples=True,
             cache_mode=self.examples_cache,
-            fn=self.on_process_first,
+            fn=self.on_process_example,
             directory_name=examples_dirname,
         )
 

gradio_dualvision/gradio_patches/gallery.py

@@ -1,35 +1,52 @@
-from __future__ import annotations
-
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+import gradio
+import numpy as np
+import PIL.Image
 from concurrent.futures import ThreadPoolExecutor
-
-from gradio_client import utils as client_utils
-from gradio.components.gallery import GalleryImage, GalleryData, GalleryMediaType, CaptionedGalleryMediaType, GalleryVideo
 from pathlib import Path
 from urllib.parse import quote, urlparse
 
-import gradio
-import numpy as np
-import PIL.Image
+from gradio import FileData, image_utils, processing_utils, utils, wasm_utils
+from gradio.components.gallery import GalleryData, GalleryImage, GalleryMediaType, CaptionedGalleryMediaType, GalleryVideo
+from gradio_client import utils as client_utils
 from gradio_client.utils import is_http_url_like
-
-from gradio import processing_utils, utils, wasm_utils, image_utils
-from gradio.data_classes import FileData, ImageData
+from gradio.data_classes import ImageData
 
 
 class Gallery(gradio.Gallery):
+
     def postprocess(
-            self,
-            value: list[GalleryMediaType | CaptionedGalleryMediaType] | None,
+        self,
+        value: list[GalleryMediaType | CaptionedGalleryMediaType] | None,
     ) -> GalleryData:
         """
-            This is a patched version of the original function, wherein the format for PIL is computed based on the data type:
-            format = "png" if img.mode == "I;16" else "webp"
-
-            Parameters:
-                value: Expects the function to return a `list` of images or videos, or `list` of (media, `str` caption) tuples. Each image can be a `str` file path, a `numpy` array, or a `PIL.Image` object. Each video can be a `str` file path.
-            Returns:
-                a list of images or videos, or list of (media, caption) tuples
-            """
+        Parameters:
+            value: Expects the function to return a `list` of images or videos, or `list` of (media, `str` caption) tuples. Each image can be a `str` file path, a `numpy` array, or a `PIL.Image` object. Each video can be a `str` file path.
+        Returns:
+            a list of images or videos, or list of (media, caption) tuples
+        """
         if value is None:
             return GalleryData(root=[])
         if isinstance(value, str):
@@ -51,7 +68,7 @@ class Gallery(gradio.Gallery):
                 )
                 file_path = str(utils.abspath(file))
             elif isinstance(img, PIL.Image.Image):
-                format = "png" if img.mode == "I;16" else "webp"  # Patch 1: change format based on the inbound dtype
+                format = "png" if img.mode == "I;16" else self.format  # Patch 1: change format based on the inbound dtype
                 file = processing_utils.save_pil_to_cache(
                     img, cache_dir=self.GRADIO_CACHE, format=format
                 )

gradio_dualvision/gradio_patches/{imageslider.py → image.py}

@@ -25,88 +25,51 @@ import json
 import os.path
 import tempfile
 from pathlib import Path
-from typing import Union, Tuple, Optional
 
+import PIL
 import gradio
 import numpy as np
-from PIL import Image
+from PIL import Image as PILImage
 from gradio import image_utils
-from gradio_client import utils as client_utils
-from gradio.components.imageslider import image_tuple
-from gradio.data_classes import GradioRootModel, JsonData, ImageData
+from gradio.data_classes import ImageData
 
 
-class ImageSliderPlusData(GradioRootModel):
-    root: Union[
-        Tuple[ImageData | None, ImageData | None, JsonData | None],
-        Tuple[ImageData | None, ImageData | None],
-        None,
-    ]
-
-
-class ImageSlider(gradio.ImageSlider):
-    data_model = ImageSliderPlusData
-
+class Image(gradio.Image):
     def postprocess(
         self,
-        value: image_tuple,
-    ) -> ImageSliderPlusData:
-        if value is None:
-            return ImageSliderPlusData(root=(None, None, None))
+        value,
+    ) -> ImageData:
+        fn_format_selector = lambda x: "png" if (isinstance(x, np.ndarray) and x.dtype == np.uint16 and x.squeeze().ndim == 2) or (isinstance(x, PILImage.Image) and x.mode == "I;16") else self.format
+        format = fn_format_selector(value)
 
-        settings = None
-        if type(value[0]) is str:
-            settings_candidate_path = value[0] + ".settings.json"
+        out = image_utils.postprocess_image(
+            value,
+            cache_dir=self.GRADIO_CACHE,
+            format=format,
+        )
+
+        if type(value) is str:
+            settings_candidate_path = value + ".settings.json"
             if os.path.isfile(settings_candidate_path):
                 with open(settings_candidate_path, "r") as fp:
                     settings = json.load(fp)
+                out.meta["settings"] = settings
 
-        fn_format_selector = lambda x: "png" if (isinstance(x, np.ndarray) and x.dtype == np.uint16 and x.squeeze().ndim == 2) or (isinstance(x, Image.Image) and x.mode == "I;16") else self.format
-        format_0 = fn_format_selector(value[0])
-        format_1 = fn_format_selector(value[1])
+        return out
 
-        return ImageSliderPlusData(
-            root=(
-                image_utils.postprocess_image(
-                    value[0], cache_dir=self.GRADIO_CACHE, format=format_0
-                ),
-                image_utils.postprocess_image(
-                    value[1], cache_dir=self.GRADIO_CACHE, format=format_1
-                ),
-                JsonData(settings),
-            ),
-        )
+    def preprocess(self, payload: ImageData) ->  str | PIL.Image.Image | np.ndarray | None:
+        out = super().preprocess(payload)
 
-    def preprocess(self, payload: ImageSliderPlusData) -> image_tuple:
-        if payload is None:
-            return None
-        if payload.root is None:
-            raise ValueError("Payload is None.")
+        if "settings" in payload.meta:
+            with open(out + ".settings.json", "w") as fp:
+                json.dump(payload.meta["settings"], fp)
 
-        out_0 = image_utils.preprocess_image(
-            payload.root[0],
-            cache_dir=self.GRADIO_CACHE,
-            format=self.format,
-            image_mode=self.image_mode,
-            type=self.type,
-        )
-        out_1 = image_utils.preprocess_image(
-            payload.root[1],
-            cache_dir=self.GRADIO_CACHE,
-            format=self.format,
-            image_mode=self.image_mode,
-            type=self.type,
-        )
-
-        if len(payload.root) > 2 and payload.root[2] is not None:
-            with open(out_0 + ".settings.json", "w") as fp:
-                json.dump(payload.root[2].root, fp)
-
-        return out_0, out_1
+        return out
 
     @staticmethod
     def resize_and_save(image_path: str, max_dim: int, square: bool = False) -> str:
-        img = Image.open(image_path).convert("RGB")
+        img = PILImage.open(image_path).convert("RGB")
+
         if square:
             width, height = img.size
             min_side = min(width, height)
@@ -115,31 +78,16 @@ class ImageSlider(gradio.ImageSlider):
             right = left + min_side
             bottom = top + min_side
             img = img.crop((left, top, right, bottom))
+        
         img.thumbnail((max_dim, max_dim))
         temp_file = tempfile.NamedTemporaryFile(suffix=".webp", delete=False)
         img.save(temp_file.name, "WEBP")
+        
         return temp_file.name
 
-    def process_example_dims(
-        self, input_data: tuple[str | Path | None] | None, max_dim: Optional[int] = None, square: bool = False
-    ) -> image_tuple:
-        if input_data is None:
-            return None
-        input_data = (str(input_data[0]), str(input_data[1]))
-        if self.proxy_url or client_utils.is_http_url_like(input_data[0]):
-            return input_data[0]
-        if max_dim is not None:
-            input_data = (
-                self.resize_and_save(input_data[0], max_dim, square),
-                self.resize_and_save(input_data[1], max_dim, square),
-            )
-        return (
-            self.move_resource_to_block_cache(input_data[0]),
-            self.move_resource_to_block_cache(input_data[1]),
-        )
-
     def process_example(
-        self, input_data: tuple[str | Path | None] | None
-    ) -> image_tuple:
-        return self.process_example_dims(input_data, 256, True)
-
+        self, input_data: str | Path | None
+    ) -> str | PIL.Image.Image | np.ndarray | None:
+        thumbnail = self.resize_and_save(input_data, 256, True)
+        out = super().process_example(thumbnail)
+        return out

gradio_dualvision/gradio_patches/radio.py

@@ -23,13 +23,9 @@
 # --------------------------------------------------------------------------
 import gradio
 from gradio import components
-from gradio.components.base import Component
-from gradio.data_classes import (
-    GradioModel,
-    GradioRootModel,
-)
-
 from gradio.blocks import BlockContext
+from gradio.components.base import Component
+from gradio.data_classes import GradioModel, GradioRootModel
 
 
 def patched_postprocess_update_dict(