Add output portrait cache and streamlined tool sync

cached_data/output_portraits/ankle_torque_s_r_raw.pkl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7051294c00afffe8d35bb76e820cca5eedba1f2025e8876510cf0636339eea0e
+size 255530992

cached_data/output_portraits/hip_torque_s_r_raw.pkl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa0966e7dce85e2d2554911d0e82c03108019500eeec955cd1e34833d809c794
+size 258544069

cached_data/output_portraits/knee_torque_s_r_raw.pkl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1cae696ab3f55b030038d21240aee12477b606c0ff73481ec6566912b82f5bae
+size 270291469

pages/02_Tool.py

@@ -2,6 +2,8 @@ import os
 import sys
 import io
 import logging
+import pickle
+import gzip
 from datetime import datetime
 from pathlib import Path
 
@@ -26,9 +28,15 @@ if str(ROOT_DIR) not in sys.path:
     sys.path.insert(0, str(ROOT_DIR))
 
 try:
-    from multivariate_gaussian_overlap import calculate_portrait
+    from multivariate_gaussian_overlap import (
+        calculate_portrait,
+        combine_similarity_difference_to_conflict,
+    )
 except ImportError:
-    from multivariate_gaussian_overlap import calculate_portrait
+    from multivariate_gaussian_overlap import (
+        calculate_portrait,
+        combine_similarity_difference_to_conflict,
+    )
 
 try:
     from plot_similarity import plot_similarity_measure
@@ -79,6 +87,142 @@ logger.addHandler(console_handler)
 # Configure the page
 st.set_page_config(page_title="Task Similarity Analysis Tool", layout="wide")
 
+# Cache helpers for high-level output portraits
+OUTPUT_CACHE_DIR = ROOT_DIR / "cached_data" / "output_portraits"
+
+
+def _ensure_output_cache_dir() -> Path:
+    OUTPUT_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    return OUTPUT_CACHE_DIR
+
+
+def _get_output_cache_path(output_sensor: str, biomechanical_filtering: bool) -> Path:
+    sanitized = output_sensor.replace(os.sep, "_")
+    suffix = "_bio" if biomechanical_filtering else "_raw"
+    return _ensure_output_cache_dir() / f"{sanitized}{suffix}.pkl.gz"
+
+
+def load_high_level_output_portrait(output_sensor: str, biomechanical_filtering: bool):
+    if biomechanical_filtering:
+        return None
+
+    cache_path = _get_output_cache_path(output_sensor, biomechanical_filtering)
+    if not cache_path.exists():
+        return None
+
+    try:
+        with gzip.open(cache_path, "rb") as handle:
+            payload = pickle.load(handle)
+    except (OSError, pickle.PickleError, EOFError) as exc:
+        logger.warning(
+            "Failed to read cached portrait %s (%s); regenerating.",
+            cache_path.name,
+            exc,
+        )
+        cache_path.unlink(missing_ok=True)
+        return None
+
+    if (
+        payload.get("output_sensor") != output_sensor
+        or payload.get("biomechanical_filtering") != biomechanical_filtering
+    ):
+        return None
+
+    return payload.get("portrait"), payload.get("results_dict")
+
+
+def save_high_level_output_portrait(
+    output_sensor: str,
+    biomechanical_filtering: bool,
+    portrait: np.ndarray,
+    results_dict: dict,
+):
+    if biomechanical_filtering:
+        return
+
+    cache_path = _get_output_cache_path(output_sensor, biomechanical_filtering)
+    tmp_path = cache_path.with_name(cache_path.name + ".tmp")
+    payload = {
+        "output_sensor": output_sensor,
+        "biomechanical_filtering": biomechanical_filtering,
+        "portrait": portrait,
+        "results_dict": results_dict,
+        "created_at": datetime.utcnow().isoformat(),
+    }
+
+    with gzip.open(tmp_path, "wb") as handle:
+        pickle.dump(payload, handle)
+
+    tmp_path.replace(cache_path)
+
+
+def _task_matches_spec(spec: tuple, candidate: tuple) -> bool:
+    if spec is None or spec == (None, None, None):
+        return True
+
+    if candidate is None:
+        return False
+
+    name, incline, speed = spec
+    cand_name, cand_incline, cand_speed = candidate
+
+    if name and cand_name != name:
+        return False
+    if incline is not None and cand_incline != incline:
+        return False
+    if speed is not None and cand_speed != speed:
+        return False
+
+    return True
+
+
+def filter_output_results_by_tasks(
+    results_dict: dict,
+    task1_spec: tuple,
+    task2_spec: tuple,
+):
+    if not results_dict:
+        return None
+
+    task_pairs = results_dict.get("task_pairs", [])
+    portraits = results_dict.get("portraits", [])
+
+    if not task_pairs or not portraits:
+        return None
+
+    filtered_pairs = []
+    filtered_portraits = []
+
+    for pair, portrait in zip(task_pairs, portraits):
+        t1_candidate, t2_candidate = pair
+        if _task_matches_spec(task1_spec, t1_candidate) and _task_matches_spec(task2_spec, t2_candidate):
+            filtered_pairs.append(pair)
+            filtered_portraits.append(portrait)
+
+    if not filtered_portraits:
+        return None
+
+    if len(filtered_portraits) == 1:
+        aggregated_portrait = filtered_portraits[0]
+    else:
+        aggregated_portrait = np.nanmax(np.stack(filtered_portraits), axis=0)
+
+    filtered_dict = {
+        "task_pairs": filtered_pairs,
+        "portraits": filtered_portraits,
+    }
+
+    for optional_key in (
+        "task_histogram",
+        "n_matched_pairs",
+        "unmatched_input_pairs",
+        "unmatched_output_pairs",
+    ):
+        if optional_key in results_dict:
+            filtered_dict[optional_key] = results_dict[optional_key]
+
+    return aggregated_portrait, filtered_dict
+
 # Add authentication (temporarily disabled)
 st.session_state.setdefault("authenticated", True)
 # if not st.session_state.get("authenticated", False):
