optimised, removed dead codes

app.py

@@ -68,13 +68,9 @@ if HAS_DRAWABLE_CANVAS and ST_DIALOG:
             st.warning("No prediction available to measure.")
             return
         display_mode = st.session_state.get("measure_display_mode", "Default")
-        _m_clamp = st.session_state.get(
-            "measure_clamp_only", st.session_state.get("measure_clip_bounds", False)
-        )
+        _m_clamp = st.session_state.get("measure_clamp_only", False)
         display_heatmap = apply_display_scale(
             raw_heatmap, display_mode,
-            min_percentile=st.session_state.get("measure_min_percentile", 0),
-            max_percentile=st.session_state.get("measure_max_percentile", 100),
             clip_min=st.session_state.get("measure_clip_min", 0),
             clip_max=st.session_state.get("measure_clip_max", 1),
             clamp_only=_m_clamp,
@@ -102,15 +98,12 @@ def _get_measure_dialog_fn():
 
 def _populate_measure_session_state(heatmap, img, pixel_sum, force, key_img, colormap_name,
                                     display_mode, auto_cell_boundary, cell_mask=None,
-                                    min_percentile=0, max_percentile=100, clip_min=0, clip_max=1,
-                                    clamp_only=False):
+                                    clip_min=0, clip_max=1, clamp_only=False):
     """Populate session state for the measure tool. If cell_mask is None and auto_cell_boundary, computes it."""
     if cell_mask is None and auto_cell_boundary:
         cell_mask = estimate_cell_mask(heatmap)
     st.session_state["measure_raw_heatmap"] = heatmap.copy()
     st.session_state["measure_display_mode"] = display_mode
-    st.session_state["measure_min_percentile"] = min_percentile
-    st.session_state["measure_max_percentile"] = max_percentile
     st.session_state["measure_clip_min"] = clip_min
     st.session_state["measure_clip_max"] = clip_max
     st.session_state["measure_clamp_only"] = clamp_only
@@ -252,7 +245,7 @@ with st.sidebar:
     if model_type == "single_cell":
         try:
             with st.container(border=False, key="s2f_grp_conditions"):
