optimised

S2FApp/app.py

@@ -17,10 +17,12 @@ if S2F_ROOT not in sys.path:
 
 from config.constants import (
     COLORMAPS,
+    DEFAULT_SUBSTRATE,
     MODEL_TYPE_LABELS,
     SAMPLE_EXTENSIONS,
+    SAMPLE_THUMBNAIL_LIMIT,
 )
-from utils.paths import get_ckp_base, model_subfolder
+from utils.paths import get_ckp_base, get_ckp_folder, get_sample_folder, list_files_in_folder, model_subfolder
 from utils.segmentation import estimate_cell_mask
 from utils.substrate_settings import list_substrates
 from utils.display import apply_display_scale
@@ -70,9 +72,10 @@ def _get_measure_dialog_fn():
 
 
 def _populate_measure_session_state(heatmap, img, pixel_sum, force, key_img, colormap_name,
-                                    display_mode, auto_cell_boundary):
-    """Populate session state for the measure tool."""
-    cell_mask = estimate_cell_mask(heatmap)
+                                    display_mode, auto_cell_boundary, cell_mask=None):
+    """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_bf_img"] = img.copy()
@@ -135,25 +138,6 @@ st.caption("Predict traction force maps from bright-field microscopy images of c
 
 # Folders
 ckp_base = get_ckp_base(S2F_ROOT)
-ckp_single_cell = os.path.join(ckp_base, "single_cell")
-ckp_spheroid = os.path.join(ckp_base, "spheroid")
-sample_base = os.path.join(S2F_ROOT, "samples")
-sample_single_cell = os.path.join(sample_base, "single_cell")
-sample_spheroid = os.path.join(sample_base, "spheroid")
-
-
-def get_ckp_files_for_model(model_type):
-    folder = ckp_single_cell if model_type == "single_cell" else ckp_spheroid
-    if os.path.isdir(folder):
-        return sorted(f for f in os.listdir(folder) if f.endswith(".pth"))
-    return []
-
-
-def get_sample_files_for_model(model_type):
-    folder = sample_single_cell if model_type == "single_cell" else sample_spheroid
-    if os.path.isdir(folder):
-        return sorted(f for f in os.listdir(folder) if f.lower().endswith(SAMPLE_EXTENSIONS))
-    return []
 
 
 def get_cached_sample_thumbnails(model_type, sample_folder, sample_files):
@@ -164,7 +148,7 @@ def get_cached_sample_thumbnails(model_type, sample_folder, sample_files):
     cache = st.session_state["sample_thumbnails"]
     if cache_key not in cache:
         thumbnails = []
-        for fname in sample_files[:8]:
+        for fname in sample_files[:SAMPLE_THUMBNAIL_LIMIT]:
             path = os.path.join(sample_folder, fname)
             img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
             thumbnails.append((fname, img))
@@ -184,8 +168,8 @@ with st.sidebar:
         help="Single cell: substrate-aware force prediction. Spheroid: spheroid force maps.",
     )
 
-    ckp_files = get_ckp_files_for_model(model_type)
-    ckp_folder = ckp_single_cell if model_type == "single_cell" else ckp_spheroid
+    ckp_folder = get_ckp_folder(ckp_base, model_type)
+    ckp_files = list_files_in_folder(ckp_folder, ".pth")
     ckp_subfolder_name = model_subfolder(model_type)
 
     if ckp_files:
@@ -199,7 +183,7 @@ with st.sidebar:
         checkpoint = None
 
     substrate_config = None
-    substrate_val = "Fibroblasts_Fibronectin_6KPa"
+    substrate_val = DEFAULT_SUBSTRATE
     use_manual = True
     if model_type == "single_cell":
         try:
@@ -270,8 +254,8 @@ if img_source == "Upload":
         img = cv2.imdecode(nparr, cv2.IMREAD_GRAYSCALE)
         uploaded.seek(0)
 else:
-    sample_files = get_sample_files_for_model(model_type)
-    sample_folder = sample_single_cell if model_type == "single_cell" else sample_spheroid
+    sample_folder = get_sample_folder(S2F_ROOT, model_type)
+    sample_files = list_files_in_folder(sample_folder, SAMPLE_EXTENSIONS)
     sample_subfolder_name = model_subfolder(model_type)
     if sample_files:
         selected_sample = st.selectbox(
@@ -333,7 +317,7 @@ if just_ran:
     with st.spinner("Loading model and predicting..."):
         try:
             predictor = get_or_create_predictor(model_type, checkpoint, ckp_folder)
-            sub_val = substrate_val if model_type == "single_cell" and not use_manual else "Fibroblasts_Fibronectin_6KPa"
+            sub_val = substrate_val if model_type == "single_cell" and not use_manual else DEFAULT_SUBSTRATE
             heatmap, force, pixel_sum = predictor.predict(
                 image_array=img,
                 substrate=sub_val,
@@ -352,17 +336,18 @@ if just_ran:
                 "pixel_sum": pixel_sum,
                 "cache_key": cache_key,
             }
+            cell_mask = estimate_cell_mask(heatmap) if auto_cell_boundary else None
             _populate_measure_session_state(
                 heatmap, img, pixel_sum, force, key_img, colormap_name,
-                display_mode, auto_cell_boundary,
+                display_mode, auto_cell_boundary, cell_mask=cell_mask,
             )
-
             render_result_display(
                 img, heatmap, display_heatmap, pixel_sum, force, key_img,
                 colormap_name=colormap_name,
                 display_mode=display_mode,
                 measure_region_dialog=_get_measure_dialog_fn(),
                 auto_cell_boundary=auto_cell_boundary,
+                cell_mask=cell_mask,
             )
 
         except Exception as e:
@@ -373,10 +358,10 @@ elif has_cached:
     r = st.session_state["prediction_result"]
     img, heatmap, force, pixel_sum = r["img"], r["heatmap"], r["force"], r["pixel_sum"]
     display_heatmap = apply_display_scale(heatmap, display_mode)
-
+    cell_mask = estimate_cell_mask(heatmap) if auto_cell_boundary else None
     _populate_measure_session_state(
         heatmap, img, pixel_sum, force, key_img, colormap_name,
-        display_mode, auto_cell_boundary,
+        display_mode, auto_cell_boundary, cell_mask=cell_mask,
     )
 
     if st.session_state.pop("open_measure_dialog", False):
@@ -390,6 +375,7 @@ elif has_cached:
         display_mode=display_mode,
         measure_region_dialog=_get_measure_dialog_fn(),
         auto_cell_boundary=auto_cell_boundary,
+        cell_mask=cell_mask,
     )
 
 elif run and not checkpoint:

S2FApp/config/constants.py

@@ -6,8 +6,12 @@ import cv2
 # Model & paths
 MODEL_INPUT_SIZE = 1024
 
+# Default substrate (used when config lookup fails or manual mode fallback)
+DEFAULT_SUBSTRATE = "Fibroblasts_Fibronectin_6KPa"
+
 # UI
 CANVAS_SIZE = 320
+SAMPLE_THUMBNAIL_LIMIT = 8
 COLORMAP_N_SAMPLES = 64
 
 # Model type labels

S2FApp/predictor.py

@@ -13,20 +13,22 @@ S2F_ROOT = os.path.dirname(os.path.abspath(__file__))
 if S2F_ROOT not in sys.path:
     sys.path.insert(0, S2F_ROOT)
 
+from config.constants import DEFAULT_SUBSTRATE, MODEL_INPUT_SIZE
 from models.s2f_model import create_s2f_model
 from utils.paths import get_ckp_base, model_subfolder
 from utils.substrate_settings import get_settings_of_category, compute_settings_normalization
 from utils import config
 
 
-def load_image(filepath, target_size=1024):
+def load_image(filepath, target_size=None):
     """Load and preprocess a bright field image."""
     img = cv2.imread(filepath, cv2.IMREAD_GRAYSCALE)
     if img is None:
         raise ValueError(f"Could not load image: {filepath}")
-    if isinstance(target_size, int):
-        target_size = (target_size, target_size)
-    img = cv2.resize(img, target_size)
+    size = target_size if target_size is not None else MODEL_INPUT_SIZE
+    if isinstance(size, int):
+        size = (size, size)
+    img = cv2.resize(img, size)
     img = img.astype(np.float32) / 255.0
     return img
 
@@ -126,7 +128,7 @@ class S2FPredictor:
         self._use_tanh_output = model_type == "single_cell"  # single_cell uses tanh, spheroid uses sigmoid
         self.config_path = os.path.join(S2F_ROOT, "config", "substrate_settings.json")
 
-    def predict(self, image_path=None, image_array=None, substrate="Fibroblasts_Fibronectin_6KPa",
+    def predict(self, image_path=None, image_array=None, substrate=None,
                 substrate_config=None):
         """
         Run prediction on an image.
