fix user components not receiving updates, improve gallery passthrough of 16bit pngs, make thumbnails square

gradio_dualvision/app_template.py

@@ -32,6 +32,7 @@ from PIL import Image
 from gradio.components.base import Component
 
 from .gradio_patches.examples import Examples
+from .gradio_patches.gallery import Gallery
 from .gradio_patches.imagesliderplus import ImageSliderPlus
 from .gradio_patches.radio import Radio
 
@@ -99,6 +100,8 @@ class DualVisionApp(gr.Blocks):
         self.key_original_image = key_original_image
         self.slider_position = slider_position
         self.input_keys = None
+        self.input_cls = None
+        self.input_kwargs = None
         self.left_selector_visible = left_selector_visible
         self.advanced_settings_can_be_half_width = advanced_settings_can_be_half_width
         if spaces_zero_gpu_enabled:
@@ -353,7 +356,12 @@ class DualVisionApp(gr.Blocks):
             )
         if any(k not in results_settings for k in self.input_keys):
             raise gr.Error(f"Mismatching setgings keys")
-        results_settings = {k: results_settings[k] for k in self.input_keys}
+        results_settings = {
+            k: cls(**ctor_args, value=results_settings[k])
+            for k, cls, ctor_args in zip(
+                self.input_keys, self.input_cls, self.input_kwargs
+            )
+        }
 
         results_dict = {
             self.key_original_image: image_in,
@@ -440,7 +448,7 @@ class DualVisionApp(gr.Blocks):
         """
         self.make_header()
 
-        results_state = gr.Gallery(visible=False, format="png")
+        results_state = Gallery(visible=False)
 
         image_slider = self.make_slider()
 
@@ -598,6 +606,11 @@ class DualVisionApp(gr.Blocks):
             with gr.Row():
                 btn_clear, btn_submit = self.make_buttons()
         self.input_keys = list(user_components.keys())
+        self.input_cls = list(v.__class__ for v in user_components.values())
+        self.input_kwargs = [
+            {k: v for k, v in c.constructor_args.items() if k not in ("value")}
+            for c in user_components.values()
+        ]
         return user_components, btn_clear, btn_submit
 
     def make_buttons(self):

gradio_dualvision/gradio_patches/gallery.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from gradio.components.gallery import (
+    GalleryImageType,
+    CaptionedGalleryImageType,
+    GalleryImage,
+    GalleryData,
+)
+from pathlib import Path
+from urllib.parse import urlparse
+
+import gradio
+import numpy as np
+import PIL.Image
+from gradio_client.utils import is_http_url_like
+
+from gradio import processing_utils, utils, wasm_utils
+from gradio.data_classes import FileData
+
+
+class Gallery(gradio.Gallery):
+    def postprocess(
+        self,
+        value: list[GalleryImageType | CaptionedGalleryImageType] | 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"
+        """
+        if value is None:
+            return GalleryData(root=[])
+        output = []
+
+        def _save(img):
+            url = None
+            caption = None
+            orig_name = None
+            if isinstance(img, (tuple, list)):
+                img, caption = img
+            if isinstance(img, np.ndarray):
+                file = processing_utils.save_img_array_to_cache(
+                    img, cache_dir=self.GRADIO_CACHE, format=self.format
+                )
+                file_path = str(utils.abspath(file))
+            elif isinstance(img, PIL.Image.Image):
+                format = "png" if img.mode == "I;16" else "webp"
+                file = processing_utils.save_pil_to_cache(
+                    img, cache_dir=self.GRADIO_CACHE, format=format
+                )
+                file_path = str(utils.abspath(file))
+            elif isinstance(img, str):
+                file_path = img
+                if is_http_url_like(img):
+                    url = img
+                    orig_name = Path(urlparse(img).path).name
+                else:
+                    url = None
+                    orig_name = Path(img).name
+            elif isinstance(img, Path):
+                file_path = str(img)
+                orig_name = img.name
+            else:
+                raise ValueError(f"Cannot process type as image: {type(img)}")
+            return GalleryImage(
+                image=FileData(path=file_path, url=url, orig_name=orig_name),
+                caption=caption,
+            )
+
+        if wasm_utils.IS_WASM:
+            for img in value:
+                output.append(_save(img))
+        else:
+            with ThreadPoolExecutor() as executor:
+                for o in executor.map(_save, value):
+                    output.append(o)
+        return GalleryData(root=output)

gradio_dualvision/gradio_patches/imagesliderplus.py

@@ -49,7 +49,7 @@ class ImageSliderPlus(ImageSlider):
     data_model = ImageSliderPlusData
 
     def as_example(self, value):
-        return self.process_example_dims(value, 256)
+        return self.process_example_dims(value, 256, True)
 
     def _format_image(self, im: Image):
         if self.type != "filepath":
@@ -117,15 +117,23 @@ class ImageSliderPlus(ImageSlider):
         return out_0, out_1
 
     @staticmethod
-    def resize_and_save(image_path: str, max_dim: int) -> str:
+    def resize_and_save(image_path: str, max_dim: int, square: bool = False) -> str:
         img = Image.open(image_path).convert("RGB")
+        if square:
+            width, height = img.size
+            min_side = min(width, height)
+            left = (width - min_side) // 2
+            top = (height - min_side) // 2
+            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
+        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
@@ -134,8 +142,8 @@ class ImageSliderPlus(ImageSlider):
             return input_data[0]
         if max_dim is not None:
             input_data = (
-                self.resize_and_save(input_data[0], max_dim),
-                self.resize_and_save(input_data[1], max_dim),
+                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]),