clean up

_utils/image_io.py

@@ -1,28 +1,8 @@
 """Image standardization.
 
-Microscopy TIFFs come in many flavors: 16-bit or float pixels, single or
-multi channel, and multi-page Z / time stacks. ``standardize_image`` collapses
-any of those variants to a single canonical 8-bit RGB PNG used for BOTH the
-on-screen preview and the model, so what you see is what gets segmented.
-
-Which axis means what is read from the file's own metadata (``series.axes``
-from tifffile: 'C'=channel, 'S'=RGB samples, 'Z'/'T'=stack, 'Y'/'X'=spatial)
-rather than guessed from the array shape -- guessing cannot tell a 3-channel
-(C, Y, X) image apart from a 3-slice (Z, Y, X) stack. Only when a file names
-no axes at all (tifffile reports 'Q' = unknown) do we fall back to the dominant
-convention: the first unknown axis of size 2-4 is the channel axis.
-
-Reduction policy:
-
-  * multi-page / Z / time stacks -> one frame (default: the first)
-  * more than 3 channels         -> first 3 channels (as R, G, B)
-  * intensity -> 0-255           -> 1st-99th percentile auto-contrast for
-                                    16-bit/float input (outlier-robust: a hot /
-                                    saturated pixel would make plain min/max
-                                    scaling collapse the real signal to black)
-
-Standard 8-bit inputs (PNG/JPG/8-bit TIFF) are passed through unchanged in
-value; only channel layout is normalized.
+``standardize_image`` collapses any microscopy TIFF variant (16-bit/float,
+multi-channel, multi-page Z/time stacks) to one canonical 8-bit RGB PNG, used
+for both the preview and the model.
 """
 
 import os
@@ -37,21 +17,19 @@ try:
 except ImportError:  # pragma: no cover - tifffile is a project dependency
     tifffile = None
 
-# Size policy. The model resizes any input to 512x512 (see segmentation.py), so a
-# larger image costs memory/time and *loses* detail rather than adding any.
-RECOMMENDED_SIZE = 512   # cropping to about this preserves the most detail
-WARN_SIZE = 3072         # above this, advise the user to crop
-MAX_SIZE = 4096          # above this, refuse: reading the pixels risks an OOM
-# Refuse files whose full array would not comfortably fit in memory. Measured on
-# the uncompressed array (shape x dtype) rather than the file size on disk, since
-# compression makes disk size a poor proxy for what we actually allocate.
-MAX_READ_BYTES = 300 * 1024 ** 2   # 300 MiB
-
-# Axis roles, per tifffile's `series.axes` naming.
-_SPATIAL = ("Y", "X")
+# The model resizes any input to 512x512, so a larger image loses detail rather
+# than adding any.
+RECOMMENDED_SIZE = 512
+WARN_SIZE = 3072
+MAX_SIZE = 4096
+# Measured on the uncompressed array, not the file size on disk: compression
+# makes disk size a poor proxy for what opening the file actually allocates.
+MAX_READ_BYTES = 300 * 1024 ** 2
+
+# Axis roles, per tifffile's `series.axes` naming. Anything else (Z, T, ...) is a
+# stack axis, indexed by frame.
 _CHANNEL = ("C", "S")      # C = separate channel planes, S = interleaved RGB samples
 _UNKNOWN = ("Q", "I")      # file named no axis; only these may be *guessed* as channels
-# Anything else (Z, T, ...) is a stack axis and is indexed by frame.
 
 
 def _read_array(path):