@@ -138,7 +140,7 @@ class S2FPredictor:
             substrate_config: Optional dict with 'pixelsize' and 'young'. Overrides substrate lookup.
 
         Returns:
-            heatmap: numpy array (1024, 1024) in [0, 1]
+            heatmap: numpy array (MODEL_INPUT_SIZE, MODEL_INPUT_SIZE) in [0, 1]
             force: scalar cell force (sum of heatmap * SCALE_FACTOR_FORCE)
             pixel_sum: raw sum of all pixel values in heatmap
         """
@@ -150,15 +152,16 @@ class S2FPredictor:
                 img = img[:, :, 0] if img.shape[-1] >= 1 else img
             if img.max() > 1.0:
                 img = img / 255.0
-            img = cv2.resize(img, (1024, 1024))
+            img = cv2.resize(img, (MODEL_INPUT_SIZE, MODEL_INPUT_SIZE))
         else:
             raise ValueError("Provide image_path or image_array")
 
         x = torch.from_numpy(img).float().unsqueeze(0).unsqueeze(0).to(self.device)  # [1,1,H,W]
 
         if self.model_type == "single_cell" and self.norm_params is not None:
+            sub = substrate if substrate is not None else DEFAULT_SUBSTRATE
             settings_ch = create_settings_channels_single(
-                substrate, self.device, x.shape[2], x.shape[3],
+                sub, self.device, x.shape[2], x.shape[3],
                 config_path=self.config_path, substrate_config=substrate_config
             )
             x = torch.cat([x, settings_ch], dim=1)  # [1,3,H,W]

S2FApp/ui/components.py

@@ -50,18 +50,23 @@ _REGION_COLORS = [
 ]
 
 
-def make_annotated_heatmap(heatmap_rgb, mask, fill_alpha=0.3, stroke_color=(255, 102, 0), stroke_width=2):
-    """Composite heatmap with drawn region overlay."""
-    annotated = heatmap_rgb.copy()
+def _draw_region_overlay(annotated, mask, color, fill_alpha=0.3, stroke_width=2):
+    """Draw single region overlay on annotated heatmap (fill + alpha blend + contour). Modifies annotated in place."""
     contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     overlay = annotated.copy()
-    cv2.fillPoly(overlay, contours, stroke_color)
+    cv2.fillPoly(overlay, contours, color)
     mask_3d = np.stack([mask] * 3, axis=-1).astype(bool)
     annotated[mask_3d] = (
         (1 - fill_alpha) * annotated[mask_3d].astype(np.float32)
         + fill_alpha * overlay[mask_3d].astype(np.float32)
     ).astype(np.uint8)
-    cv2.drawContours(annotated, contours, -1, stroke_color, stroke_width)
+    cv2.drawContours(annotated, contours, -1, color, stroke_width)
+
+
+def make_annotated_heatmap(heatmap_rgb, mask, fill_alpha=0.3, stroke_color=(255, 102, 0), stroke_width=2):
+    """Composite heatmap with drawn region overlay."""
+    annotated = heatmap_rgb.copy()
+    _draw_region_overlay(annotated, mask, stroke_color, fill_alpha, stroke_width)
     return annotated
 
 
@@ -73,15 +78,7 @@ def make_annotated_heatmap_multi_regions(heatmap_rgb, masks, labels, cell_mask=N
         cv2.drawContours(annotated, contours, -1, (255, 0, 0), 2)
     for i, mask in enumerate(masks):
         color = _REGION_COLORS[i % len(_REGION_COLORS)]
-        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        overlay = annotated.copy()
-        cv2.fillPoly(overlay, contours, color)
-        mask_3d = np.stack([mask] * 3, axis=-1).astype(bool)
-        annotated[mask_3d] = (
-            (1 - fill_alpha) * annotated[mask_3d].astype(np.float32)
-            + fill_alpha * overlay[mask_3d].astype(np.float32)
-        ).astype(np.uint8)
-        cv2.drawContours(annotated, contours, -1, color, 2)
+        _draw_region_overlay(annotated, mask, color, fill_alpha, stroke_width=2)
         # Label at centroid
         M = cv2.moments(mask)
         if M["m00"] > 0:
@@ -159,7 +156,7 @@ def _obj_to_pts(obj, scale_x, scale_y, heatmap_w, heatmap_h):
 def parse_canvas_shapes_to_masks(json_data, canvas_h, canvas_w, heatmap_h, heatmap_w):
     """Parse drawn shapes and return a list of individual masks (one per shape)."""
     if not json_data or "objects" not in json_data or not json_data["objects"]:
-        return [], 0
+        return []
     scale_x = heatmap_w / canvas_w
     scale_y = heatmap_h / canvas_h
     masks = []
@@ -170,7 +167,7 @@ def parse_canvas_shapes_to_masks(json_data, canvas_h, canvas_w, heatmap_h, heatm
         mask = np.zeros((heatmap_h, heatmap_w), dtype=np.uint8)
         cv2.fillPoly(mask, [pts], 1)
         masks.append(mask)
-    return masks, len(masks)
+    return masks
 
 
 def build_original_vals(raw_heatmap, pixel_sum, force):
@@ -385,8 +382,8 @@ def render_region_canvas(display_heatmap, raw_heatmap=None, bf_img=None, origina
         )
 
     if canvas_result.json_data:
-        masks, n = parse_canvas_shapes_to_masks(canvas_result.json_data, CANVAS_SIZE, CANVAS_SIZE, h, w)
-        if masks and n > 0:
+        masks = parse_canvas_shapes_to_masks(canvas_result.json_data, CANVAS_SIZE, CANVAS_SIZE, h, w)
+        if masks:
             metrics_list = [compute_region_metrics(raw_heatmap, m, original_vals) for m in masks]
             if cell_mask is not None and np.any(cell_mask > 0):
                 cell_metrics = compute_region_metrics(raw_heatmap, cell_mask, original_vals)
@@ -433,13 +430,18 @@ def _add_cell_contour_to_fig(fig_pl, cell_mask, row=1, col=2):
 
 
 def render_result_display(img, raw_heatmap, display_heatmap, pixel_sum, force, key_img, download_key_suffix="",
-                         colormap_name="Jet", display_mode="Auto", measure_region_dialog=None, auto_cell_boundary=True):
+                         colormap_name="Jet", display_mode="Auto", measure_region_dialog=None, auto_cell_boundary=True,
+                         cell_mask=None):
     """
     Render prediction result: plot, metrics, expander, and download/measure buttons.
     measure_region_dialog: callable to open measure dialog (when ST_DIALOG available).
     auto_cell_boundary: when True, use estimated cell area for metrics; when False, use entire map.
