Update app.py

app.py

@@ -9,80 +9,42 @@ from PIL import Image, ImageDraw
 import io
 from huggingface_hub import hf_hub_download
 import base64
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import csv
 import joblib
 import os
 
-HF_REPO_ID    = "myang4218/cellposemodel"
-HF_REPO_ID2   = "LiangLabUMB/viability_model"
-HF_REPO_CPSAM = "mouseland/cellpose-sam"
+HF_REPO_ID = "myang4218/cellposemodel"
+HF_REPO_ID2 = "LiangLabUMB/viability_model"
 MODEL_OPTIONS = {
     "Hemocytometer Model": "hemocytometermodel.npy",
-    "General Model":       "generalmodel.npy",
-    "Cellpose SAMv2":      "cpsam_v2",
+    "General Model": "generalmodel.npy"
 }
-MODEL_REPOS = {
-    "hemocytometermodel.npy": HF_REPO_ID,
-    "generalmodel.npy":       HF_REPO_ID,
-    "cpsam_v2":               HF_REPO_CPSAM,
-}
-
-
-# Viability classifier is loaded LAZILY (only when viability is first requested).
-# Loading XGBoost / the pickled model at module level initialises a CUDA context
-# in the main process, which conflicts with ZeroGPU's per-call GPU allocation and
-# leaves segmentation requests stuck in the GPU queue. Keeping the main process
-# CUDA-clean until viability is explicitly called avoids this.
-VIABILITY_CLF     = None
-VIABILITY_SCALER  = None
-_VIABILITY_LOADED = False
-_VIABILITY_ERROR  = None
-
-
-def ensure_viability_loaded():
-    """
-    Load the XGBoost classifier + scaler on first use, pinned to CPU.
 
-    XGBoost initialises a CUDA context if it thinks a GPU is available. Once
-    that context exists in the main process, every subsequent ZeroGPU fork for
-    run_segmentation inherits a dirty CUDA state and hangs in the GPU queue.
-    We force the loaded booster onto CPU so it never touches CUDA — viability
-    inference on ~20 features per cell is trivially fast on CPU anyway.
-    """
-    global VIABILITY_CLF, VIABILITY_SCALER, _VIABILITY_LOADED, _VIABILITY_ERROR
-    if _VIABILITY_LOADED:
-        return
-    try:
-        import xgboost
-        _clf_path    = hf_hub_download(repo_id=HF_REPO_ID2, filename="viability_xgb_clf.pkl")
-        _scaler_path = hf_hub_download(repo_id=HF_REPO_ID2, filename="viability_xgb_scaler.pkl")
-        VIABILITY_CLF    = joblib.load(_clf_path)
-        VIABILITY_SCALER = joblib.load(_scaler_path)
-
-        # Force CPU inference so XGBoost never initialises a CUDA context.
-        try:
-            VIABILITY_CLF.set_params(device="cpu", predictor="cpu_predictor", tree_method="hist")
-        except Exception:
-            pass
-        try:
-            booster = VIABILITY_CLF.get_booster()
-            booster.set_param({"device": "cpu", "predictor": "cpu_predictor"})
-        except Exception:
-            pass
-
-        _VIABILITY_LOADED = True
-        print("✓ Viability classifier loaded (lazy, CPU-pinned).")
-    except Exception as e:
-        _VIABILITY_ERROR = str(e)
-        print(f"Viability classifier failed to load: {e}")
-
-# mobile safe resize limits
+loaded_models = {}
+
+VIABILITY_CLF    = None
+VIABILITY_SCALER = None
+ 
+try:
+    _clf_path    = hf_hub_download(repo_id=HF_REPO_ID2, filename="viability_clf.pkl")
+    _scaler_path = hf_hub_download(repo_id=HF_REPO_ID2, filename="viability_scaler.pkl")
+    VIABILITY_CLF    = joblib.load(_clf_path)
+    VIABILITY_SCALER = joblib.load(_scaler_path)
+    print("✓ Viability classifier loaded.")
+except Exception as e:
+    print(f"Viability classifier not found or failed to load: {e}")
+
+# ---- mobile-safe size limits (aggressive for Safari) ----
 MAX_SIDE = 1024          
 MAX_PIXELS = 1024 * 1024
 
 
 def safe_resize(image_np):