-                st.markdown('<p style="font-size: 0.95rem; font-weight: 500; margin-bottom: 0.5rem;">Conditions</p>', unsafe_allow_html=True)
+                st.markdown('<p class="s2f-form-label s2f-form-label--section">Conditions</p>', unsafe_allow_html=True)
                 conditions_source = st.radio(
                     "Conditions",
                     ["From config", "Manually"],
@@ -333,11 +326,10 @@ with st.sidebar:
                 clip_min, clip_max = 0.0, 1.0
             display_mode = "Range"
             clamp_only = False
-        min_percentile, max_percentile = 0, 100
 
     cm_col_lbl, cm_col_sb = st.columns([1, 2])
     with cm_col_lbl:
-        st.markdown('<p class="selectbox-label">Colormap</p>', unsafe_allow_html=True)
+        st.markdown('<p class="s2f-form-label s2f-form-label--colormap">Colormap</p>', unsafe_allow_html=True)
     with cm_col_sb:
         colormap_name = st.selectbox(
             "Colormap",
@@ -438,15 +430,13 @@ def _load_predictor(model_type, checkpoint, ckp_folder):
 
 
 def _prepare_and_render_cached_result(r, key_img, colormap_name, display_mode, auto_cell_boundary,
-                                     min_percentile, max_percentile, clip_min, clip_max, clamp_only,
+                                     clip_min, clip_max, clamp_only,
                                      download_key_suffix="", check_measure_dialog=False,
                                      show_success=False):
     """Prepare display from cached result and render. Used by both just_ran and has_cached paths."""
     img, heatmap, force, pixel_sum = r["img"], r["heatmap"], r["force"], r["pixel_sum"]
     display_heatmap = apply_display_scale(
         heatmap, display_mode,
-        min_percentile=min_percentile,
-        max_percentile=max_percentile,
         clip_min=clip_min,
         clip_max=clip_max,
         clamp_only=clamp_only,
@@ -455,7 +445,6 @@ def _prepare_and_render_cached_result(r, key_img, colormap_name, display_mode, a
     _populate_measure_session_state(
         heatmap, img, pixel_sum, force, key_img, colormap_name,
         display_mode, auto_cell_boundary, cell_mask=cell_mask,
-        min_percentile=min_percentile, max_percentile=max_percentile,
         clip_min=clip_min, clip_max=clip_max, clamp_only=clamp_only,
     )
     if check_measure_dialog and st.session_state.pop("open_measure_dialog", False):
@@ -513,8 +502,6 @@ if just_ran_batch:
                 batch_results,
                 colormap_name=colormap_name,
                 display_mode=display_mode,
-                min_percentile=min_percentile,
-                max_percentile=max_percentile,
                 clip_min=clip_min,
                 clip_max=clip_max,
                 auto_cell_boundary=auto_cell_boundary,
@@ -531,8 +518,6 @@ elif batch_mode and st.session_state.get("batch_results"):
         st.session_state["batch_results"],
         colormap_name=colormap_name,
         display_mode=display_mode,
-        min_percentile=min_percentile,
-        max_percentile=max_percentile,
         clip_min=clip_min,
         clip_max=clip_max,
         auto_cell_boundary=auto_cell_boundary,
@@ -561,7 +546,7 @@ elif just_ran:
             st.session_state["prediction_result"] = r
             _prepare_and_render_cached_result(
                 r, key_img, colormap_name, display_mode, auto_cell_boundary,
-                min_percentile, max_percentile, clip_min, clip_max, clamp_only,
+                clip_min, clip_max, clamp_only,
                 download_key_suffix="", check_measure_dialog=False,
                 show_success=True,
             )
@@ -573,7 +558,7 @@ elif has_cached:
     r = st.session_state["prediction_result"]
     _prepare_and_render_cached_result(
         r, key_img, colormap_name, display_mode, auto_cell_boundary,
-        min_percentile, max_percentile, clip_min, clip_max, clamp_only,
+        clip_min, clip_max, clamp_only,
         download_key_suffix="_cached", check_measure_dialog=True,
         show_success=False,
     )

static/s2f_styles.css

@@ -11,6 +11,7 @@
     --s2f-sidebar-panel-border: rgba(203, 213, 225, 0.34);
     /* Match Streamlit’s sidebar horizontal padding so panels can full-bleed the track */
     --s2f-sidebar-inline-inset: 1rem;
+    --s2f-sidebar-width: 360px;
 }
 /* Streamlit renders a fixed header; without this offset, the sidebar and first main block sit underneath it. */
 .stApp:has(header[data-testid="stHeader"]) {
@@ -34,30 +35,26 @@ html, body {
     overflow: hidden !important;
     margin: 0 !important;
 }
+/* App shell: flex column, dot grid background */
 .stApp {
     height: 100vh !important;
     max-height: 100dvh !important;
     overflow: hidden !important;
     display: flex !important;
     flex-direction: column !important;
+    background-color: #fafbfc !important;
+    background-image:
+        radial-gradient(circle at 1px 1px, rgba(148, 163, 184, 0.12) 1px, transparent 0);
+    background-size: 28px 28px !important;
+    background-position: 0 0, 0 0 !important;
 }
-/* Flex row: sidebar + main (first flex child of .stApp that wraps the app shell; header may be a sibling above this) */
+/* Flex row: sidebar + main */
 .stApp > div {
     display: flex !important;
     flex: 1 !important;
     min-height: 0 !important;
     overflow: hidden !important;
 }
-
-/* === Modern background patterns === */
-.stApp {
-    background-color: #fafbfc !important;
-    background-image:
-        /* Subtle dot grid */
-        radial-gradient(circle at 1px 1px, rgba(148, 163, 184, 0.12) 1px, transparent 0);
-    background-size: 28px 28px !important;
-    background-position: 0 0, 0 0 !important;
-}
 /* Soft gradient overlay for depth */
 .stApp::before {
     content: '';
@@ -139,7 +136,7 @@ section[data-testid="stSidebar"] {
     position: fixed !important;
     top: var(--s2f-streamlit-header-offset, 0px) !important;
     left: 0 !important;
-    width: 360px !important;
+    width: var(--s2f-sidebar-width) !important;
     height: calc(100dvh - var(--s2f-streamlit-header-offset, 0px)) !important;
     max-height: calc(100dvh - var(--s2f-streamlit-header-offset, 0px)) !important;
     overflow-x: hidden !important;
@@ -170,22 +167,6 @@ section[data-testid="stSidebar"] [data-testid="stWidgetLabel"] p {
     font-weight: 500 !important;
     color: #334155 !important;
 }
-.sidebar-section {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    padding: 0.5rem 0 0.25rem;
-    margin-top: 0.6rem;
-    border-bottom: 2px solid #94a3b8;
-    margin-bottom: 0.75rem;
-}
-.sidebar-section .section-title {
-    font-size: 0.78rem;
-    font-weight: 700;
-    color: var(--s2f-primary-dark);
-    text-transform: uppercase;
-    letter-spacing: 0.06em;
-}
 .sidebar-brand {
     display: flex;
     align-items: center;
@@ -193,10 +174,6 @@ section[data-testid="stSidebar"] [data-testid="stWidgetLabel"] p {
     padding-bottom: 0.65rem;
     margin-bottom: 0.35rem;
 }
-.sidebar-brand .brand-icon {
-    font-size: 1.6rem;
-    line-height: 1;
-}
 .sidebar-brand .brand-text {
     font-size: 1.1rem;
     font-weight: 700;
@@ -387,67 +364,6 @@ div[data-testid="stHorizontalBlock"]:has([data-testid="stDownloadButton"]):has([
     color: var(--s2f-primary-dark);
 }
 
-/* === Scale visualization === */
-.scale-viz {
-    margin: 0.3rem 0 0.5rem;
-    font-size: 0.78rem;
-    color: #64748b;
-}
-.sv-track {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-}
-.sv-end {
-    font-weight: 600;
-    font-size: 0.72rem;
-    color: #94a3b8;
-    min-width: 14px;
-    text-align: center;
-}
-.sv-bar {
-    flex: 1;
-    height: 10px;
-    background: #e2e8f0;
-    border-radius: 5px;
-    position: relative;
-    overflow: visible;
-}
-.sv-active {
-    position: absolute;
-    top: 0;
-    height: 100%;
-    background: linear-gradient(90deg, var(--s2f-primary), var(--s2f-primary-dark));
-    border-radius: 5px;
-    box-shadow: 0 1px 4px rgba(var(--s2f-primary-rgb), 0.3);
-}
-.sv-lbl {
-    position: absolute;
-    top: 14px;
-    font-size: 0.7rem;
-    font-weight: 700;
-    color: var(--s2f-primary-dark);
-    white-space: nowrap;
-}
-.sv-lbl-l { left: 0; }
-.sv-lbl-r { right: 0; }
-.sv-note {
-    display: flex;
-    align-items: center;
-    gap: 4px;
-    margin-top: 10px;
-    font-size: 0.75rem;
-    color: #64748b;
-}
-.sv-pill {
-    background: rgba(var(--s2f-primary-rgb), 0.15);
-    color: var(--s2f-primary-dark);
-    font-weight: 700;
-    padding: 1px 6px;
-    border-radius: 4px;
-    font-size: 0.72rem;
-}
-
 /* === Run prediction info bar === */
 .run-info {
     display: flex;
@@ -506,10 +422,7 @@ section[data-testid="stSidebar"] [data-testid="stMultiSelect"] > div > div:focus
     border-color: var(--s2f-primary) !important;
     box-shadow: 0 0 0 1px rgba(var(--s2f-primary-rgb), 0.28) !important;
 }
-/* Radio: selected circle uses accent color */
-[data-testid="stRadio"] input[type="radio"] {
-    accent-color: var(--s2f-primary);
-}
+/* Radio: accent color */
 [data-testid="stRadio"] input {
     accent-color: var(--s2f-primary);
 }
@@ -540,13 +453,19 @@ ul[role="listbox"] li {
     color: #1e293b !important;
     background-color: #ffffff !important;
 }
-.selectbox-label {
-    margin: 0;
-    padding-top: 0.4rem;
-    font-size: 0.9rem;
+/* Sidebar / form labels (colormap row, section titles) */
+.s2f-form-label {
+    font-size: 0.95rem;
     font-weight: 500;
     color: #334155;
     line-height: 1.2;
+    margin: 0;
+}
+.s2f-form-label--colormap {
+    padding-top: 0.4rem;
+}
+.s2f-form-label--section {
+    margin-bottom: 0.5rem;
 }
 
 /* === Dataframe === */
@@ -598,7 +517,7 @@ hr { border-color: #cbd5e1 !important; opacity: 0.7; }
 .footer-citation {
     position: fixed;
     bottom: 0;
-    left: 360px;
+    left: var(--s2f-sidebar-width);
     right: 0;
     z-index: 999;
     padding: 0.5rem 1rem 0.55rem;
@@ -615,7 +534,7 @@ hr { border-color: #cbd5e1 !important; opacity: 0.7; }
  */
 [data-testid="stAppViewContainer"],
 .appview-container .main {
-    margin-left: 360px !important;
+    margin-left: var(--s2f-sidebar-width) !important;
     flex: 1 !important;
     min-height: 0 !important;
     overflow-y: auto !important;
@@ -639,6 +558,49 @@ section[data-testid="stSidebar"] > div:first-child {
     padding-bottom: 0.5rem !important;
 }
 
+/* Measure tool: value panel (replaces inline styles in measure_tool.py) */
+.s2f-measure-vals-heading {
+    font-weight: 400;
+    color: #334155;
+    font-size: 0.95rem;
+    margin: 0 20px 4px 4px;
+}
+.s2f-measure-vals-panel {
+    width: 100%;
+    box-sizing: border-box;
+    border: 1px solid #e2e8f0;
+    border-radius: 10px;
+    padding: 10px 12px;
+    margin: 0 10px 20px 10px;
+    background: linear-gradient(145deg, #f8fafc 0%, #f1f5f9 100%);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);
+}
+.s2f-measure-vals-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 5px;
+    font-size: 0.9rem;
+}
+
+/* Dialog / expander: measure canvas layout */
+[data-testid="stDialog"] [data-testid="stSelectbox"],
+[data-testid="stExpander"] [data-testid="stSelectbox"],
+[data-testid="stDialog"] [data-testid="stSelectbox"] > div,
+[data-testid="stExpander"] [data-testid="stSelectbox"] > div {
+    width: 100% !important;
+    max-width: 100% !important;
+}
+[data-testid="stDialog"] [data-testid="stMetric"] label,
+[data-testid="stDialog"] [data-testid="stMetric"] [data-testid="stMetricValue"],
+[data-testid="stExpander"] [data-testid="stMetric"] label,
+[data-testid="stExpander"] [data-testid="stMetric"] [data-testid="stMetricValue"] {
+    font-size: 0.95rem !important;
+}
+[data-testid="stDialog"] img,
+[data-testid="stExpander"] img {
+    border-radius: 0 !important;
+}
+
 /* === Responsive === */
 @media (max-width: 768px) {
     .s2f-header {

ui/measure_tool.py

@@ -257,20 +257,6 @@ def render_region_canvas(display_heatmap, raw_heatmap=None, bf_img=None, origina
     heatmap_rgb = heatmap_to_rgb_with_contour(display_heatmap, colormap_name, cell_mask)
     pil_bg = Image.fromarray(heatmap_rgb).resize((CANVAS_SIZE, CANVAS_SIZE), Image.Resampling.LANCZOS)
 
-    st.markdown("""
-    <style>
-        [data-testid="stDialog"] [data-testid="stSelectbox"], [data-testid="stExpander"] [data-testid="stSelectbox"],
-        [data-testid="stDialog"] [data-testid="stSelectbox"] > div, [data-testid="stExpander"] [data-testid="stSelectbox"] > div {
-            width: 100% !important; max-width: 100% !important;
-        }
-        [data-testid="stDialog"] [data-testid="stMetric"] label, [data-testid="stDialog"] [data-testid="stMetric"] [data-testid="stMetricValue"],
-        [data-testid="stExpander"] [data-testid="stMetric"] label, [data-testid="stExpander"] [data-testid="stMetric"] [data-testid="stMetricValue"] {
-            font-size: 0.95rem !important;
-        }
-        [data-testid="stDialog"] img, [data-testid="stExpander"] img { border-radius: 0 !important; }
-    </style>
-    """, unsafe_allow_html=True)
-
     if bf_img is not None:
         bf_resized = cv2.resize(bf_img, (CANVAS_SIZE, CANVAS_SIZE))
         bf_rgb = cv2.cvtColor(bf_resized, cv2.COLOR_GRAY2RGB) if bf_img.ndim == 2 else cv2.cvtColor(bf_resized, cv2.COLOR_BGR2RGB)
@@ -288,19 +274,16 @@ def render_region_canvas(display_heatmap, raw_heatmap=None, bf_img=None, origina
             vals = cell_vals if cell_vals else original_vals
             if vals:
                 label = "Cell area" if cell_vals else "Full map"
-                st.markdown(f'<p style="font-weight: 400; color: #334155; font-size: 0.95rem; margin: 0 20px 4px 4px;">{label}</p>', unsafe_allow_html=True)
-                st.markdown(f"""
-                <div style="width: 100%; box-sizing: border-box; border: 1px solid #e2e8f0; border-radius: 10px;
-                    padding: 10px 12px; margin: 0 10px 20px 10px; background: linear-gradient(145deg, #f8fafc 0%, #f1f5f9 100%);
-                    box-shadow: 0 1px 3px rgba(0,0,0,0.06);">
-                    <div style="display: flex; flex-wrap: wrap; gap: 5px; font-size: 0.9rem;">
-                        <span><strong>Sum:</strong> {vals['pixel_sum']:.1f}</span>
-                        <span><strong>Force:</strong> {vals['force']:.1f}</span>
-                        <span><strong>Max:</strong> {vals['max']:.3f}</span>
-                        <span><strong>Mean:</strong> {vals['mean']:.3f}</span>
-                    </div>
-                </div>
-                """, unsafe_allow_html=True)
+                st.markdown(
+                    f'<p class="s2f-measure-vals-heading">{html.escape(label)}</p>'
+                    f'<div class="s2f-measure-vals-panel"><div class="s2f-measure-vals-grid">'
+                    f"<span><strong>Sum:</strong> {vals['pixel_sum']:.1f}</span>"
+                    f"<span><strong>Force:</strong> {vals['force']:.1f}</span>"
+                    f"<span><strong>Max:</strong> {vals['max']:.3f}</span>"
+                    f"<span><strong>Mean:</strong> {vals['mean']:.3f}</span>"
+                    f"</div></div>",
+                    unsafe_allow_html=True,
+                )
             st.caption("Bright-field")
             bf_display = bf_rgb.copy()
             if cell_mask is not None and np.any(cell_mask > 0):

ui/result_display.py

@@ -10,7 +10,7 @@ import streamlit as st
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 
-from utils.display import apply_display_scale, cv_colormap_to_plotly_colorscale
+from utils.display import apply_display_scale, cv_colormap_to_plotly_colorscale, is_display_range_remapped
 from utils.report import heatmap_to_rgb_with_contour, heatmap_to_png_bytes, create_pdf_report
 from utils.segmentation import estimate_cell_mask
 from ui.heatmaps import render_horizontal_colorbar, add_cell_contour_to_fig
@@ -29,8 +29,15 @@ _HISTOGRAM_HEIGHT = 180
 _BATCH_PREVIEW_LIMIT = 3
 
 
+def _result_banner(badge: str, badge_class: str, title: str) -> str:
+    """HTML row for INPUT/OUTPUT section titles (batch + single views). badge_class: input | output."""
+    return (
+        f'<div class="result-label"><span class="result-badge {badge_class}">{badge}</span> {title}</div>'
+    )
+
+
 def render_batch_results(batch_results, colormap_name="Jet", display_mode="Default",
-                        min_percentile=0, max_percentile=100, clip_min=0, clip_max=1,
+                        clip_min=0, clip_max=1,
                         auto_cell_boundary=False, clamp_only=False):
     """
     Render batch prediction results: summary table, bright-field row, heatmap row, and bulk download.
@@ -48,7 +55,6 @@ def render_batch_results(batch_results, colormap_name="Jet", display_mode="Defau
             r["_cell_mask"] = r.get("cell_mask") if auto_cell_boundary else None
         r["_display_heatmap"] = apply_display_scale(
             r["heatmap"], display_mode,
-            min_percentile=min_percentile, max_percentile=max_percentile,
             clip_min=clip_min, clip_max=clip_max, clamp_only=clamp_only,
         )
     # Build table rows - consistent column names for both modes
@@ -71,7 +77,7 @@ def render_batch_results(batch_results, colormap_name="Jet", display_mode="Defau
                    f"{np.max(heatmap):.4f}", f"{np.mean(heatmap):.4f}"]
         rows.append(row)
         csv_rows.append([os.path.splitext(key)[0]] + row[1:])
-    st.markdown('<div class="result-label"><span class="result-badge input">INPUT</span> Bright-field images</div>', unsafe_allow_html=True)
+    st.markdown(_result_banner("INPUT", "input", "Bright-field images"), unsafe_allow_html=True)
     n_cols = min(5, len(batch_results))
     preview_count = min(_BATCH_PREVIEW_LIMIT, len(batch_results))
     preview_results = batch_results[:preview_count]
@@ -85,8 +91,8 @@ def render_batch_results(batch_results, colormap_name="Jet", display_mode="Defau
             img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
         with bf_cols[i % min(n_cols, preview_count)]:
             st.image(img_rgb, caption=r["key_img"], use_container_width=True)
-    is_rescale_b = display_mode == "Range" and clip_max > clip_min and not (clip_min == 0 and clip_max == 1)
-    st.markdown('<div class="result-label"><span class="result-badge output">OUTPUT</span> Predicted force maps</div>', unsafe_allow_html=True)
+    is_rescale_b = is_display_range_remapped(display_mode, clip_min, clip_max)
+    st.markdown(_result_banner("OUTPUT", "output", "Predicted force maps"), unsafe_allow_html=True)
     hm_cols = st.columns(min(n_cols, preview_count))
     for i, r in enumerate(preview_results):
         hm_rgb = heatmap_to_rgb_with_contour(
@@ -97,7 +103,7 @@ def render_batch_results(batch_results, colormap_name="Jet", display_mode="Defau
             st.image(hm_rgb, caption=r["key_img"], use_container_width=True)
     if remaining_results:
         with st.expander(f"Show remaining batch previews ({len(remaining_results)})", expanded=False):
-            st.markdown('<div class="result-label"><span class="result-badge input">INPUT</span> Remaining bright-field images</div>', unsafe_allow_html=True)
+            st.markdown(_result_banner("INPUT", "input", "Remaining bright-field images"), unsafe_allow_html=True)
             rem_bf_cols = st.columns(min(5, len(remaining_results)))
             for i, r in enumerate(remaining_results):
                 img = r["img"]
@@ -107,7 +113,7 @@ def render_batch_results(batch_results, colormap_name="Jet", display_mode="Defau
                     img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
                 with rem_bf_cols[i % min(5, len(remaining_results))]:
                     st.image(img_rgb, caption=r["key_img"], use_container_width=True)
-            st.markdown('<div class="result-label"><span class="result-badge output">OUTPUT</span> Remaining predicted force maps</div>', unsafe_allow_html=True)
+            st.markdown(_result_banner("OUTPUT", "output", "Remaining predicted force maps"), unsafe_allow_html=True)
             rem_hm_cols = st.columns(min(5, len(remaining_results)))
             for i, r in enumerate(remaining_results):
                 hm_rgb = heatmap_to_rgb_with_contour(
@@ -211,13 +217,13 @@ def render_result_display(img, raw_heatmap, display_heatmap, pixel_sum, force, k
 
     buf_hm = heatmap_to_png_bytes(display_heatmap, colormap_name, cell_mask=cell_mask)
 
-    is_rescale = display_mode == "Range" and clip_max > clip_min and not (clip_min == 0.0 and clip_max == 1.0)
+    is_rescale = is_display_range_remapped(display_mode, clip_min, clip_max)
 
     tit1, tit2 = st.columns(2)
     with tit1:
-        st.markdown('<div class="result-label"><span class="result-badge input">INPUT</span> Bright-field image</div>', unsafe_allow_html=True)
+        st.markdown(_result_banner("INPUT", "input", "Bright-field image"), unsafe_allow_html=True)
     with tit2:
-        st.markdown('<div class="result-label"><span class="result-badge output">OUTPUT</span> Predicted force map</div>', unsafe_allow_html=True)
+        st.markdown(_result_banner("OUTPUT", "output", "Predicted force map"), unsafe_allow_html=True)
     fig_pl = make_subplots(rows=1, cols=2)
     fig_pl.add_trace(go.Heatmap(z=img, colorscale="gray", showscale=False), row=1, col=1)
     plotly_colorscale = cv_colormap_to_plotly_colorscale(colormap_name)

utils/display.py

@@ -4,14 +4,6 @@ import cv2
 
 from config.constants import COLORMAPS, COLORMAP_N_SAMPLES
 
-# Legacy aliases (single mapping at entry — app uses Default / Range / Percentile / Rescale only)
-_DISPLAY_MODE_ALIASES = {
-    "Auto": "Default",
-    "Full": "Default",
-    "Filter": "Range",
-    "Threshold": "Range",
-}
-
 
 def cv_colormap_to_plotly_colorscale(colormap_name, n_samples=None):
     """Build a Plotly colorscale from OpenCV colormap so UI matches download/PDF exactly."""
@@ -27,54 +19,43 @@ def cv_colormap_to_plotly_colorscale(colormap_name, n_samples=None):
     return scale
 
 
-def apply_display_scale(heatmap, mode, min_percentile=0, max_percentile=100,
-                        clip_min=0, clip_max=1, clamp_only=False):
+def is_display_range_remapped(display_mode, clip_min, clip_max):
+    """
+    True when the UI uses Range mode with a clip window other than the full [0, 1]
+    (colorbar tick labels map normalized 0–1 to that interval).
+    """
+    if display_mode != "Range":
+        return False
+    lo, hi = float(clip_min), float(clip_max)
+    return hi > lo and not (lo == 0.0 and hi == 1.0)
+
+
+def apply_display_scale(heatmap, mode, clip_min=0, clip_max=1, clamp_only=False):
     """
     Apply display scaling. Display only—does not change underlying values.
 
+    Supports modes used by the app: ``Default`` (clip to [0, 1]) and ``Range``
+    (window to [clip_min, clip_max]). Unknown ``mode`` is treated like ``Default``.
+
     Parameters
     ----------
     clamp_only : bool
-        Only used for ``mode == "Range"`` or ``mode == "Rescale"`` when ``clip_max > clip_min``:
+        For ``mode == "Range"`` when ``clip_max > clip_min``:
 
-        - **False** (default for Range in the app): pixels outside ``[clip_min, clip_max]`` are set
-          to 0; values inside are linearly mapped to ``[0, 1]`` so the colormap uses the full
-          dynamic range (blue→red) within that interval.
-        - **True**: values are clamped to ``[clip_min, clip_max]`` but **not** rescaled to
-          ``[0, 1]`` (rarely used for the main heatmap view; can compress colormap contrast).
+        - **False** (default in the app for Range): pixels outside ``[clip_min, clip_max]`` are set
+          to 0; values inside are linearly mapped to ``[0, 1]`` for the colormap.
+        - **True**: values are clamped to ``[clip_min, clip_max]`` without rescaling to ``[0, 1]``.
     """
-    mode = _DISPLAY_MODE_ALIASES.get(mode, mode)
-
-    if mode == "Default":
-        return np.clip(heatmap, 0, 1).astype(np.float32)
-    if mode == "Percentile":
-        pmin = float(np.percentile(heatmap, min_percentile))
-        pmax = float(np.percentile(heatmap, max_percentile))
-        if pmax > pmin:
-            out = (heatmap.astype(np.float32) - pmin) / (pmax - pmin)
-            return np.clip(out, 0, 1).astype(np.float32)
-        return np.clip(heatmap, 0, 1).astype(np.float32)
-    if mode == "Range":
-        vmin, vmax = float(clip_min), float(clip_max)
-        if vmax > vmin:
-            h = heatmap.astype(np.float32)
-            if clamp_only:
-                return np.clip(h, vmin, vmax).astype(np.float32)
-            mask = (h >= vmin) & (h <= vmax)
-            out = np.zeros_like(h)
-            out[mask] = (h[mask] - vmin) / (vmax - vmin)
-            return np.clip(out, 0, 1).astype(np.float32)
-        return np.clip(heatmap, 0, 1).astype(np.float32)
-    if mode == "Rescale":
-        vmin, vmax = float(clip_min), float(clip_max)
-        if vmax > vmin:
-            h = heatmap.astype(np.float32)
-            if clamp_only:
-                clamped = np.clip(h, vmin, vmax)
-                return ((clamped - vmin) / (vmax - vmin)).astype(np.float32)
-            mask = (h >= vmin) & (h <= vmax)
-            out = np.zeros_like(h)
-            out[mask] = (h[mask] - vmin) / (vmax - vmin)
-            return np.clip(out, 0, 1).astype(np.float32)
+    if mode != "Range":
         return np.clip(heatmap, 0, 1).astype(np.float32)
+    # Range
+    vmin, vmax = float(clip_min), float(clip_max)
+    if vmax > vmin:
+        h = heatmap.astype(np.float32)
+        if clamp_only:
+            return np.clip(h, vmin, vmax).astype(np.float32)
+        mask = (h >= vmin) & (h <= vmax)
+        out = np.zeros_like(h)
+        out[mask] = (h[mask] - vmin) / (vmax - vmin)
+        return np.clip(out, 0, 1).astype(np.float32)
     return np.clip(heatmap, 0, 1).astype(np.float32)