@@ -145,7 +123,6 @@ def _reduce_to_hwc(arr, axes, frame=0):
     """
     axes = list(axes)
 
-    # Drop size-1 axes, keeping arr and axes in sync.
     for i in range(len(axes) - 1, -1, -1):
         if arr.shape[i] == 1:
             arr = arr.reshape(arr.shape[:i] + arr.shape[i + 1:])
@@ -153,7 +130,6 @@ def _reduce_to_hwc(arr, axes, frame=0):
 
     _, planned, _ = _plan_axes(arr.shape, axes)
 
-    # Apply the plan to the array: infer the channel axis, then move it last.
     if "C" in planned and not any(a in _CHANNEL for a in axes):
         for i, (a, d) in enumerate(zip(axes, arr.shape)):
             if a in _UNKNOWN and d in (2, 3, 4):
@@ -164,7 +140,6 @@ def _reduce_to_hwc(arr, axes, frame=0):
         arr = np.moveaxis(arr, ci, -1)
         axes.append(axes.pop(ci))
 
-    # Index the leading stack axes: first by `frame`, deeper by 0.
     target = 3 if ci is not None else 2
     first = True
     while len(axes) > target:

app.py

@@ -31,12 +31,10 @@ DATASET_REPO = "VisionLanguageGroup/feedback"
 
 
 print("===== clearing cache =====")
-# cache_path = os.path.expanduser("~/.cache/")
 cache_path = os.path.expanduser("~/.cache/huggingface/gradio")
 if os.path.exists(cache_path):
     try:
         shutil.rmtree(cache_path)
-        # print("✅ Deleted ~/.cache/")
         print("✅ Deleted ~/.cache/huggingface/gradio")
     except:
         pass
@@ -87,15 +85,12 @@ def save_feedback_to_hf(query_id, feedback_type, feedback_text=None, img_path=No
         save_feedback(query_id, feedback_type, feedback_text, img_path, bboxes)
         return
     
-    # One stem for the record and its image so the two pair up. query_id alone is
-    # not enough - a single session can submit feedback more than once.
+    # Shared by the record and its image so the two pair up; query_id alone is not unique (a session can submit more than once).
     stem = f"feedback_{query_id}_{int(time.time())}"
 
     try:
         api = HfApi()
 
-        # Upload the standardized PNG: the exact image the model saw (first
-        # frame, <=3 channels, auto-contrasted), not the raw upload.
         image_in_repo = None
         if img_path and os.path.exists(img_path):
             try:
@@ -109,16 +104,14 @@ def save_feedback_to_hf(query_id, feedback_type, feedback_text=None, img_path=No
                 )
             except Exception as e:
                 print(f"⚠️ Failed to upload image: {e}")
-                image_in_repo = None  # still record the rest of the feedback
+                image_in_repo = None  
 
         feedback_data = {
             "query_id": query_id,
             "feedback_type": feedback_type,
             "feedback_text": feedback_text,
-            # Path inside the dataset repo. This used to be the local temp path,
-            # which was meaningless once the session ended.
-            "image_path": image_in_repo,
-            "bboxes": str(bboxes),  # 转为字符串
+            "image_path": image_in_repo, 
+            "bboxes": str(bboxes), 
             "datetime": time.strftime("%Y-%m-%d %H:%M:%S"),
             "timestamp": time.time()
         }
@@ -320,6 +313,22 @@ def cleanup_tracking_cache(track_vis_cache):
                 pass
 
 
+# Per session. Refused rather than evicting the oldest, since there is no way to
+# remove a single entry.
+MAX_GALLERY_UPLOADS = 10
+
+_GALLERY_RAW_SOURCE = {}
+_RAW_SOURCE_CAP = 500
+
+
+def _remember_gallery_source(thumb_path, raw_path):
+    """Map a gallery thumbnail back to the original file it was made from.
+    """
+    _GALLERY_RAW_SOURCE[thumb_path] = raw_path
+    while len(_GALLERY_RAW_SOURCE) > _RAW_SOURCE_CAP:  # dicts keep insertion order
+        _GALLERY_RAW_SOURCE.pop(next(iter(_GALLERY_RAW_SOURCE)))
+
+
 def _annot_path(annot_value):
     """Extract the image path from a BBoxAnnotator value (path or (path, boxes))."""
     if not annot_value:
@@ -347,8 +356,8 @@ def check_image(img_path):
     """
     w, h = image_size(img_path)
     if w <= 0 or h <= 0:
-        # Neither tifffile nor PIL could parse the header, so this is not a
-        # format we can read. Say so instead of failing silently downstream.
+        # Neither reader could parse the header, so say so rather than failing
+        # silently further down.
         ext = os.path.splitext(img_path)[1].lower() or "(no extension)"
         return (f"Could not read {ext} as an image. Supported formats: "
                 f"TIFF / OME-TIFF (8/16/32-bit, stacks, multi-channel), PNG, JPG, and other formats suported by tiffile. "
@@ -420,8 +429,7 @@ def prepare_uploaded_image(annot_value):
     if not img_path:
         return annot_value, None, gr.update(visible=False, value=1)
 
-    # Guard before any pixels are read. On refusal clear the annotator so the
-    # oversize file cannot be sent to inference.
+    # Clear the annotator on refusal, so a rejected file cannot reach inference.
     rejected = check_image(img_path)
     if rejected:
         gr.Warning(rejected, duration=None, title="❌ Cannot use this file")
@@ -430,9 +438,8 @@ def prepare_uploaded_image(annot_value):
     info = inspect_image(img_path)
     display = standardize_image(img_path, frame=0)
 
-    # Only speak up when something non-obvious happened: a dimension had to be
-    # guessed, it is a stack, or channels are being dropped. A plain RGB or
-    # grayscale image needs no explanation.
+    # Stay quiet unless something non-obvious happened; a plain RGB or grayscale
+    # image needs no explanation.
     if info.guessed or info.frames > 1 or info.channels > 3:
         gr.Info(_describe_read(info), duration=None, title="📚 Image Loading Info")
 
@@ -1379,9 +1386,7 @@ with gr.Blocks(
         primary_hue=gr.themes.colors.sky,
         secondary_hue=gr.themes.colors.slate,
         neutral_hue=gr.themes.colors.slate,
-        # Weights must be loaded to be usable: GoogleFont defaults to (400, 600),
-        # so any font-weight above 600 silently falls back. Inter tops out at 900;
-        # anything higher is dropped by Google Fonts without an error.
+        # A weight must be listed here to be usable; the default is (400, 600).
         font=gr.themes.GoogleFont("Inter", weights=(400, 600, 700, 800)),
     ),
     css=CSS,
@@ -1406,17 +1411,16 @@ with gr.Blocks(
         """
     )
     
-    # 全局状态
-    # Must be a callable: gr.State deepcopies a plain value, so str(uuid4())
-    # would be evaluated once at construction and every session would share the
-    # same id. A callable is re-run on each app load, giving one id per session.
+
+    # Must stay a callable: a plain value is deepcopied, so every session would
+    # share one id.
     current_query_id = gr.State(lambda: str(uuid.uuid4()))
     user_uploaded_examples = gr.State(example_images_seg.copy())
     seg_vis_state = gr.State({})
     count_vis_state = gr.State({})
     track_vis_state = gr.State({})
-    # Raw uploaded path, kept so a different stack frame can be re-extracted
-    # (the annotator only holds the already-flattened preview PNG).
+    # The annotator only holds the flattened preview, so keep the original for
+    # re-extracting other stack frames.
     seg_raw_state = gr.State(None)
     count_raw_state = gr.State(None)
     
@@ -1437,8 +1441,8 @@ with gr.Blocks(
                         🤘 Tell us about your experience by rating and submitting feedback, which would greatly help us improve the framework!
                         """
                     )
-            # Reference material - collapsed by default. Must stay AFTER the
-            # instructions markdown: the CSS styles it via .prose:nth-child(2).
+            # Must stay after the instructions markdown: the CSS targets it with
+            # .prose:nth-child(2).
             with gr.Accordion("📋 Image Upload Requirements (click to expand or fold)", open=False, elem_classes="req-accordion"):
                 gr.Markdown(
                     """
@@ -1548,13 +1552,11 @@ with gr.Blocks(
                         visible=False
                     )
             
-            # standardize on upload (preview) + configure the stack frame slider
             annotator.upload(
                 fn=prepare_uploaded_image,
                 inputs=annotator,
                 outputs=[annotator, seg_raw_state, seg_frame_slider]
             )
-            # re-render the preview when the user picks a different stack frame
             seg_frame_slider.release(
                 fn=select_frame,
                 inputs=[seg_raw_state, seg_frame_slider],
@@ -1596,9 +1598,13 @@ with gr.Blocks(
                 if rejected:
                     return (current_imgs, current_imgs,
                             gr.update(value=f"❌ {rejected}", visible=True), None)
-                # Standardize to an 8-bit PNG so TIFFs render as gallery
-                # thumbnails; prepend so it's immediately visible at the front.
+                if len(current_imgs) - len(example_images_seg) >= MAX_GALLERY_UPLOADS:
+                    return (current_imgs, current_imgs,
+                            gr.update(value=f"⚠️ Gallery upload limit reached "
+                                            f"({MAX_GALLERY_UPLOADS} images). Reload the page "
+                                            f"to start over.", visible=True), None)
                 std_path = standardize_image(img_path)
+                _remember_gallery_source(std_path, img_path)
                 if std_path not in current_imgs:
                     current_imgs.insert(0, std_path)
                 return (current_imgs, current_imgs,
@@ -1610,11 +1616,11 @@ with gr.Blocks(
                 outputs=[user_uploaded_examples, example_gallery, add_gallery_status, image_uploader]
             )
             
-            # click event for Gallery selection (gallery entries are single-frame)
+            # Reuse the upload path so the toast and frame slider behave the same.
             def load_from_gallery(evt: gr.SelectData, all_imgs):
                 if evt.index is not None and evt.index < len(all_imgs):
                     item = all_imgs[evt.index]
-                    return standardize_image(item), item, gr.update(visible=False, value=1)
+                    return prepare_uploaded_image(_GALLERY_RAW_SOURCE.get(item, item))
                 return None, None, gr.update(visible=False, value=1)
 
             example_gallery.select(
@@ -1670,8 +1676,8 @@ with gr.Blocks(
                 🤘 Tell us about your experience by rating and submitting feedback, which would greatly help us improve the framework!
                 """
             )
-            # Reference material - collapsed by default. Must stay AFTER the
-            # instructions markdown: the CSS styles it via .prose:nth-child(2).
+            # Must stay after the instructions markdown: the CSS targets it with
+            # .prose:nth-child(2).
             with gr.Accordion("📋 Image requirements", open=False, elem_classes="req-accordion"):
                 gr.Markdown(
                     """
@@ -1799,9 +1805,13 @@ with gr.Blocks(
                 if rejected:
                     return (current_imgs, current_imgs,
                             gr.update(value=f"❌ {rejected}", visible=True), None)
-                # Standardize to an 8-bit PNG so TIFFs render as gallery
-                # thumbnails; prepend so it's immediately visible at the front.
+                if len(current_imgs) - len(example_images_cnt) >= MAX_GALLERY_UPLOADS:
+                    return (current_imgs, current_imgs,
+                            gr.update(value=f"⚠️ Gallery upload limit reached "
+                                            f"({MAX_GALLERY_UPLOADS} images). Reload the page "
+                                            f"to start over.", visible=True), None)
                 std_path = standardize_image(new_img_file)
+                _remember_gallery_source(std_path, new_img_file)
                 if std_path not in current_imgs:
                     current_imgs.insert(0, std_path)
                     print(f"✅ Added image to gallery: {std_path}")
@@ -1815,26 +1825,24 @@ with gr.Blocks(
                 outputs=[count_user_examples, count_example_gallery, count_add_status, count_image_uploader]
             )
             
-            # standardize on upload (preview) + configure the stack frame slider
             count_annotator.upload(
                 fn=prepare_uploaded_image,
                 inputs=count_annotator,
                 outputs=[count_annotator, count_raw_state, count_frame_slider]
             )
-            # re-render the preview when the user picks a different stack frame
             count_frame_slider.release(
                 fn=select_frame,
                 inputs=[count_raw_state, count_frame_slider],
                 outputs=count_annotator
             )
 
-            # When user selects from gallery, load into annotator (single-frame)
+            # When user selects from gallery, load into annotator
             def load_from_count_gallery(evt: gr.SelectData, all_imgs):
-                """Load selected image from gallery into annotator"""
+                """Load a gallery image, reusing the upload path."""
                 if evt.index is not None and evt.index < len(all_imgs):
                     selected_img = all_imgs[evt.index]
                     print(f"📸 Loading image from gallery: {selected_img}")
-                    return standardize_image(selected_img), selected_img, gr.update(visible=False, value=1)
+                    return prepare_uploaded_image(_GALLERY_RAW_SOURCE.get(selected_img, selected_img))
                 return None, None, gr.update(visible=False, value=1)
 
             count_example_gallery.select(
@@ -1867,14 +1875,7 @@ with gr.Blocks(
                 try:
                     img_path = annot_val[0] if annot_val and len(annot_val) > 0 else None
                     bboxes = annot_val[1] if annot_val and len(annot_val) > 1 else []
-                    
-                    # save_feedback(
-                    #     query_id=query_id,
-                    #     feedback_type=f"score_{int(score)}",
-                    #     feedback_text=comment,
-                    #     img_path=img_path,
-                    #     bboxes=bboxes
-                    # )
+
 
                     save_feedback_to_hf(
                         query_id=query_id,
@@ -2211,14 +2212,6 @@ with gr.Blocks(
                 try:
                     img_path = annot_val[0] if annot_val and len(annot_val) > 0 else None
                     bboxes = annot_val[1] if annot_val and len(annot_val) > 1 else []
-                    
-                    # save_feedback(
-                    #     query_id=query_id,
-                    #     feedback_type=f"score_{int(score)}",
-                    #     feedback_text=comment,
-                    #     img_path=img_path,
-                    #     bboxes=bboxes
-                    # )
 
                     save_feedback_to_hf(
                         query_id=query_id,
@@ -2246,9 +2239,4 @@ if __name__ == "__main__":
         share=False,
         ssr_mode=False,
         show_error=True,
-        # Deliberately no max_file_size: a transport-layer 413 is silent in the
-        # annotator (we never get to run, so we cannot show a message), and file
-        # size is a poor proxy anyway - a 1344x1024 time-lapse can be 256MB while
-        # a 4096x4096 RGB is only 50MB. Size is checked in check_image()
-        # instead, where a real message can be shown.
     )