+    cell_mask: optional precomputed cell mask; if None and auto_cell_boundary, will be computed.
     """
-    cell_mask = estimate_cell_mask(raw_heatmap) if auto_cell_boundary else None
+    if cell_mask is None and auto_cell_boundary:
+        cell_mask = estimate_cell_mask(raw_heatmap)
+    elif not auto_cell_boundary:
+        cell_mask = None
     cell_pixel_sum, cell_force, cell_mean = _compute_cell_metrics(raw_heatmap, cell_mask, pixel_sum, force) if cell_mask is not None else (None, None, None)
     use_cell_metrics = auto_cell_boundary and cell_pixel_sum is not None and cell_force is not None and cell_mean is not None
 

S2FApp/utils/metrics.py

@@ -4,6 +4,8 @@ Includes: MSE, MS-SSIM, Pixel Correlation (Pearson), Relative Magnitude Error (W
 and evaluation helpers for notebooks and scripts.
 """
 import os
+
+from config.constants import DEFAULT_SUBSTRATE
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -237,7 +239,7 @@ def evaluate_metrics_on_dataset(generator, data_loader, device=None, description
 
             if use_settings and normalization_params is not None:
                 from models.s2f_model import create_settings_channels
-                meta = metadata if has_metadata else {'substrate': [substrate_override or 'Fibroblasts_Fibronectin_6KPa'] * images.size(0)}
+                meta = metadata if has_metadata else {'substrate': [substrate_override or DEFAULT_SUBSTRATE] * images.size(0)}
                 settings_ch = create_settings_channels(meta, normalization_params, device, images.shape, config_path=config_path)
                 images = torch.cat([images, settings_ch], dim=1)
 
@@ -420,7 +422,7 @@ def plot_predictions(loader, generator, n_samples, device, threshold=0.0,
     bf_batch = torch.stack(bf_list[:n]).to(device, dtype=torch.float32)
     if use_settings and normalization_params:
         from models.s2f_model import create_settings_channels
-        sub = substrate_override or 'Fibroblasts_Fibronectin_6KPa'
+        sub = substrate_override or DEFAULT_SUBSTRATE
         meta_dict = {'substrate': [sub] * n}
         settings_ch = create_settings_channels(meta_dict, normalization_params, device, bf_batch.shape, config_path=config_path)
         bf_batch = torch.cat([bf_batch, settings_ch], dim=1)

S2FApp/utils/paths.py

@@ -15,3 +15,29 @@ def get_ckp_base(root):
 def model_subfolder(model_type):
     """Return subfolder name for model type: 'single_cell' or 'spheroid'."""
     return "single_cell" if model_type == "single_cell" else "spheroid"
+
+
+def get_ckp_folder(ckp_base, model_type):
+    """Return checkpoint folder path for model type."""
+    return os.path.join(ckp_base, model_subfolder(model_type))
+
+
+def get_sample_folder(root, model_type):
+    """Return sample folder path for model type (samples/<subfolder>)."""
+    return os.path.join(root, "samples", model_subfolder(model_type))
+
+
+def list_files_in_folder(folder, extensions):
+    """
+    List files in folder matching extensions. Returns sorted list.
+    extensions: str or tuple of suffixes, e.g. '.pth' or ('.tif', '.png'). Matching is case-insensitive.
+    """
+    if not os.path.isdir(folder):
+        return []
+    ext_tuple = (extensions,) if isinstance(extensions, str) else extensions
+
+    def matches(fname):
+        fname_lower = fname.lower()
+        return any(fname_lower.endswith(e.lower()) for e in ext_tuple)
+
+    return sorted(f for f in os.listdir(folder) if matches(f))

S2FApp/utils/report.py

@@ -13,6 +13,41 @@ from reportlab.pdfgen import canvas
 from config.constants import COLORMAPS
 
 
+def _draw_pdf_footer(c, margin=72, footer_y=40, include_web_app=False):
+    """Draw common footer for S2F PDF reports."""
+    c.setFont("Helvetica", 8)
+    c.setFillColorRGB(0.4, 0.4, 0.4)
+    gen_date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    c.drawString(margin, footer_y, f"Generated by Shape2Force (S2F) on {gen_date}")
+    c.drawString(margin, footer_y - 12, "Model: https://huggingface.co/Angione-Lab/Shape2Force")
+    if include_web_app:
+        c.drawString(margin, footer_y - 24, "Web app: https://huggingface.co/spaces/Angione-Lab/Shape2force")
+    c.setFillColorRGB(0, 0, 0)
+
+
+def _pdf_image_layout(page_w_pt, page_h_pt, margin=72, n_images=2):
+    """Return layout dict for centered side-by-side images: img_w, img_h, img_gap, img_left, bf_x, hm_x, img_bottom, y_top."""
+    img_w = 2.8 * inch
+    img_h = 2.8 * inch
+    img_gap = 20
+    total_img_width = n_images * img_w + (n_images - 1) * img_gap
+    img_left = margin + (page_w_pt - 2 * margin - total_img_width) / 2
+    bf_x = img_left
+    hm_x = img_left + img_w + img_gap
+    y_top = page_h_pt - 50
+    img_bottom = y_top - 35 - img_h  # header (title + image name) takes 35pt
+    return {
+        "img_w": img_w,
+        "img_h": img_h,
+        "img_gap": img_gap,
+        "img_left": img_left,
+        "bf_x": bf_x,
+        "hm_x": hm_x,
+        "img_bottom": img_bottom,
+        "y_top": y_top,
+    }
+
+
 def heatmap_to_rgb(scaled_heatmap, colormap_name="Jet"):
     """Convert scaled heatmap (float 0-1) to RGB array using the given colormap."""
     heatmap_uint8 = (np.clip(scaled_heatmap, 0, 1) * 255).astype(np.uint8)
@@ -47,35 +82,23 @@ def create_pdf_report(img, display_heatmap, raw_heatmap, pixel_sum, force, base_
     c = canvas.Canvas(buf, pagesize=A4)
     c.setTitle("Shape2Force")
     c.setAuthor("Angione-Lab")
-    page_w_pt = A4[0]
-    page_h_pt = A4[1]
+    page_w_pt, page_h_pt = A4[0], A4[1]
     margin = 72
-    img_w, img_h = 2.8 * inch, 2.8 * inch
-    img_gap = 20
-
-    # Center images
-    total_img_width = 2 * img_w + img_gap
-    img_left = margin + (page_w_pt - 2 * margin - total_img_width) / 2
-    bf_x = img_left
-    hm_x = img_left + img_w + img_gap
-
-    footer_y = 40
-    c.setFont("Helvetica", 8)
-    c.setFillColorRGB(0.4, 0.4, 0.4)
-    gen_date = datetime.now().strftime("%Y-%m-%d %H:%M")
-    c.drawString(margin, footer_y, f"Generated by Shape2Force (S2F) on {gen_date}")
-    c.drawString(margin, footer_y - 12, "Model: https://huggingface.co/Angione-Lab/Shape2Force")
-    c.drawString(margin, footer_y - 24, "Web app: https://huggingface.co/spaces/Angione-Lab/Shape2force")
-    c.setFillColorRGB(0, 0, 0)
-
-    y_top = page_h_pt - 50
+    layout = _pdf_image_layout(page_w_pt, page_h_pt, margin)
+    img_w = layout["img_w"]
+    img_h = layout["img_h"]
+    bf_x = layout["bf_x"]
+    hm_x = layout["hm_x"]
+    img_bottom = layout["img_bottom"]
+    y_top = layout["y_top"]
+
+    _draw_pdf_footer(c, margin=margin, include_web_app=True)
     c.setFont("Helvetica-Bold", 16)
     c.drawString(margin, y_top, "Shape2Force (S2F) - Prediction Report")
     c.setFont("Helvetica", 10)
     c.drawString(margin, y_top - 14, f"Image: {base_name}")
     y_top -= 35
 
-    img_bottom = y_top - img_h
     img_pil = Image.fromarray(img) if img.ndim == 2 else Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
     img_buf = io.BytesIO()
     img_pil.save(img_buf, format="PNG")
@@ -133,36 +156,22 @@ def create_measure_pdf_report(bf_img, heatmap_labeled_rgb, table_rows, base_name
     c = canvas.Canvas(buf, pagesize=A4)
     c.setTitle("Shape2Force - Region Measurement")
     c.setAuthor("Angione-Lab")
-    page_w_pt = A4[0]
-    page_h_pt = A4[1]
+    page_w_pt, page_h_pt = A4[0], A4[1]
     margin = 72
-    img_w = 2.8 * inch
-    img_h = 2.8 * inch
-    img_gap = 20
-
-    # Center images: two images side by side
-    total_img_width = 2 * img_w + img_gap
-    img_left = margin + (page_w_pt - 2 * margin - total_img_width) / 2
-    bf_x = img_left
-    hm_x = img_left + img_w + img_gap
-
-    footer_y = 40
-    c.setFont("Helvetica", 8)
-    c.setFillColorRGB(0.4, 0.4, 0.4)
-    gen_date = datetime.now().strftime("%Y-%m-%d %H:%M")
-    c.drawString(margin, footer_y, f"Generated by Shape2Force (S2F) on {gen_date}")
-    c.drawString(margin, footer_y - 12, "Model: https://huggingface.co/Angione-Lab/Shape2Force")
-    c.setFillColorRGB(0, 0, 0)
-
-    y_top = page_h_pt - 50
+    layout = _pdf_image_layout(page_w_pt, page_h_pt, margin)
+    img_w = layout["img_w"]
+    img_h = layout["img_h"]
+    bf_x = layout["bf_x"]
+    hm_x = layout["hm_x"]
+    img_bottom = layout["img_bottom"]
+    y_top = layout["y_top"]
+
+    _draw_pdf_footer(c, margin=margin)
     c.setFont("Helvetica-Bold", 14)
     c.drawString(margin, y_top, "Region Measurement Report")
     c.setFont("Helvetica", 10)
     c.drawString(margin, y_top - 14, f"Image: {base_name}")
-    y_top -= 35
 
-    # Images (centered)
-    img_bottom = y_top - img_h
     bf_pil = Image.fromarray(bf_img) if bf_img.ndim == 2 else Image.fromarray(
         cv2.cvtColor(bf_img, cv2.COLOR_BGR2RGB)
     )

S2FApp/utils/substrate_settings.py

@@ -5,6 +5,8 @@ Loads from config/substrate_settings.json - users can edit this file to add/modi
 import os
 import json
 
+from config.constants import DEFAULT_SUBSTRATE
+
 
 def _default_config_path():
     """Default path to substrate settings config (S2F/config/substrate_settings.json)."""
@@ -50,7 +52,7 @@ def resolve_substrate(name, config=None, config_path=None):
 
     s = (name or '').strip()
     if not s:
-        return config.get('default_substrate', 'Fibroblasts_Fibronectin_6KPa')
+        return config.get('default_substrate', DEFAULT_SUBSTRATE)
 
     substrates = config.get('substrates', {})
     s_lower = s.lower()
@@ -61,7 +63,7 @@ def resolve_substrate(name, config=None, config_path=None):
         if s_lower.startswith(key.lower()) or key.lower().startswith(s_lower):
             return key
 
-    return config.get('default_substrate', 'Fibroblasts_Fibronectin_6KPa')
+    return config.get('default_substrate', DEFAULT_SUBSTRATE)
 
 
 def get_settings_of_category(substrate_name, config=None, config_path=None):
@@ -81,12 +83,15 @@ def get_settings_of_category(substrate_name, config=None, config_path=None):
 
     substrate_key = resolve_substrate(substrate_name, config=config)
     substrates = config.get('substrates', {})
-    default = config.get('default_substrate', 'Fibroblasts_Fibronectin_6KPa')
+    default = config.get('default_substrate', DEFAULT_SUBSTRATE)
 
     if substrate_key in substrates:
         return substrates[substrate_key].copy()
 
-    default_settings = substrates.get(default, {'name': 'Fibroblasts on Fibronectin (6 kPa)', 'pixelsize': 3.0769, 'young': 6000})
+    default_settings = substrates.get(
+        default,
+        {'name': 'Fibroblasts on Fibronectin (6 kPa)', 'pixelsize': 3.0769, 'young': 6000},
+    )
     return default_settings.copy()