@@ -218,7 +362,7 @@ with st.sidebar:
     phase_window_percent = st.slider(
         "Window Size (%)",
         0,
-        20,
+        99,
         0,
         key="phase_slider",
         help="Set how much gait history to include. 0% keeps the portraits focused on the current phase only.",
@@ -474,45 +618,86 @@ if st.session_state.authenticated:
             if input_result is None:
                 st.stop()
 
-            output_result = calculate_overlap_measures(
-                task1=task1_name_backend[0],
-                task2=task2_name_backend[0],
-                sensors=None,
-                abstraction_level=analysis_detail,
-                task1_incline=task1_name_backend[1],
-                task1_speed=task1_name_backend[2],
-                task2_incline=task2_name_backend[1],
-                task2_speed=task2_name_backend[2],
-                time_windows=[1],
-                output_sensors=[first_output_sensor],
-                biomechanical_filtering=use_biomechanical_filtering,
-                return_details=True,
+            cached_output = load_high_level_output_portrait(
+                first_output_sensor,
+                use_biomechanical_filtering,
             )
 
-            if output_result is None:
-                st.stop()
+            use_cache = not use_biomechanical_filtering
 
-            conflict_result = calculate_overlap_measures(
-                task1=task1_name_backend[0],
-                task2=task2_name_backend[0],
-                sensors=selected_sensors,
-                abstraction_level=analysis_detail,
-                task1_incline=task1_name_backend[1],
-                task1_speed=task1_name_backend[2],
-                task2_incline=task2_name_backend[1],
-                task2_speed=task2_name_backend[2],
-                time_windows=phase_windows,
-                output_sensors=[first_output_sensor],
-                biomechanical_filtering=use_biomechanical_filtering,
-                return_details=True,
+            if cached_output is None:
+                if use_cache:
+                    logger.info(
+                        "Caching high-level output portrait for %s (biomech=%s)",
+                        first_output_sensor,
+                        use_biomechanical_filtering,
+                    )
+                else:
+                    logger.info(
+                        "Biomechanical filtering enabled; skipping cache for %s",
+                        first_output_sensor,
+                    )
+
+                high_output_result = calculate_overlap_measures(
+                    task1=None,
+                    task2=None,
+                    sensors=None,
+                    abstraction_level="High Level",
+                    task1_incline=None,
+                    task1_speed=None,
+                    task2_incline=None,
+                    task2_speed=None,
+                    time_windows=[1],
+                    output_sensors=[first_output_sensor],
+                    biomechanical_filtering=use_biomechanical_filtering,
+                    return_details=True,
+                )
+
+                if high_output_result is None:
+                    st.stop()
+
+                high_output_portrait, high_output_details = high_output_result
+                if use_cache:
+                    save_high_level_output_portrait(
+                        first_output_sensor,
+                        use_biomechanical_filtering,
+                        high_output_portrait,
+                        high_output_details,
+                    )
+                    output_cache_status = "Recomputed output portrait (cache refreshed)."
+                else:
+                    output_cache_status = "Biomechanical filtering active; caching disabled."
+            else:
+                logger.info(
+                    "Loaded high-level output portrait from cache for %s (biomech=%s)",
+                    first_output_sensor,
+                    use_biomechanical_filtering,
+                )
+                high_output_portrait, high_output_details = cached_output
+                output_cache_status = "Loaded output portrait from cache."
+
+            filtered_output = filter_output_results_by_tasks(
+                high_output_details,
+                task1_name_backend,
+                task2_name_backend,
             )
 
-            if conflict_result is None:
-                st.stop()
+            if filtered_output is None:
+                output_portrait = high_output_portrait
+                output_details = high_output_details
+            else:
+                output_portrait, output_details = filtered_output
 
             input_portrait, input_details = input_result
-            output_portrait, output_details = output_result
-            conflict_portrait, conflict_details = conflict_result
+
+            try:
+                conflict_portrait, conflict_details = combine_similarity_difference_to_conflict(
+                    input_details,
+                    output_details,
+                )
+            except ValueError as exc:
+                st.error(f"Failed to combine input and output portraits: {exc}")
+                st.stop()
 
             st.session_state.analysis_results = {
                 'input_portrait': input_portrait,
@@ -528,6 +713,7 @@ if st.session_state.authenticated:
                 'analysis_detail': analysis_detail,
                 'task1_backend': task1_name_backend,
                 'task2_backend': task2_name_backend,
+                'output_cache_status': output_cache_status,
             }
             st.success("Updated portraits with the latest configuration.")
 
@@ -536,6 +722,10 @@ if st.session_state.authenticated:
     if analysis_results:
         st.subheader("Similarity Analysis")
 
+        cache_msg = analysis_results.get('output_cache_status')
+        if cache_msg:
+            st.caption(cache_msg)
+
         display_phase_x = st.session_state.get('tool_phase_x_display', int(round(DEFAULT_PHASE_X / 1.5)))
         display_phase_y = st.session_state.get('tool_phase_y_display', int(round(DEFAULT_PHASE_Y / 1.5)))