-    
+    """
+    Downscale image to fit within MAX_SIDE and MAX_PIXELS while
+    preserving aspect ratio. Works for RGB / RGBA / grayscale.
+    """
     h, w = image_np.shape[:2]
     total = h * w
 
@@ -190,7 +152,11 @@ FEATURE_COLS_INFERENCE = [
 
 
 def classify_cells_by_model(image_np, masks):
-    
+    """
+    Run the trained LogisticRegression classifier to predict live/dead per cell.
+    Returns (dead_count, alive_count, overlay_np, {cell_id: label}).
+    Requires VIABILITY_CLF and VIABILITY_SCALER to be loaded.
+    """
     import numpy as np
     cell_ids = np.unique(masks)
     cell_ids = cell_ids[cell_ids > 0]
@@ -222,7 +188,11 @@ def classify_cells_by_model(image_np, masks):
 
 
 def draw_viability_overlay(image_np, masks, label_map):
-   
+    """
+    Draw coloured contours + cell-number labels onto image_np.
+    label_map: {cell_id: 0=live, 1=dead}
+    Returns a uint8 numpy array.
+    """
     overlay  = image_np.copy()
     cell_ids = np.unique(masks)
     cell_ids = cell_ids[cell_ids > 0]
@@ -250,10 +220,114 @@ def draw_viability_overlay(image_np, masks, label_map):
                           (0, 0, 0), -1)
             cv2.putText(overlay, label_str,
                         (cx - tw//2, cy + th//2),
-                        font, font_scale, color, thickness, cv2.LINE_AA) 
+                        font, font_scale, color, thickness, cv2.LINE_AA)
     return overlay
 
 
+def classify_cells_by_blueness(image_np, masks, threshold_bias):
+    """
+    Classify cells as dead (blue) or alive using an adaptive Otsu threshold
+    on per-cell blueness scores, with a user bias to fine-tune.
+
+    Args:
+        image_np:        RGB image array
+        masks:           Cellpose segmentation masks
+        threshold_bias:  Slider value -50..+50; shifts Otsu threshold up/down.
+                         Negative = more cells classified dead (looser).
+                         Positive = fewer cells classified dead (stricter).
+                         0 = pure Otsu (fully automatic).
+
+    Returns:
+        dead_count, alive_count, colored_overlay, otsu_threshold, final_threshold
+    """
+
+    if len(image_np.shape) == 2:
+        image_np = cv2.cvtColor(image_np, cv2.COLOR_GRAY2RGB)
+    elif len(image_np.shape) == 3 and image_np.shape[2] == 4:
+        image_np = cv2.cvtColor(image_np, cv2.COLOR_RGBA2RGB)
+
+    hsv = cv2.cvtColor(image_np, cv2.COLOR_RGB2HSV)
+
+    hue        = hsv[:, :, 0].astype(np.float32)
+    saturation = hsv[:, :, 1].astype(np.float32)
+
+    # Raw blueness: hue proximity to 115° × saturation
+    hue_distance = np.minimum(np.abs(hue - 115), 180 - np.abs(hue - 115))
+    hue_score    = np.maximum(0, 1 - hue_distance / 65)
+    blueness     = hue_score * (saturation / 255.0)
+
+    # --- Compute per-cell mean blueness scores ---
+    cell_ids = np.unique(masks)
+    cell_ids = cell_ids[cell_ids > 0]
+
+    if len(cell_ids) == 0:
+        blank = image_np.copy()
+        return 0, 0, blank, 0.0, 0.0
+
+    cell_scores = np.array([np.mean(blueness[masks == cid]) for cid in cell_ids])
+
+    # --- Otsu on the distribution of per-cell scores ---
+    # cv2.threshold expects uint8; scale 0-1 → 0-255
+    scores_u8 = (np.clip(cell_scores, 0, 1) * 255).astype(np.uint8)
+
+    if scores_u8.max() == scores_u8.min():
+        # All cells identical → Otsu is undefined; use midpoint
+        otsu_threshold = float(scores_u8[0]) / 255.0
+    else:
+        # Reshape to a single-column image so cv2.threshold works
+        thresh_val, _ = cv2.threshold(
+            scores_u8.reshape(-1, 1), 0, 255,
+            cv2.THRESH_BINARY + cv2.THRESH_OTSU
+        )
+        otsu_threshold = thresh_val / 255.0
+
+    # --- Apply user bias: slider -50..+50 maps to ±0.20 shift ---
+    bias = (threshold_bias / 50.0) * 0.20
+    final_threshold = float(np.clip(otsu_threshold + bias, 0.0, 1.0))
+
+    # --- Classify ---
+    dead_cells  = [cid for cid, s in zip(cell_ids, cell_scores) if s > final_threshold]
+    alive_cells = [cid for cid, s in zip(cell_ids, cell_scores) if s <= final_threshold]
+
+    # --- Outline-only overlay on raw image with enumerated labels ---
+    final_overlay = image_np.copy()
+
+    # Compute a consistent enumeration order (cell_ids is already sorted ascending)
+    cell_enum = {cid: idx + 1 for idx, cid in enumerate(cell_ids)}
+
+    dead_set  = set(dead_cells)
+    alive_set = set(alive_cells)
+
+    for cid in cell_ids:
+        cell_mask = (masks == cid).astype(np.uint8)
+        contours, _ = cv2.findContours(cell_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        color = (220, 50, 50) if cid in dead_set else (50, 220, 80)
+        cv2.drawContours(final_overlay, contours, -1, color, thickness=2)
+
+        # Draw enumeration label at centroid
+        ys, xs = np.where(cell_mask)
+        if len(ys) > 0:
+            cx, cy = int(xs.mean()), int(ys.mean())
+            label_str = str(cell_enum[cid])
+            font       = cv2.FONT_HERSHEY_SIMPLEX
+            font_scale = 0.35
+            thickness  = 1
+            (tw, th), _ = cv2.getTextSize(label_str, font, font_scale, thickness)
+            # Dark background rectangle for readability
+            cv2.rectangle(
+                final_overlay,
+                (cx - tw // 2 - 1, cy - th // 2 - 1),
+                (cx + tw // 2 + 1, cy + th // 2 + 1),
+                (0, 0, 0),
+                -1
+            )
+            cv2.putText(
+                final_overlay, label_str,
+                (cx - tw // 2, cy + th // 2),
+                font, font_scale, color, thickness, cv2.LINE_AA
+            )
+
+    return len(dead_cells), len(alive_cells), final_overlay, otsu_threshold, final_threshold
 
 
 def measure_confluency(masks, image_np):
@@ -377,10 +451,12 @@ def warp_polygon_to_square(image_np, points):
 
 
 def toggle_stereological_mode(use_stereology):
+    """Show/hide stereological controls based on checkbox"""
     return gr.update(visible=use_stereology)
 
 
 def update_exclusion_preview(image, left_width, top_width):
+    """Update the preview image with exclusion zone overlay"""
     if image is None:
         return None
     
@@ -389,8 +465,9 @@ def update_exclusion_preview(image, left_width, top_width):
     return Image.fromarray(overlay)
 
 
+# ---------------------------------------------------------------------------
 # Patch segmentation
-
+# ---------------------------------------------------------------------------
 PATCH_SIZE   = 512   # target patch side length
 PATCH_OVERLAP = 64   # overlap border on each edge (pixels)
 MIN_PATCH_DIM = 256  # don't bother patching if image fits comfortably
@@ -478,42 +555,62 @@ def _merge_patch_masks(patch_results, full_h, full_w, overlap=PATCH_OVERLAP):
     return renumbered
 
 
+def _segment_patch(args):
+    """Worker: run cellpose on a single patch. Called from a thread pool."""
+    patch_np, row_start, col_start, model_filename, hf_repo = args
+    # Each thread uses the shared loaded_models cache (GIL-safe for reads;
+    # model.eval() releases the GIL during GPU work so threads overlap.)
+    model_path = hf_hub_download(repo_id=hf_repo, filename=model_filename)
+    if model_filename in loaded_models:
+        model = loaded_models[model_filename]
+    else:
+        model = models.CellposeModel(gpu=True, pretrained_model=model_path)
+        loaded_models[model_filename] = model
+
+    mask, _, _ = model.eval(patch_np, diameter=None, channels=[0, 0])
+    return mask, row_start, col_start
+
+
 def run_segmentation_patched(image_np, model_filename):
     """
-    Split image into overlapping patches, run Cellpose sequentially on each,
+    Split image into overlapping patches, run Cellpose on each in parallel,
     then stitch back into a single full-resolution mask.
-
-    NOTE: ThreadPoolExecutor was removed because ZeroGPU allocates the GPU
-    only to the main thread. Worker threads spawned by ThreadPoolExecutor run
-    outside the GPU context, causing a 3-minute timeout waiting for a GPU
-    grant that never arrives for the worker threads.
-    Sequential patching within the @spaces.GPU context is correct and fast.
+    Falls back to whole-image segmentation if the image is small enough
+    that patching adds overhead without benefit.
     """
     h, w = image_np.shape[:2]
-    repo       = MODEL_REPOS.get(model_filename, HF_REPO_ID)
-    # hf_hub_download caches the weights file on disk, so this only hits the
-    # network once — subsequent calls read from the local cache.
-    model_path = hf_hub_download(repo_id=repo, filename=model_filename)
-
-    # IMPORTANT: build the CellposeModel fresh on every call. ZeroGPU allocates
-    # a DIFFERENT physical GPU for each @spaces.GPU invocation, so a model cached
-    # from a previous call holds a CUDA context bound to a now-deallocated GPU.
-    # Reusing it makes the next request hang in the GPU queue. Constructing the
-    # model is cheap because the weights are already on local disk.
-    model = models.CellposeModel(gpu=True, pretrained_model=model_path)
+    model_path = hf_hub_download(repo_id=HF_REPO_ID, filename=model_filename)
+    if model_filename in loaded_models:
+        model = loaded_models[model_filename]
+    else:
+        model = models.CellposeModel(gpu=True, pretrained_model=model_path)
+        loaded_models[model_filename] = model
 
     # Small images: no benefit from patching
     if max(h, w) <= MIN_PATCH_DIM * 2:
-        mask, _, _ = model.eval(image_np, diameter=None)
-        return mask, 1
+        mask, _, _ = model.eval(image_np, diameter=None, channels=[0, 0])
+        return mask, 1   # 1 patch
 
     patches = _split_patches(image_np)
     n_patches = len(patches)
 
-    patch_results = []
-    for patch, row_start, col_start in patches:
-        mask_patch, _, _ = model.eval(patch, diameter=None)
-        patch_results.append((mask_patch, row_start, col_start))
+    # Build argument list for the thread pool
+    args_list = [
+        (patch, r, c, model_filename, HF_REPO_ID)
+        for patch, r, c in patches
+    ]
+
+    patch_results = []  # (mask, row_start, col_start) in submission order
+
+    # ThreadPoolExecutor: GPU kernels release the GIL so threads overlap on GPU
+    with ThreadPoolExecutor(max_workers=min(n_patches, 4)) as pool:
+        futures = {pool.submit(_segment_patch, a): a for a in args_list}
+        for future in as_completed(futures):
+            mask_patch, row_start, col_start = future.result()
+            patch_results.append((mask_patch, row_start, col_start))
+
+    # Re-sort by (row, col) so stitching is deterministic
+    patch_results.sort(key=lambda x: (x[1], x[2]))
 
     full_mask = _merge_patch_masks(patch_results, h, w)
     return full_mask, n_patches
@@ -521,7 +618,6 @@ def run_segmentation_patched(image_np, model_filename):
 
 @spaces.GPU
 def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
-                     use_min_filter, use_max_filter,
                      use_stereology, left_exclusion, top_exclusion,
                      crop_points=None):
     image_np = np.array(image)
@@ -565,18 +661,21 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
         print("p90:", np.percentile(sizes, 90) if len(sizes) > 0 else 0)
         print("max:", sizes.max() if len(sizes) > 0 else 0)
         
-        # Compute recommendation from RAW masks (always shown, never auto-applied)
+        # Compute recommendation from RAW masks 
         recommend_min = rec_min_size(masks_raw)
 
-        # Apply filters only if their checkboxes are enabled
+        # If user sets slider to 0, use the recommendation
+        min_used = recommend_min if (min_cell_size == 0) else int(min_cell_size)
+
+        # Apply filters
         masks = masks_raw.copy()
         removed_small = 0
         removed_large = 0
 
-        if use_min_filter and int(min_cell_size) > 0:
-            masks, removed_small = filter_mask_by_size(masks, int(min_cell_size))
+        if min_used > 0:
+            masks, removed_small = filter_mask_by_size(masks, min_used)
 
-        if use_max_filter and max_cell_size > 0:
+        if max_cell_size > 0:
             masks, removed_large = filter_mask_by_maxsize(masks, int(max_cell_size))
 
         # Apply stereological exclusion if enabled
@@ -588,7 +687,7 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
         
         filter_msg = ""
         if removed_small:
-            filter_msg += f"Removed {removed_small} small objects (< {int(min_cell_size)} pixels).\n"
+            filter_msg += f"Removed {removed_small} small objects (< {min_used} pixels).\n"
         if removed_large:
             filter_msg += f"Removed {removed_large} large objects (> {int(max_cell_size)} pixels).\n"
         if use_stereology and excluded_count > 0:
@@ -630,7 +729,7 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
             pack_array(masks),
             pack_array(processed_image_np),
             confluency,
-            f"Recommended minimum: **{recommend_min} px** (25th percentile of detected cell sizes)",
+            gr.update(value=recommend_min), 
             pack_array(raw_image_np),
         )
 
@@ -645,20 +744,17 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
             None,
             None,
             0.0,
-            "",
+            gr.update(),
             None,
         )
 
 
 def run_viability(stored_masks, stored_image_np):
+    """Run model-based viability classification. Returns overlay + counts + label_map."""
     if stored_masks is None or stored_image_np is None:
         return None, 0, 0, 0.0, "Please run segmentation first.", {}
-
-    # Lazy-load the classifier the first time viability is requested
-    ensure_viability_loaded()
     if VIABILITY_CLF is None:
-        err = _VIABILITY_ERROR or "unknown error"
-        return None, 0, 0, 0.0, f"Viability model failed to load: {err}", {}
+        return None, 0, 0, 0.0, "No viability model found. Add viability_clf.pkl and viability_scaler.pkl to the app directory.", {}
 
     masks    = unpack_array(stored_masks)
     image_np = unpack_array(stored_image_np)
@@ -677,20 +773,14 @@ def run_viability(stored_masks, stored_image_np):
 
 
 def pack_array(arr):
-    """
-    Serialise a numpy array to a base64 string for gr.State storage.
-    Uses numpy .npy format (preserves int32 exactly, no 255 truncation)
-    encoded as base64 so it is a plain Python string — safe for ZeroGPU
-    state serialisation which cannot handle raw bytes objects.
-    """
+    pil = Image.fromarray(arr.astype(np.uint8))
     buf = io.BytesIO()
-    np.save(buf, arr)
-    return base64.b64encode(buf.getvalue()).decode("ascii")
+    pil.save(buf, format="PNG")
+    return buf.getvalue()
 
 
 def unpack_array(data):
-    buf = io.BytesIO(base64.b64decode(data))
-    return np.load(buf, allow_pickle=False)
+    return np.array(Image.open(io.BytesIO(data)))
 
 
 def save_tab_result(cell_count, confluency, viab_percent):
@@ -730,12 +820,29 @@ def compute_summary(r1, r2, r3, r4):
     return avg_count, avg_conf, avg_viab, "\n".join(lines)
 
 
-
+# ---------------------------------------------------------------------------
 # Training data export — feature extraction per cell
-
+# ---------------------------------------------------------------------------
 
 def extract_cell_features(image_np, masks):
-    
+    """
+    For every segmented cell, extract a fixed feature vector from the pixels
+    inside its mask.  Returns a list of dicts, one per cell.
+
+    Features:
+      RGB channels        — mean_r, mean_g, mean_b, std_r, std_g, std_b
+      HSV channels        — mean_h, mean_s, mean_v, std_s, std_v
+      Ratios              — blue_red_ratio, blue_green_ratio, rg_ratio
+      Morphology          — area_px, circularity
+      Centre/edge profile — inner_brightness, peak_brightness,
+                            bright_spot_fraction, ring_darkness,
+                            centre_periphery_ratio, brightness_std_normalised
+
+    Profile zones are tuned to hemocytometer live-cell morphology:
+    a small intense specular highlight at the centre surrounded by a dark
+    navy membrane ring. Dead cells are pale blue-grey blobs with no ring
+    and no bright spot.
+    """
     if len(image_np.shape) == 2:
         image_np = cv2.cvtColor(image_np, cv2.COLOR_GRAY2RGB)
     elif image_np.shape[2] == 4:
@@ -896,8 +1003,9 @@ def prepare_export(stored_masks, stored_image, threshold_bias):
     return path, msg
 
 
-
+# ---------------------------------------------------------------------------
 # Tab builder
+# ---------------------------------------------------------------------------
 
 def draw_polygon_overlay(image_pil, points):
     """
@@ -955,12 +1063,14 @@ def clear_crop_points(image_pil):
 
 
 
+# ---------------------------------------------------------------------------
 # Label correction grid
+# ---------------------------------------------------------------------------
 
-THUMB_SIZE   = 80   
-GRID_COLS    = 10  
-BORDER       = 4    
-LABEL_H      = 16   
+THUMB_SIZE   = 80   # each cell thumbnail is THUMB_SIZE × THUMB_SIZE px
+GRID_COLS    = 8    # thumbnails per row
+BORDER       = 4    # coloured border thickness in px
+LABEL_H      = 16   # height of the text label strip at the bottom of each thumb
 
 def _crop_cell_thumb(image_np, masks, cid):
     """
@@ -992,7 +1102,14 @@ def _crop_cell_thumb(image_np, masks, cid):
 
 
 def build_correction_grid(image_np, masks, labelled_features, raw_image_np=None):
-    
+    """
+    Render all cell thumbnails into a single PIL image grid.
+    Each thumbnail has a coloured border: green=live(0), red=dead(1).
+    A small number in the corner identifies the cell_id.
+
+    Returns the PIL grid image.
+    Cell order in the grid matches the order of labelled_features.
+    """
     if not labelled_features:
         placeholder = Image.fromarray(
             np.zeros((THUMB_SIZE, THUMB_SIZE, 3), dtype=np.uint8)
@@ -1139,29 +1256,14 @@ def build_tab(tab_index, masks_state, image_state, result_state):
                     value="Hemocytometer Model"
                 )
 
-                gr.Markdown("### Size Filters")
-
-                use_min_filter = gr.Checkbox(
-                    label="Enable minimum size filter",
-                    value=False,
-                    info="Remove objects smaller than the threshold below"
-                )
                 min_size_slider = gr.Slider(
                     minimum=0,
                     maximum=500,
                     value=0,
                     step=10,
-                    label="Minimum Cell Size (pixels)",
-                )
-                min_size_recommendation = gr.Markdown(
-                    value="*Run segmentation to see recommended minimum*",
+                    label="Minimum Cell Size (pixels). Leave at zero for automated recommendation",
                 )
 
-                use_max_filter = gr.Checkbox(
-                    label="Enable maximum size filter",
-                    value=False,
-                    info="Remove objects larger than the threshold below"
-                )
                 max_size_slider = gr.Slider(
                     minimum=0,
                     maximum=10000,
@@ -1303,10 +1405,9 @@ def build_tab(tab_index, masks_state, image_state, result_state):
         segment_btn.click(
             fn=run_segmentation,
             inputs=[img_input, model_dropdown, min_size_slider, max_size_slider,
-                    use_min_filter, use_max_filter,
                     use_stereo, left_excl, top_excl, crop_points_state],
             outputs=[cell_count_out, overlay_out, info_out, viability_section,
-                     masks_state, image_state, confluency_out, min_size_recommendation, raw_image_state]
+                     masks_state, image_state, confluency_out, min_size_slider, raw_image_state]
         )
 
         # ---- Run Viability button -------------------------------------------
@@ -1395,8 +1496,9 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
 
 
+# ---------------------------------------------------------------------------
 # Gradio interface
-
+# ---------------------------------------------------------------------------
 with gr.Blocks(
     title="CellposeCellCounter",
     theme=gr.themes.Soft(),