First commit

Dockerfile

@@ -1,21 +0,0 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,20 +0,0 @@
----
-title: Lower Limb Similarity Analysis
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

cached_data/precalculated_stats.pkl.gz

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

config.py

@@ -0,0 +1,42 @@
+# Configuration file for dashboard and preprocessing scripts
+
+AVAILABLE_SENSORS = [
+    'hip_angle_s_r', 'hip_angle_s_l', 'hip_vel_s_r', 'hip_vel_s_l',
+    'knee_angle_s_r', 'knee_angle_s_l', 'knee_vel_s_r', 'knee_vel_s_l',
+    'ankle_angle_s_r', 'ankle_angle_s_l', 'ankle_vel_s_r', 'ankle_vel_s_l',
+    'foot_angle_s_r', 'foot_angle_s_l', 'foot_vel_s_r', 'foot_vel_s_l'
+]
+
+AVAILABLE_TASKS = ['decline_walking', 'level_walking', 'incline_walking',
+                   'stairs', 'sit_to_stand']
+
+OUTPUTS_TOTAL = ['hip_torque_s_r', 'knee_torque_s_r', 'ankle_torque_s_r',
+                 'hip_power_s_r', 'knee_power_s_r', 'ankle_power_s_r']
+
+# Not strictly needed by preprocess_data_for_hosting.py but good to keep related constants together.
+ANALYSIS_ABSTRACTION_LEVELS = ['High', 'Medium/Low']
+
+# Task configurations for pre-calculation and analysis
+LOW_LEVEL_TASKS = [
+    ('stair_descent', None, None),
+    ('stair_ascent', None, None),
+    ('sit_to_stand', None, None),
+    ('level_walking', 0.0, 0.8),
+    ('level_walking', 0.0, 1.0),
+    ('level_walking', 0.0, 1.2),
+    # Gtech variants
+    ('level_walking', 0.0, 0.6),
+    ('level_walking', 0.0, 1.8),
+    ('incline_walking', 5.0, 0.8),
+    ('incline_walking', 5.0, 1.0),
+    ('incline_walking', 5.0, 1.2),
+    ('decline_walking', -5.0, 0.8),
+    ('decline_walking', -5.0, 1.0),
+    ('decline_walking', -5.0, 1.2),
+    ('incline_walking', 10.0, 0.8),
+    ('incline_walking', 10.0, 1.0),
+    ('incline_walking', 10.0, 1.2),
+    ('decline_walking', -10.0, 0.8),
+    ('decline_walking', -10.0, 1.0),
+    ('decline_walking', -10.0, 1.2),
+] 

dashboard.py

@@ -0,0 +1,679 @@
+import streamlit as st
+import logging
+from datetime import datetime
+import os
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from multivariate_gaussian_overlap import calculate_similarity_portrait_abstraction
+from plot_similarity import plot_similarity_measure
+from sensor_illustration import LegIllustration
+import io
+
+# Import constants from config.py
+from config import AVAILABLE_SENSORS, AVAILABLE_TASKS, OUTPUTS_TOTAL, ANALYSIS_ABSTRACTION_LEVELS
+
+# Set up logging
+if not os.path.exists('st_logs'):
+    os.makedirs('st_logs')
+
+# Create logger
+logger = logging.getLogger('dashboard_logger')
+logger.setLevel(logging.INFO)
+
+# Create handlers
+file_handler = logging.FileHandler('st_logs/dashboard_access.log')
+console_handler = logging.StreamHandler(sys.stdout)
+
+# Create formatter and add it to the handlers
+formatter = logging.Formatter('%(asctime)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+file_handler.setFormatter(formatter)
+console_handler.setFormatter(formatter)
+
+# Add the handlers to the logger
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
+
+# Configure the page with custom CSS
+st.set_page_config(page_title="Task Similarity Analysis", layout="wide")
+
+# Custom CSS for better visual appeal
+st.markdown("""
+    <style>
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    .stButton>button {
+        width: 100%;
+        margin-top: 1rem;
+        margin-bottom: 1rem;
+    }
+    .sidebar .sidebar-content {
+        padding-top: 1rem;
+    }
+    hr {
+        margin: 1rem 0;
+    }
+    h1 {
+        padding-bottom: 1rem;
+        border-bottom: 2px solid #f0f2f6;
+    }
+    h3 {
+        margin-top: 1.5rem;
+    }
+    /* Add tooltip styles */
+    .tooltip-container {
+        position: relative;
+        display: inline-block;
+        width: 100%;
+    }
+    
+    .tooltip-content {
+        visibility: hidden;
+        background-color: white;
+        color: black;
+        text-align: left;
+        padding: 10px;
+        border-radius: 5px;
+        border: 1px solid #ddd;
+        position: absolute;
+        z-index: 1;
+        top: 100%;
+        left: 0;
+        margin-top: 5px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        width: 200px;
+    }
+    
+    .tooltip-container:hover .tooltip-content {
+        visibility: visible;
+    }
+
+    .color-legend {
+        display: flex;
+        align-items: center;
+        margin: 5px 0;
+    }
+
+    .color-box {
+        width: 15px;
+        height: 15px;
+        margin-right: 10px;
+        border-radius: 3px;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# Add authentication
+if not st.session_state.get("authenticated", False):
+    password = st.text_input("Password:", type="password")
+    if password == "locolab!":  # Replace with secure password
+        st.session_state.authenticated = True
+        # Log successful login with timestamp and IP
+        ip = st.get_client_ip() if hasattr(st, 'get_client_ip') else 'Unknown IP'
+        logger.info(f"Successful login from {ip}")
+    elif password:  # Only log if a password attempt was made
+        # Log failed attempt
+        ip = st.get_client_ip() if hasattr(st, 'get_client_ip') else 'Unknown IP'
+        logger.warning(f"Failed login attempt from {ip} with password: {password}")
+        st.stop()
+    else:
+        st.stop()
+
+# Define available sensors and tasks
+# MOVED TO config.py: AVAILABLE_SENSORS, AVAILABLE_TASKS, OUTPUTS_TOTAL, ANALYSIS_ABSTRACTION_LEVELS
+
+ANALYSIS_MODES = ['Similarity Analysis'] # This one seems specific to dashboard
+
+# Sidebar controls with better organization
+with st.sidebar:
+    st.title("Configuration")
+    
+    # Add the generate button styling and button right after the title
+    st.markdown("""
+        <style>
+        div[data-testid="stButton"] button {
+            background-color: #28a745;
+            color: white;
+            border: none;
+        }
+        div[data-testid="stButton"] button:hover {
+            background-color: #218838;
+            color: white;
+            border: none;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+    
+    generate_button = st.button("Generate Visualization", key="generate_viz")
+    
+    st.markdown("---")  # Visual separator
+    
+    # Modified task selection expander with abstraction controls
+    with st.expander("🎯 Task Selection", expanded=True):
+        
+        # --- Analysis Detail moved to top ---
+        analysis_detail = st.selectbox(
+            "Analysis Detail",
+            ["High Level", "Medium Level", "Low Level"], 
+            index=0, # Default to High Level
+            help="High: Compare all tasks globally. Medium: Select specific tasks, compare across all their conditions. Low: Select specific tasks and conditions (incline/speed)."
+        )
+
+        # --- Task Selection --- 
+        # Disable task selection if High Level is chosen
+        tasks_disabled = (analysis_detail == "High Level")
+        task1 = st.selectbox("Task 1", AVAILABLE_TASKS, index=0, disabled=tasks_disabled)
+        task2 = st.selectbox("Task 2", AVAILABLE_TASKS, index=1, disabled=tasks_disabled)
+
+        # Convert to old terminology for backend compatibility - THIS IS MODIFIED LATER
+        # abstraction_level = "High" if analysis_detail == "Summary View" else "Medium" 
+
+        # Initialize parameters - These will be overwritten based on analysis_detail
+        task1_incline = None
+        task1_speed = None 
+        task2_incline = None
+        task2_speed = None
+
+        # Task parameter controls - only show if Low Level (previously Detailed View)
+        if analysis_detail == "Low Level":
+            st.markdown("**Task Specific Parameters**")
+            col1, col2 = st.columns(2)
+            with col1:
+                # Task 1 parameters
+                # Default to "All" which will become None later
+                task1_incline_select = "All"
+                if task1 != 'level_walking':
+                    task1_incline_select = st.selectbox(
+                        f"{task1} Incline", 
+                        options=["All", 5.0, 10.0], 
+                        index=0
+                    )
+                                    
+                task1_speed_select = st.selectbox(
+                    f"{task1} Speed", 
+                    options=["All", 0.8, 1.0, 1.2], 
+                    index=0
+                )
+            with col2:
+                # Task 2 parameters
+                task2_incline_select = "All"
+                if task2 != 'level_walking':
+                    task2_incline_select = st.selectbox(
+                        f"{task2} Incline", 
+                        options=["All", 5.0, 10.0], 
+                        index=0
+                    )
+                                    
+                task2_speed_select = st.selectbox(
+                    f"{task2} Speed", 
+                    options=["All", 0.8, 1.0, 1.2], 
+                    index=0
+                )
+            
+            # Convert "All" selections to None for Low Level analysis
+            task1_incline = task1_incline_select if task1_incline_select != "All" else None
+            task1_speed = task1_speed_select if task1_speed_select != "All" else None
+            task2_incline = task2_incline_select if task2_incline_select != "All" else None
+            task2_speed = task2_speed_select if task2_speed_select != "All" else None
+        
+        # No specific parameters needed for High or Medium level, they remain None
+
+    
+    st.markdown("---")  # Visual separator
+    
+    # Sensor selection in an expander (moved second)
+    with st.expander("📡 Sensor Configuration", expanded=True):
+        # Add sensor illustration at the top of the sensor configuration
+        if 'selected_sensors' not in st.session_state:
+            st.session_state.selected_sensors = ['hip_angle_s_r']
+        
+        # Create tooltip HTML
+        tooltip_html = f"""
+        <div class="tooltip-container">
+            <div style="width: 100%">
+                {{plot_placeholder}}
+            </div>
+            <div class="tooltip-content">
+                <div style="font-weight: bold; margin-bottom: 8px">Color Convention:</div>
+                <div class="color-legend">
+                    <div class="color-box" style="background-color: green"></div>
+                    <div>Angle Sensors</div>
+                </div>
+                <div class="color-legend">
+                    <div class="color-box" style="background-color: blue"></div>
+                    <div>Velocity Sensors</div>
+                </div>
+                <div class="color-legend">
+                    <div class="color-box" style="background-color: red"></div>
+                    <div>Angle + Velocity</div>
+                </div>
+                <div class="color-legend">
+                    <div class="color-box" style="background-color: orange"></div>
+                    <div>Torque Sensors</div>
+                </div>
+            </div>
+        </div>
+        """
+        
+        # Create and display sensor illustration
+        sensor_fig = LegIllustration().draw_illustration(
+            highlighted_elements=st.session_state.selected_sensors,
+            gait_cycle_sections=st.session_state.get('phase_windows', [])  # Default if not set
+        )
+        
+        # Convert plot to HTML
+        from io import BytesIO
+        buf = BytesIO()
+        sensor_fig.savefig(buf, format='png', transparent=True, bbox_inches='tight')
+        buf.seek(0)
+        import base64
+        plot_html = f'<img src="data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}" style="width: 100%">'
+        
+        # Insert plot into tooltip HTML and display
+        st.markdown(tooltip_html.replace('{plot_placeholder}', plot_html), unsafe_allow_html=True)
+        
+        # Existing sensor selection
+        selected_sensors = st.multiselect(
+            "Select Sensors",
+            AVAILABLE_SENSORS,
+            default=['hip_angle_s_r']
+        )
+        # Update session state
+        st.session_state.selected_sensors = selected_sensors
+        
+        # Phase window selection
+        st.markdown("### Phase Window")
+        use_specific_phases = st.toggle(
+            "Analyze Specific Gait Phases", 
+            value=False,
+            help="Enable to select specific portions of the gait cycle for analysis",
+            key="phase_toggle"  # Add key to track changes
+        )
+
+        if use_specific_phases:
+            st.markdown("""
+                Select gait cycle phases to analyze (0% = current time, -100% = past heel strike).
+                Multiple selections allow analysis of combined phases.
+            """)
+            # Create a list of all possible phase percentages (0 to 100%)
+            phase_options = [f"-{i/1.5:.1f}%" for i in range(151)]
+            
+            # Create multiselect dropdown for specific phase offsets
+            selected_phase_strings = st.multiselect(
+                "Select Phase Offsets",
+                phase_options,
+                default=[phase_options[0]],
+                key="phase_multiselect"  # Add key to track changes
+            )
+            
+            # Convert selected percentages to phase offsets
+            phase_windows = [max(1, -int(float(p.strip('%')) * 1.49)) for p in selected_phase_strings]
+            if st.session_state.get('phase_windows') != phase_windows:
+                st.session_state.phase_windows = phase_windows
+                st.rerun()  # Updated from experimental_rerun to rerun
+
+        else:
+            # Slider behavior - create list of all phases up to selected value
+            phase_window_percent = st.slider(
+                "Window Size (%)", 
+                0, 100, 1,
+                key="phase_slider"  # Add key to track changes
+            )
+            max_window = max(1, int(phase_window_percent * 1.49))
+            phase_windows = list(range(1, max_window + 1))
+            if st.session_state.get('phase_windows') != phase_windows:
+                st.session_state.phase_windows = phase_windows
+                st.rerun()  # Updated from experimental_rerun to rerun
+            
+            if phase_window_percent > 0:
+                st.caption(f"Current window: {phase_window_percent:.1f}% ({max_window} frames)")
+    
+    st.markdown("---")
+    
+    # Visualization options in an expander (moved third)
+    with st.expander("📊 Visualization Options", expanded=True):
+        show_output_diff = st.checkbox("Show Output Differences", value=False)
+        show_conflict = st.checkbox("Show Input-Output Conflict", value=False)
+            
+        # Add output selection if showing output differences or conflict
+        if show_output_diff or show_conflict:
+            selected_outputs = st.multiselect(
+                "Select Outputs",
+                OUTPUTS_TOTAL,
+                default=['ankle_torque_s_r'],
+                format_func=lambda x: x.replace('_s_r', '').replace('_', ' ').title()
+            )
+            if not selected_outputs:
+                st.warning("⚠️ Please select at least one output.")
+                st.stop()
+            # Update the OUTPUTS constant to use only selected outputs
+            OUTPUTS = selected_outputs
+
+    st.markdown("---")
+    
+    # Marginal distribution options in an expander (moved last)
+    # Only show if neither output differences nor conflict is selected
+    if not (show_output_diff or show_conflict):
+        with st.expander("📈 Marginal Distribution", expanded=True):
+            show_marginals = st.checkbox("Show Marginal Distributions", value=False)
+            if show_marginals:
+                threshold = st.slider("Similarity Threshold", 0.0, 1.0, 0.5, 0.1)
+    else:
+        show_marginals = False
+    
+    st.markdown("---")  # Add a separator
+
+# Main content
+st.title("Task Similarity Analysis Dashboard")
+
+if not selected_sensors:
+    st.warning("⚠️ Please select at least one sensor.")
+    st.stop()
+
+def calculate_overlap_measures(task1, task2, sensors, abstraction_level, 
+                              task1_incline=None, task1_speed=None,
+                              task2_incline=None, task2_speed=None,
+                              time_windows=None,
+                              use_output_data=False):
+    """
+    Calculate overlap measures with support for time windowing.
+    """
+    # Create a progress placeholder in Streamlit
+    progress_placeholder = st.empty()
+    progress_bar = progress_placeholder.progress(0)
+    status_placeholder = st.empty()
+    
+    try:
+        # Show calculation status
+        # status_placeholder.text("Pre-computing task statistics...")
+        
+        # Flip sign of incline if task is decline_walking
+        if task1 == 'decline_walking' and task1_incline is not None:
+            task1_incline = -task1_incline
+        if task2 == 'decline_walking' and task2_incline is not None:
+            task2_incline = -task2_incline
+
+        # Define task specifications
+        task1_spec = (task1, task1_incline, task1_speed)
+        task2_spec = (task2, task2_incline, task2_speed)
+
+        
+        # Get the phase windows from session state or use default
+        if time_windows is None:
+            time_windows = [1]
+        
+        similarity = calculate_similarity_portrait_abstraction(
+            sensors=list(sensors),
+            time_window=time_windows,
+            abstraction_level=abstraction_level.lower(),
+            task1_name=task1_spec,
+            task2_name=task2_spec,
+            output_difference=use_output_data,
+            progress_callback=lambda x: progress_bar.progress(x)
+        )
+        
+        # Clear the progress indicators
+        progress_placeholder.empty()
+        status_placeholder.empty()
+
+        if similarity is None:
+            st.error("Error calculating similarity. Please check your task and sensor configuration.")
+            return None
+        
+        return similarity
+        
+    except ValueError as e:
+        # Clear progress indicators and show error
+        progress_placeholder.empty()
+        status_placeholder.empty()
+        st.error(f"This is not a valid task configuration: {e}")
+        return None
+    except Exception as e:
+        # Clear progress indicators and show error
+        progress_placeholder.empty()
+        status_placeholder.empty()
+        st.error(f"Unexpected error: {e}")
+        return None
+
+def create_heatmap_matplotlib(data, title, plot_type='input'):
+    """Create a matplotlib heatmap using the library's plotting function"""
+    fig, ax = plt.subplots(figsize=(6, 6))
+    
+    # Reshape data to 2D if needed
+    if len(data.shape) == 1:
+        data = data.reshape(-1, 1)  # Convert to 2D column vector
+    
+    plot_similarity_measure(
+        ax=ax,
+        measure_data=data,
+        plot_type=plot_type,
+        task_x_name=task1.replace('_', ' ').title(),
+        task_y_name=task2.replace('_', ' ').title()
+    )
+    ax.set_title(title)
+    return fig
+
+def create_sensor_illustration(selected_sensors):
+    """Create sensor illustration with selected sensors"""
+    illustrator = LegIllustration()
+    fig = illustrator.draw_illustration(
+        highlighted_elements=selected_sensors,
+        gait_cycle_sections=st.session_state.get('phase_windows', [])  # Default if not set
+    )
+    # Make figure smaller while maintaining aspect ratio
+    # Let the main plotting layout control size
+    # fig.set_size_inches(3, 6) 
+    return fig
+
+def create_downloadable_image(fig):
+    """Create a single image from the main figure object."""
+    # Remove old logic trying to combine multiple figures
+    
+    # Save the provided figure directly to bytes
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png', bbox_inches='tight', dpi=150)
+    plt.close(fig) # Close the figure to free memory
+    buf.seek(0)
+    return buf.getvalue()
+
+# Main section after authentication
+if st.session_state.authenticated:
+    if generate_button:
+        with st.spinner("Doing some math..."):
+            # Determine backend parameters based on UI selections
+            # These variables (task1, task2, analysis_detail, task1_incline, etc.) 
+            # are already defined from the sidebar widgets and their values are 
+            # current when the button is pressed.
+            
+            if analysis_detail == "High Level":
+                # For High Level, task names and conditions are None, 
+                # task1 and task2 from UI are effectively ignored for backend call.
+                task1_name_backend = (None, None, None)
+                task2_name_backend = (None, None, None)
+            elif analysis_detail == "Medium Level":
+                # For Medium Level, specific tasks are chosen, but all their conditions.
+                # task1, task2 are the selected task strings from the UI.
+                # Incline and speed are None to signify "all conditions" for these tasks.
+                task1_name_backend = (task1, None, None) 
+                task2_name_backend = (task2, None, None)
+            else: # "Low Level"
+                # For Low Level, specific tasks and their specific conditions are used.
+                # task1, task2 are task strings.
+                # task1_incline, task1_speed, etc., are specific values (or None if "All" was selected for that condition in the UI).
+                task1_name_backend = (task1, task1_incline, task1_speed)
+                task2_name_backend = (task2, task2_incline, task2_speed)
+            
+            # This will be passed to calculate_overlap_measures, which then passes its .lower() version
+            # to calculate_similarity_portrait_abstraction.
+            abstraction_level_backend = analysis_detail 
+
+            progress_placeholder = st.empty()
+            progress_placeholder.write(f"Calculating input similarity for {task1_name_backend[0] or 'all tasks'} and {task2_name_backend[0] or 'all tasks'}...")
+            # Calculate input similarity using determined backend parameters
+            input_similarity = calculate_overlap_measures(
+                task1=task1_name_backend[0], 
+                task2=task2_name_backend[0], 
+                sensors=selected_sensors, 
+                abstraction_level=abstraction_level_backend,
+                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=st.session_state.get('phase_windows', [])
+            )
+            
+            output_difference_main = None
+            conflict_main = None
+            first_output_sensor = None
+
+            if input_similarity is not None:
+                print("Input similarity calculated, proceeding...")
+                
+                # Calculate output difference and conflict for the FIRST selected output
+                if (show_output_diff or show_conflict):
+                    if selected_outputs: # Check if any outputs were selected
+                        first_output_sensor = selected_outputs[0]
+                        progress_placeholder.empty()
+                        progress_placeholder.write(f"Calculating output difference for {first_output_sensor}...")
+                        
+                        # Calculate DIFFERENCE using determined backend parameters
+                        output_difference_main = calculate_overlap_measures(
+                            task1_name_backend[0], task2_name_backend[0],
+                            [first_output_sensor], abstraction_level_backend, # USE CORRECT VARIABLE
+                            task1_incline=task1_name_backend[1], task1_speed=task1_name_backend[2],
+                            task2_incline=task2_name_backend[1], task2_speed=task2_name_backend[2],
+                            use_output_data=True, 
+                            time_windows=[1] # Output difference usually uses time_window=1
+                        )
+                        
+                        if output_difference_main is not None and show_conflict:
+                            progress_placeholder.empty()
+                            progress_placeholder.write(f"Calculating conflict for {first_output_sensor}...")
+                            # Conflict is input similarity * output difference
+                            conflict_main = input_similarity * output_difference_main
+                    else:
+                        st.warning("⚠️ Please select at least one output sensor to show Output Differences or Conflict.")
+                        # Ensure plots dependent on these are skipped
+                        show_output_diff = False
+                        show_conflict = False 
+                
+                # Clear progress text
+                progress_placeholder.empty()
+
+                # --- Start of New Plotting Layout --- 
+                st.subheader("Similarity Analysis")
+                
+                fig, axs = plt.subplots(2, 3, figsize=(18, 10), constrained_layout=False) # Adjust figsize as needed
+
+                # --- Row 0: Output Info / Header --- 
+                
+                # Ax[0,0]: Output Leg Illustration
+                if (show_output_diff or show_conflict) and first_output_sensor:
+                    leg_illustrator_out = LegIllustration()
+                    leg_illustrator_out.draw_illustration(ax=axs[0,0], highlighted_elements=[first_output_sensor])
+                    axs[0,0].set_title(f"Output: {first_output_sensor.replace('_s_r','').replace('_',' ').title()}")
+                else:
+                    axs[0,0].axis('off')
+                    
+                # Ax[0,1]: Task Info Text
+                axs[0,1].axis('off') # Turn off axis lines and ticks
+                task_info_text = f"{abstraction_level_backend} Abstraction\n" # Use abstraction_level_backend
+                task1_display_incline = "All" if task1_name_backend[1] is None else task1_name_backend[1]
+                task1_display_speed = "All" if task1_name_backend[2] is None else task1_name_backend[2]
+                task2_display_incline = "All" if task2_name_backend[1] is None else task2_name_backend[1]
+                task2_display_speed = "All" if task2_name_backend[2] is None else task2_name_backend[2]
+                
+                task1_display_name = task1_name_backend[0] or "All Tasks"
+                task2_display_name = task2_name_backend[0] or "All Tasks"
+
+                task_info_text += f"Task 1 (Y): {task1_display_name} (Incline: {task1_display_incline}, Speed: {task1_display_speed})\n"
+                task_info_text += f"Task 2 (X): {task2_display_name} (Incline: {task2_display_incline}, Speed: {task2_display_speed})"
+                axs[0,1].text(0.5, 0.5, task_info_text, ha='center', va='center', fontsize=10, wrap=True)
+                
+                # Ax[0,2]: Output Difference Heatmap
+                if show_output_diff and output_difference_main is not None:
+                    plot_similarity_measure(
+                        ax=axs[0,2], 
+                        measure_data=output_difference_main, 
+                        plot_type='output', 
+                        cbar=True, 
+                        cbar_labels=True,
+                        fontsize=10,
+                        task_x_name=task2_name_backend[0], # Pass task names for potential use in plot_similarity_measure
+                        task_y_name=task1_name_backend[0]
+                    )
+                    axs[0,2].set_title("Output Difference")
+                else:
+                    axs[0,2].axis('off')
+
+                # --- Row 1: Input Info / Conflict --- 
+                
+                # Ax[1,0]: Input Leg Illustration
+                leg_illustrator_in = LegIllustration()
+                leg_illustrator_in.draw_illustration(
+                    ax=axs[1,0], 
+                    highlighted_elements=selected_sensors, 
+                    gait_cycle_sections=st.session_state.get('phase_windows', [])
+                )
+                axs[1,0].set_title(f"Input Sensors")
+
+                # Ax[1,1]: Input Similarity Heatmap
+                plot_similarity_measure(
+                    ax=axs[1,1], 
+                    measure_data=input_similarity, 
+                    plot_type='input', 
+                    cbar=True, 
+                    cbar_labels=True,
+                    fontsize=10,
+                    task_x_name=task2_name_backend[0], 
+                    task_y_name=task1_name_backend[0]
+                )
+                axs[1,1].set_title("Input Similarity")
+
+                # Ax[1,2]: Conflict Heatmap
+                if show_conflict and conflict_main is not None:
+                    plot_similarity_measure(
+                        ax=axs[1,2], 
+                        measure_data=conflict_main, 
+                        plot_type='conflict', 
+                        cbar=True, 
+                        cbar_labels=True,
+                        fontsize=10,
+                        task_x_name=task2_name_backend[0], 
+                        task_y_name=task1_name_backend[0]
+                    )
+                    axs[1,2].set_title("Input-Output Conflict")
+                else:
+                     axs[1,2].axis('off')
+                
+                # Adjust layout and display
+                plt.tight_layout(pad=1.5)
+                st.pyplot(fig)
+
+                # --- End of New Plotting Layout ---
+
+                # Download button using the new main figure
+                try:
+                    image_data = create_downloadable_image(fig)
+                    st.download_button(
+                        label="Download Plot Layout",
+                        data=image_data,
+                        file_name="similarity_layout.png",
+                        mime="image/png",
+                    )
+                except Exception as e:
+                    st.error(f"Failed to create downloadable image: {e}")
+
+            # Handle case where input similarity calculation failed
+            else:
+                st.error("Error calculating input similarity. Please check your task and sensor configuration.")
+
+        # Existing logic for marginals if needed (outside the main 2x3 grid)
+        if show_marginals:
+             st.markdown("--- Marginal Distributions ---")
+             # Placeholder: Add logic to plot marginal distributions if required.
+             # This was previously outside the main conditional blocks.
+             st.write("(Marginal distribution plotting not implemented in this layout yet)")

data_tools.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+def generate_task_info_name(walking_type, incline, walking_speed):
+    """
+    Generate a standardized 'task_info' name string based on the walking type, incline, and walking speed.
+
+    The returned string follows the format:
+        For level walking: "{walking_type}_{formatted_speed}"
+        For incline/decline: "{walking_type}_{incline}_deg_{formatted_speed}"
+    where:
+      - walking_type is expected to be one of:
+          'decline_walking', 'level_walking', or 'incline_walking'
+      - incline is a numerical value indicating ground incline in degrees.
+      - formatted_speed is a walking speed string, e.g., 's0x8' for 0.8 m/s, 's1' for 1.0 m/s, 's1x2' for 1.2 m/s.
+    
+    Args:
+        walking_type (str): The type of walking. Expected values: 'decline_walking', 'level_walking', or 'incline_walking'.
+        incline (float or int): Ground incline in degrees.
+        walking_speed (float): Walking speed in m/s.
+    
+    Returns:
+        str: The generated task_info name.
+        
+    Examples:
+        >>> generate_task_info_name('decline_walking', -5, 0.8)
+        'decline_walking_5_deg_s0x8'
+        >>> generate_task_info_name('level_walking', 0, 1.0)
+        'level_walking_s1'
+        >>> generate_task_info_name('incline_walking', 5, 1.2)
+        'incline_walking_5_deg_s1x2'
+    """
+
+    if 'stair' in walking_type:
+        return walking_type
+
+    if walking_type != 'level_walking' and (np.isnan(incline) or incline is None):
+        print(f"Incline is NaN for task {walking_type} {incline} {walking_speed}")
+        return None
+    if np.isnan(walking_speed) or walking_speed is None:
+        print(f"Walking speed is NaN for task {walking_type} {incline} {walking_speed}")
+        return None
+    
+    def format_walking_speed(speed):
+        # Map known speeds to specific string representations
+        mapping = {0.8: "s0x8", 1.0: "s1", 1.2: "s1x2"}
+        # Use the mapping if available, otherwise default to a generic string
+        return mapping.get(speed, f"s{speed}")
+
+    # Format walking speed
+    speed_str = format_walking_speed(walking_speed)
+    
+    # For level walking, return simpler format without incline info
+    if walking_type == 'level_walking':
+        return f"{walking_type}_{speed_str}"
+    
+    # Format incline: if the value is an integer, do not show decimals.
+    if incline == int(incline):
+        incline_str = str(abs(int(incline)))
+    else:
+        incline_str = str(abs(incline))
+    
+    # Build and return the standardized task_info string for incline/decline walking
+    task_info = f"{walking_type}_{incline_str}_deg_{speed_str}_m_s"
+    return task_info

multivariate_gaussian_overlap.py

@@ -0,0 +1,947 @@
+# %%
+"""" 
+This script is meant to analyze how similar sensor inputs are to each other for 
+different tasks and potentially different subjects
+
+
+
+Note: Task 1 represents the y axis in the heatmap. 
+      Task 2 represents the x axis in the heatmap.
+"""
+
+import numpy as np
+from tqdm import tqdm
+import itertools
+from functools import partial
+import pandas as pd
+from typing import Optional, Union, Callable
+import pickle
+from data_tools import generate_task_info_name
+import os
+# from data_loader import total_data # Removed as total_data is no longer used directly
+from functools import lru_cache
+from scipy.stats import norm
+# Import LOW_LEVEL_TASKS from config
+from config import LOW_LEVEL_TASKS
+# Add this at the top of your file, after the imports
+os.environ['PYDEVD_DISABLE_FILE_VALIDATION'] = '1'
+
+# ADD IMPORTS
+import gzip
+from pathlib import Path
+
+# Load significance thresholds if available
+try:
+    SIGNIFICANCE_THRESHOLDS = pd.read_csv('significance_thresholds.csv')
+except FileNotFoundError:
+    SIGNIFICANCE_THRESHOLDS = None
+
+# REMOVE task_subject_indices_file loading
+# Load file with task subject indices
+# try:
+#     with open('cached_data/task_subject_indices.pkl', 'rb') as f:
+#         task_subject_indices_file = pickle.load(f)
+# except FileNotFoundError:
+#     print("Did not find any task subject indices. Current working directory: ", 
+#           os.getcwd())
+#     task_subject_indices_file = None
+
+# ADD HOSTING_STATS loading
+HOSTING_STATS_PATH = Path("cached_data/precalculated_stats.pkl.gz") # Assumes script is run from task-similarity-analysis/ or it's in PYTHONPATH
+try:
+    with gzip.open(HOSTING_STATS_PATH, "rb") as f:
+        HOSTING_STATS = pickle.load(f)
+    if HOSTING_STATS is None: # Should not happen if pickle.load succeeds
+        print(f"Warning: {HOSTING_STATS_PATH} loaded as None.")
+    # else:
+    #     print(f"Successfully loaded {HOSTING_STATS_PATH}")
+except FileNotFoundError:
+    print(f"ERROR: Could not load {HOSTING_STATS_PATH}. Please run preprocess_data_for_hosting.py first.")
+    HOSTING_STATS = None 
+except Exception as e:
+    print(f"Error loading {HOSTING_STATS_PATH}: {e}")
+    HOSTING_STATS = None
+
+
+def calculate_task_statistics(
+    task_info_with_subject: tuple, 
+    selected_sensors: list[str], 
+    time_window_offsets: list[int], # Represents phase_windows from dashboard e.g. [1], or [1,2,3]
+    verbose: bool = False
+) -> Optional[tuple[np.ndarray, np.ndarray, int]]:
+    """Pre-compute task statistics for a given task and sensor configuration using HOSTING_STATS.
+    
+    Args:
+        task_info_with_subject: Tuple of (task_name, incline, speed, subject)
+        selected_sensors: List of sensor names to use
+        time_window_offsets: List of 1-indexed phase windows (e.g., [1] for current, [1,2] for current and t-1).
+                             Effectively, 1 -> roll_offset 0, 2 -> roll_offset 1, etc.
+        verbose: Whether to print verbose output
+    Returns:
+        Tuple of (final_means_array, final_covs_array, n_samples) if stats exist, None otherwise.
+        final_means_array shape: (150, len(selected_sensors) * num_actual_time_windows)
+        final_covs_array shape: (150, combined_num_features, combined_num_features) (diagonal)
+        n_samples: number of samples used for pre-calculation.
+    """
+    if HOSTING_STATS is None:
+        if verbose:
+            print("Error: HOSTING_STATS not loaded. Cannot calculate task statistics.")
+        return None
+
+    try:
+        subject_stats = HOSTING_STATS[task_info_with_subject]
+        means_all_features_at_t0 = subject_stats['means']       # (150, num_all_features_precalculated)
+        variances_all_features_at_t0 = subject_stats['variances'] # (150, num_all_features_precalculated)
+        n_samples = subject_stats['n_samples']
+        feature_order_at_preprocessing = subject_stats['feature_order']
+    except KeyError:
+        if verbose:
+            print(f"Warning: Statistics for {task_info_with_subject} not found in HOSTING_STATS. Skipping.")
+        return None
+    except TypeError: # If HOSTING_STATS is None or not a dict
+        if verbose:
+            print(f"Warning: HOSTING_STATS is not a valid dictionary for {task_info_with_subject}. Skipping.")
+        return None
+
+
+    try:
+        sensor_indices_in_precalc_order = [feature_order_at_preprocessing.index(s) for s in selected_sensors]
+    except ValueError as e:
+        if verbose:
+            print(f"Warning: One or more selected_sensors not found in preprocessed feature_order for {task_info_with_subject}: {e}. Selected: {selected_sensors}, Available: {feature_order_at_preprocessing}. Skipping.")
+        return None
+
+    means_selected_current_phase = means_all_features_at_t0[:, sensor_indices_in_precalc_order]    # (150, len(selected_sensors))
+    variances_selected_current_phase = variances_all_features_at_t0[:, sensor_indices_in_precalc_order] # (150, len(selected_sensors))
+
+    # Determine actual roll offsets based on time_window_offsets from dashboard
+    # time_window_offsets (phase_windows from dashboard): [1] means current data (roll offset 0)
+    # [1, 2, 3] means current (offset 0), t-1 (offset 1), t-2 (offset 2)
+    
+    actual_roll_offsets_to_apply = [] # stores 0 for current, 1 for t-1, etc.
+    
+    # Ensure time_window_offsets is a list, default to [1] if empty or None (current time only)
+    current_time_window_offsets = time_window_offsets if time_window_offsets else [1]
+
+    for w in sorted(list(set(current_time_window_offsets))): # e.g., w from [1, 2, 3]
+        if w >= 1: # Dashboard sends 1-indexed windows
+            actual_roll_offsets_to_apply.append(w - 1) # Convert to 0-indexed roll offset
+    
+    # Ensure actual_roll_offsets_to_apply is sorted and unique, typically [0], or [0,1,2] etc.
+    actual_roll_offsets_to_apply = sorted(list(set(actual_roll_offsets_to_apply)))
+    if not actual_roll_offsets_to_apply: # Should not happen if dashboard sends at least [1]
+         if verbose: print(f"Warning: No valid roll offsets from time_window_offsets {time_window_offsets}, defaulting to current time (offset 0).")
+         actual_roll_offsets_to_apply = [0]
+
+
+    final_means_list = []
+    final_variances_list = []
+
+    for roll_offset in actual_roll_offsets_to_apply:
+        if roll_offset == 0:
+            final_means_list.append(means_selected_current_phase.copy())
+            final_variances_list.append(variances_selected_current_phase.copy())
+        elif roll_offset > 0:
+            rolled_means = np.roll(means_selected_current_phase, shift=roll_offset, axis=0) # roll along phase axis
+            rolled_variances = np.roll(variances_selected_current_phase, shift=roll_offset, axis=0)
+            final_means_list.append(rolled_means)
+            final_variances_list.append(rolled_variances)
+        # else: negative roll_offset could mean future data, not typically used here.
+
+    if not final_means_list:
+        if verbose:
+            print(f"Critical Error: final_means_list is empty after processing time_window_offsets for {task_info_with_subject}. This should not happen.")
+        return None # Or raise error
+
+    final_means_array = np.concatenate(final_means_list, axis=1)       # Concatenate along feature axis
+    final_variances_array = np.concatenate(final_variances_list, axis=1) # Concatenate along feature axis
+    
+    num_combined_features = final_means_array.shape[1]
+    final_covs_array = np.zeros((150, num_combined_features, num_combined_features))
+    for i in range(150): # For each of the 150 phase points
+        final_covs_array[i] = np.diag(final_variances_array[i]) # Variances are for the combined features
+
+    return final_means_array, final_covs_array, n_samples
+
+def apply_binary_threshold(portrait, n_samples_1, n_samples_2):
+    # Get minimum number of samples for this task pair
+    min_samples = min(n_samples_1, n_samples_2)
+    # Clip to max available threshold sample size
+    min_samples = min(min_samples, len(SIGNIFICANCE_THRESHOLDS))
+    # Get threshold for this sample size
+    threshold = SIGNIFICANCE_THRESHOLDS.iloc[min_samples-1]['threshold_95']
+    # Apply binary threshold
+    portrait[portrait < threshold] = 0
+    portrait[portrait >= threshold] = 1
+    return portrait
+
+def process_pair(task_pair, task_1_stats, task_2_stats, 
+                 binary_threshold=False,
+                 match_subjects: bool = False,
+                 biomechanical_difference: bool = False):
+    """Process a single task pair using pre-computed statistics (vectorized path only)."""
+    task1, task2 = task_pair
+    
+    # Initialize list to collect portraits for all subject combinations
+    subject_pairs = []
+    portraits = []
+    
+    # Handle subject matching option
+    if match_subjects:
+        # Only compare the same subjects between tasks
+        common_subjects = set(task_1_stats[task1].keys()) & set(task_2_stats[task2].keys())
+        for subject in common_subjects:
+            subject_pairs.append((subject, subject))
+            means1, covs1, n_samples1 = task_1_stats[task1][subject]
+            means2, covs2, n_samples2 = task_2_stats[task2][subject]
+            
+            # Calculate portrait for this subject - ALWAYS USE VECTORIZED PATH
+            portrait = vectorized_overlap_mine(means1, covs1, means2, covs2,
+                                                  biomechanical_difference=biomechanical_difference)
+            
+            if binary_threshold:
+                portrait = apply_binary_threshold(portrait, n_samples1, n_samples2)
+            
+            portraits.append(portrait)
+    else:
+        # Compare all possible subject combinations between the two tasks
+        for subject1, stats1 in task_1_stats[task1].items():
+            for subject2, stats2 in task_2_stats[task2].items():
+                subject_pairs.append((subject1, subject2))
+                means1, covs1, n_samples1 = stats1
+                means2, covs2, n_samples2 = stats2
+                
+                # Calculate portrait for this subject pair - ALWAYS USE VECTORIZED PATH
+                portrait = vectorized_overlap_mine(means1, covs1, means2, covs2,
+                                                     biomechanical_difference=biomechanical_difference)
+                
+                if binary_threshold:
+                    portrait = apply_binary_threshold(portrait, n_samples1, n_samples2)
+                
+                portraits.append(portrait)
+    
+    # If no valid portraits were created, return None
+    if len(portraits) == 0:
+        return None
+    elif 'stair' in task1[0] or 'stair' in task2[0]:
+        pass    
+    return portraits, subject_pairs
+
+def vectorized_overlap_mine(means1, covs1, means2, covs2, tol=1e-12,
+                            biomechanical_difference=False):
+    """
+    Vectorized version of the 'mine' method overlap measure computation.
+    Assumes covariance matrices (covs1, covs2) are diagonal.
+    
+    Parameters:
+        means1 (np.ndarray): Array of means for task 1 with shape (150, d).
+        covs1 (np.ndarray): Array of covariance matrices for task 1 with shape (150, d, d). Must be diagonal.
+        means2 (np.ndarray): Array of means for task 2 with shape (150, d).
+        covs2 (np.ndarray): Array of covariance matrices for task 2 with shape (150, d, d). Must be diagonal.
+        tol (float): Tolerance value to determine if a matrix is singular.
+        biomechanical_difference (bool): If True, apply output-difference filtering per
+            the method: negligible–negligible (D* = 0), amplitude (D* = D), or sign reversal
+            (D* = D × P_diff_sign).
+    
+    Returns:
+        np.ndarray: Overlap measures as a (150, 150) array.
+    """
+    d = means1.shape[1]
+    # Pairwise mean differences: (150,150,d)
+    diff = means1[:, None, :] - means2[None, :, :]
+    # Combined covariances: (150,150,d,d)
+    S = covs1[:, None, :, :] + covs2[None, :, :, :]
+    # output
+    overlap = np.zeros((150, 150))
+    
+    # --- compute raw overlap ---
+    # Logic is now only for diagonal covariance
+    # S_diag was originally `np.diagonal(S, axis1=2, axis2=3)`
+    # Since S = covs1 + covs2 and covs are diagonal, S is diagonal.
+    # S_diag elements are just var1 + var2 for each feature.
+    # covs1 and covs2 are (150, d, d), but diagonal. We can extract their diagonals first.
+    vars1 = np.diagonal(covs1, axis1=1, axis2=2) # Shape (150, d)
+    vars2 = np.diagonal(covs2, axis1=1, axis2=2) # Shape (150, d)
+
+    # Pairwise sum of variances: (150, 150, d)
+    # vars1[:, None, :] gives (150, 1, d)
+    # vars2[None, :, :] gives (1, 150, d)
+    # Broadcasting sum_vars to (150, 150, d)
+    sum_vars = vars1[:, None, :] + vars2[None, :, :] 
+    
+    non_singular = np.all(sum_vars > tol, axis=2) # Check if all diagonal elements of (cov1+cov2) are > tol for each pair
+    
+    if np.any(non_singular):
+        # Compute the quadratic form efficiently for diagonal matrices
+        # diff is (150,150,d). diff[non_singular] is (N,d) where N is number of non_singular pairs.
+        # sum_vars[non_singular] is (N,d).
+        quad_form_terms = diff[non_singular]**2 / sum_vars[non_singular] # (N, d)
+        quad_form = np.sum(quad_form_terms, axis=1) # (N,)
+            
+        # Compute the overlap measure with underflow protection
+        max_exp = 20.0  # Maximum value before underflow in np.exp
+        
+        overlap_values = np.zeros_like(quad_form)
+        
+        # Indices where exponent is too large
+        large_exp_mask = (0.5 * quad_form) > max_exp
+        
+        # Indices where exponent is not too large
+        non_large_exp_mask = ~large_exp_mask
+        
+        overlap_values[non_large_exp_mask] = np.exp(-0.5 * quad_form[non_large_exp_mask])
+        # For large exponents, overlap_values remains 0 (default)
+            
+        # Assign computed values to the overlap array
+        i_idx, j_idx = np.where(non_singular)
+        overlap[i_idx, j_idx] = overlap_values
+    
+    # --- output‐difference filtering (vectorized) ---
+    if biomechanical_difference:
+        negligible_threshold = 0.1
+        ampable_threshold = 0.2
+
+        # optimized for scalar case (d=1)
+        std1 = np.sqrt(covs1[:, 0, 0])
+        std2 = np.sqrt(covs2[:, 0, 0])
+        ci_lo1 = means1[:, 0] - 1.96 * std1
+        ci_hi1 = means1[:, 0] + 1.96 * std1
+        ci_lo2 = means2[:, 0] - 1.96 * std2
+        ci_hi2 = means2[:, 0] + 1.96 * std2
+        
+        z1 = means1[:, 0] / np.maximum(std1, tol)
+        z2 = means2[:, 0] / np.maximum(std2, tol)
+        Ppos1 = norm.cdf(z1);  Pneg1 = 1.0 - Ppos1
+        Ppos2 = norm.cdf(z2);  Pneg2 = 1.0 - Ppos2
+
+        negligible1 = (ci_lo1 >= -negligible_threshold) & (ci_hi1 <= negligible_threshold)
+        negligible2 = (ci_lo2 >= -negligible_threshold) & (ci_hi2 <= negligible_threshold)
+        ampable1    = np.abs(means1[:, 0]) > ampable_threshold
+        ampable2    = np.abs(means2[:, 0]) > ampable_threshold
+
+        
+        i_idx, j_idx = np.nonzero(non_singular)
+        if i_idx.size > 0:
+            # negligible–negligible → zero overlap
+            m0 = negligible1[i_idx] & negligible2[j_idx]
+            # Since we calculate similarity, we set the similarity to 1
+            # which is turns makes the difference 0
+            overlap[i_idx[m0], j_idx[m0]] = 1.0
+
+            # amplitude conflicts → skip modification
+            m1 = (negligible1[i_idx] & ampable2[j_idx]) \
+               | (negligible2[j_idx] & ampable1[i_idx])
+
+            # sign-reversal scaling for the rest
+            m2 = ~(m0 | m1)
+            if np.any(m2):
+                with np.errstate(all='ignore'):
+                    Pdiff = (
+                        Ppos1[i_idx[m2]] * Pneg2[j_idx[m2]] +
+                        Pneg1[i_idx[m2]] * Ppos2[j_idx[m2]]
+                    )
+                    # Since we calculate similarity, we have to scale the overlap 
+                    # and then convert it back to a similarity measure
+                    overlap[i_idx[m2], j_idx[m2]] = 1-(1-overlap[i_idx[m2], j_idx[m2]])*Pdiff
+
+    # clamp to [0,1]
+    np.clip(overlap, 0.0, 1.0, out=overlap)
+    return overlap
+
+
+def calculate_similarity_portrait_abstraction(sensors: Union[tuple, list], time_window: Union[int, list[int]] = 1,
+                               task1_name: Union[tuple, str, None] = None,
+                               task2_name: Union[tuple, str, None] = None,
+                               verbose: bool = False,
+                               n_jobs: int = -1, # n_jobs not used currently with sequential loop
+                               return_all_portraits: bool = False, # return_all_portraits part of results_dict, not directly handled by agg
+                               progress_callback: Optional[Callable[[float], None]] = None,
+                               binary_threshold: bool = False,
+                               output_difference: bool = False, # Renamed from use_output_data in dashboard
+                               match_subjects: bool = False,
+                               save_results_dict: bool = False,
+                               biomechanical_difference: bool = False,
+                               abstraction_level: Optional[str] = None): # abstraction_level passed from dashboard
+    """
+    Calculate input similarity between two tasks using multivariate Gaussian 
+    based on a given abstraction level. Uses pre-calculated HOSTING_STATS.
+    Always uses the vectorized 'mine' overlap calculation method.
+
+    High level: Is there any conflict? 
+        At this abstraction level, we want to understand if there is any 
+        conflict for a given sensor configuration. Calculate the similarity 
+        portrait for each task at the lowest level of abstraction and then 
+        aggregate the results using the agg_method function (maximum of each 
+        individual similarity portrait). The total similarity portrait is then 
+        transposed and maxed back so that it is symmetric.  
+
+    Medium/Low level: Is there any similarity between tasks with optional specificity? 
+        At this abstraction level, we want to understand similarity between tasks
+        with optional specificity for incline and speed. For example:
+        - Compare all incline 5° to stairs up: task1_name=('incline', 5, None)
+        - Compare specific tasks: task1_name=('incline', 5, 0.8)
+        - Compare general tasks: task1_name=('incline', None, None)
+        
+        Format: task_name = (task:str, incline:float|None, speed:float|None)
+        Setting incline/speed to None means match any value for that parameter.
+
+    At each level, the similarity portrait is calculated for each subject and
+    leg seperately and then aggregated using the agg_method function. 
+
+    Arguments:
+    ----------
+    sensors: tuple or list
+        List of sensor names to use for similarity calculation
+    time_window: int or list, optional
+        List of 1-indexed phase windows (e.g., [1] for current, [1,2] for current and t-1).
+        Passed as time_window_offsets to calculate_task_statistics.
+    task1_name: tuple, optional
+        For low level: tuple of (task_name:str, incline:float|None, 
+        speed:float|None)
+        Set incline/speed to None to match any value
+    task2_name: tuple, optional
+        Same format as task1_name
+    verbose: bool, optional
+        Whether to show progress bar during calculations (default=False)
+    n_jobs: int, optional
+        Number of CPU cores to use. -1 means use all available cores (default=-1). Currently not used.
+
+    return_all_portraits: bool, optional
+        If True, returns the full results_dict. If False (default), returns only the aggregated portrait.
+    binary_threshold: bool, optional
+        If True, threshold each low-level similarity portrait based on the 95% 
+        confidence interval. Values below the threshold are set to 0, above to 1.
+        (default=False)
+    output_difference: bool, optional
+        If True, return the difference between the similarity portrait and 1 
+        (default=False)
+    match_subjects: bool, optional
+        If True, match subjects between tasks (default=False)
+    save_results_dict: bool, optional
+        If True, save the results_dict to a file. Default False.
+    abstraction_level: str, optional
+        The abstraction level ("high", "medium", "low"). Used for logging/context, not for filtering within this function anymore.
+    """
+
+    # time_window is expected to be a list of 1-indexed phase windows from dashboard, e.g., [1], [1,2,3]
+    # It will be passed as time_window_offsets to calculate_task_statistics
+    # If it's an int, convert to list, though dashboard should pass list.
+    if isinstance(time_window, int):
+        # This interpretation might need review based on how dashboard calls it.
+        # If time_window=1 means "current only", it should become [1].
+        # If time_window=3 means "current, t-1, t-2", it should become [1,2,3].
+        # Let's assume int means number of windows starting from current.
+        time_window_offsets_list = list(range(1, time_window + 1)) if time_window > 0 else [1]
+    elif isinstance(time_window, list):
+        time_window_offsets_list = time_window if time_window else [1] # Default to [1] if empty list
+    else: # Default to current time if malformed
+        time_window_offsets_list = [1]
+
+
+    # MOVED TO config.py: low_level_tasks
+    unique_subjects_from_config_or_data = []
+    if HOSTING_STATS:
+        # Try to infer subjects from HOSTING_STATS keys if needed, though LOW_LEVEL_TASKS and iterating subjects is primary
+        all_subjects_in_stats = set()
+        for k_tuple in HOSTING_STATS.keys():
+            if isinstance(k_tuple, tuple) and len(k_tuple) == 4: # (task, inc, spd, subject)
+                all_subjects_in_stats.add(k_tuple[3])
+        unique_subjects_from_config_or_data = sorted(list(all_subjects_in_stats))
+        if not unique_subjects_from_config_or_data and verbose:
+            print("Warning: Could not infer subjects from HOSTING_STATS keys.")
+    
+    # If subjects could not be inferred or HOSTING_STATS is None, this part will be problematic.
+    # The original code used total_data['subject'].unique(). This is no longer available.
+    # For now, let's assume LOW_LEVEL_TASKS and iterating these subjects is the way.
+    # The `preprocess_data_for_hosting.py` iterates `unique_subjects = total_data['subject'].unique()`.
+    # So `HOSTING_STATS` keys will contain all subjects that had data.
+    # `unique_subjects_from_config_or_data` should capture these.
+    # If this list is empty and HOSTING_STATS is populated, it means keys are not as expected.
+    
+    # Fallback if subjects list is empty but stats exist (e.g. if keys are not tuples of 4)
+    # This part needs robust subject discovery if not relying on a predefined list.
+    # For now, assume unique_subjects_from_config_or_data is sufficient or that errors will propagate if it's empty.
+
+
+    # Pre-compute statistics for all valid tasks
+    if verbose or progress_callback:
+        print("Pre-computing task statistics...")
+        if progress_callback:
+            progress_callback(0.1)  # Show initial progress
+    
+    task_1_stats = {}
+    task_2_stats = {}
+    
+    # Determine subjects to iterate over.
+    # If unique_subjects_from_config_or_data is empty, this loop won't run correctly.
+    subjects_to_iterate = unique_subjects_from_config_or_data
+    if not subjects_to_iterate and verbose:
+        print("Warning: subjects_to_iterate is empty. Statistics pre-computation might be skipped or fail.")
+        # Potentially, if LOW_LEVEL_TASKS is what defines the scope, and subjects are per task_config in HOSTING_STATS
+        # then subject iteration should be nested inside task_config iteration if HOSTING_STATS keys are task_config specific.
+        # The current `preprocess_data_for_hosting.py` creates keys `(task_config_tuple, subject_str)`.
+
+    total_combinations_to_calc_stats_for = 0
+    tasks_for_stats_calc_t1 = []
+    tasks_for_stats_calc_t2 = []
+
+    for task_info_cfg in LOW_LEVEL_TASKS: # task_info_cfg is (task_name, incline, speed)
+        # Filter based on task1_name and task2_name (from dashboard selection)
+        task1_str, task1_incline, task1_speed = task1_name if task1_name else (None, None, None)
+        task2_str, task2_incline, task2_speed = task2_name if task2_name else (None, None, None)
+
+        task_1_match = (task1_str is None or task1_str == task_info_cfg[0]) and \
+                       (task1_incline is None or task1_incline == task_info_cfg[1]) and \
+                       (task1_speed is None or task1_speed == task_info_cfg[2])
+        
+        task_2_match = (task2_str is None or task2_str == task_info_cfg[0]) and \
+                       (task2_incline is None or task2_incline == task_info_cfg[1]) and \
+                       (task2_speed is None or task2_speed == task_info_cfg[2])
+
+        if task_1_match:
+            tasks_for_stats_calc_t1.append(task_info_cfg)
+            total_combinations_to_calc_stats_for += len(subjects_to_iterate) 
+        if task_2_match: # Can overlap with task_1_match
+            # Avoid double counting if task_1_match also true
+            if not task_1_match or task_info_cfg not in tasks_for_stats_calc_t1:
+                 tasks_for_stats_calc_t2.append(task_info_cfg) # only add if not already counted for t1
+                 total_combinations_to_calc_stats_for += len(subjects_to_iterate)
+            elif task_1_match and task_info_cfg not in tasks_for_stats_calc_t2: # if it matched t1, ensure it's in t2 list for later use
+                 tasks_for_stats_calc_t2.append(task_info_cfg)
+
+
+    # Recalculate total_combinations based on unique tasks for T1 and T2 sets
+    # This is complex if subjects vary per task_info in HOSTING_STATS.
+    # The simple approach: iterate LOW_LEVEL_TASKS, then subjects found in HOSTING_STATS for that task_info.
+
+    current_stat_calcs = 0
+    expected_stat_calcs = 0 # Will be determined by actual found (task_cfg, subj) pairs in HOSTING_STATS
+
+    # Populate task_1_stats
+    for task_config_t1 in tasks_for_stats_calc_t1:
+        task_1_stats[task_config_t1] = {}
+        for subject in subjects_to_iterate: # Iterate all potential subjects
+            task_info_w_subject = (*task_config_t1, subject)
+            if HOSTING_STATS and task_info_w_subject in HOSTING_STATS: # Check if this specific combo exists
+                expected_stat_calcs +=1 # Count expected calculations
+                stats = calculate_task_statistics(
+                    task_info_w_subject, sensors, time_window_offsets_list, # Pass the list of offsets
+                    verbose=verbose
+                )
+                if stats is not None:
+                    task_1_stats[task_config_t1][subject] = stats
+                current_stat_calcs+=1
+                if progress_callback and expected_stat_calcs > 0 : progress_callback(0.1 + (0.4 * (current_stat_calcs / max(1,expected_stat_calcs*2)))) # *2 for T1 and T2 pass
+
+    # Populate task_2_stats
+    for task_config_t2 in tasks_for_stats_calc_t2:
+        task_2_stats[task_config_t2] = {}
+        for subject in subjects_to_iterate:
+            task_info_w_subject = (*task_config_t2, subject)
+            if HOSTING_STATS and task_info_w_subject in HOSTING_STATS:
+                if task_config_t2 not in tasks_for_stats_calc_t1 or subject not in task_1_stats.get(task_config_t2,{}): # Avoid re-calculating if already done for T1
+                    expected_stat_calcs +=1
+                
+                stats = calculate_task_statistics(
+                    task_info_w_subject, sensors, time_window_offsets_list,
+                    verbose=verbose
+                )
+                if stats is not None:
+                    task_2_stats[task_config_t2][subject] = stats
+                current_stat_calcs+=1 # This current_stat_calcs will go up to expected_stat_calcs*2 potentially
+                if progress_callback and expected_stat_calcs > 0: progress_callback(0.1 + (0.4 * (current_stat_calcs / max(1,expected_stat_calcs*2))))
+
+
+    # Clean up empty task_configs from stats if no subjects had data
+    task_1_stats = {k: v for k, v in task_1_stats.items() if v}
+    task_2_stats = {k: v for k, v in task_2_stats.items() if v}
+        
+    # Generate valid task pairs from successfully populated stats
+    task_pairs = list(itertools.product(task_1_stats.keys(), 
+                                        task_2_stats.keys()))
+
+    if verbose or progress_callback:
+        if progress_callback:
+            progress_callback(0.5)  # Half-way point
+        print(f"Computing similarity portraits for {len(task_pairs)} task pairs...")
+    
+    # Process task pairs in parallel
+    process_func = partial(process_pair, 
+                         task_1_stats=task_1_stats,
+                         task_2_stats=task_2_stats,
+                         binary_threshold=binary_threshold,
+                         match_subjects=match_subjects,
+                         biomechanical_difference=biomechanical_difference)
+    
+
+    # Add progress tracking if requested
+    results_dict = {}
+    num_results = 0
+    for i in tqdm(range(len(task_pairs)), desc="Processing task pairs",
+                  total=len(task_pairs)):
+        current_task_pair = task_pairs[i]
+        result = process_func(current_task_pair)
+        
+        # If the result is None, then skip it
+        if result is None:
+            # print(f"Result is None for task pair {current_task_pair}")
+            continue
+
+        if 'stair' in current_task_pair[0][0] or 'stair' in current_task_pair[1][0]:
+            pass
+        
+        portraits, subject_pairs = result
+
+        low_level_task_1 = (current_task_pair[0][0], 
+                            current_task_pair[0][1], 
+                            current_task_pair[0][2])
+        low_level_task_2 = (current_task_pair[1][0], 
+                            current_task_pair[1][1], 
+                            current_task_pair[1][2])
+        low_level_task_total = (low_level_task_1, low_level_task_2)
+        # Add the result to the list of results for this low-level task
+        if low_level_task_total not in results_dict:
+            results_dict[low_level_task_total] = {}
+   
+        if portraits is not None:
+            for subject_pair, portrait in zip(subject_pairs, portraits):
+                
+                # Take the compliment if you are doing the output difference
+                if output_difference:
+                    results_dict[low_level_task_total][subject_pair] = 1 - portrait
+                else:
+                    results_dict[low_level_task_total][subject_pair] = portrait
+            num_results += 1
+        # Update progress if we requested
+        if progress_callback:
+            progress_callback(0.5 + (0.4 * (i / len(task_pairs))))
+    
+    # Final progress update
+    if progress_callback:
+        progress_callback(0.9)
+
+    # Aggregate the similarity portraits
+    if num_results <= 0:
+        # raise ValueError("No valid similarity portraits were generated")
+        if verbose: print("Warning: No valid similarity portraits were generated. Check task/subject filters and data.")
+        return (np.zeros((150,150)), {}) if return_all_portraits else np.zeros((150,150)) # Return empty/zero portrait
+
+    # Remove empty results (should be handled by num_results check, but good practice)
+    results_dict = {k: v for k, v in results_dict.items() if v and any(item is not None for item in v.values())}
+    if not results_dict and num_results > 0: # Contradiction, means num_results was miscounted or structure is wrong
+        if verbose: print("Warning: results_dict is empty despite num_results > 0. Returning zero portrait.")
+        return (np.zeros((150,150)), {}) if return_all_portraits else np.zeros((150,150))
+    if not results_dict and num_results == 0: # Consistent, no results
+        return (np.zeros((150,150)), {}) if return_all_portraits else np.zeros((150,150))
+
+
+    # Get the aggregation of the similarity portraits
+    total_task_similarity_portrait = low_level_tasks_aggregation(results_dict)
+
+    if progress_callback:
+        progress_callback(1.0)  # Complete
+
+    # Add back save_results_dict logic
+    if save_results_dict:
+        directory = 'saved_similarity_portraits'
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        # Construct filename carefully. time_window_offsets_list might be long.
+        # Using a hash or a string representation that's filename-safe.
+        time_window_str = "-".join(map(str, time_window_offsets_list))
+        file_name = f'results_dict_{sorted(sensors)}_time_window_{time_window_str}'
+        if biomechanical_difference:
+            file_name += f'_biomechanical_difference_{biomechanical_difference}'
+        # Ensure filename is not too long and is valid
+        file_name = "".join(c if c.isalnum() or c in ('_', '-') else '' for c in file_name)[:100] + ".pkl"
+
+        try:
+            with open(os.path.join(directory, file_name), 'wb') as f:
+                pickle.dump(results_dict, f)
+            if verbose:
+                print(f"Saved results_dict to {os.path.join(directory, file_name)}")
+        except Exception as e:
+            if verbose:
+                print(f"Error saving results_dict: {e}")
+
+    if return_all_portraits:
+        return total_task_similarity_portrait, results_dict
+    else:
+        return total_task_similarity_portrait
+
+
+def low_level_tasks_aggregation(results_dict: dict[tuple, list[np.ndarray]]
+                                ) -> np.ndarray:
+    """
+    Aggregate the similarity portraits for low-level tasks.
+    First, we will get the average across all subjects for each low-level task.
+    Then, we will get the max of the average similarity portraits.
+    """
+    total_task_similarity_portraits = []
+    for low_level_task in results_dict.keys():
+        
+        # Get the average across all subjects for each subject pair
+        results_list = list(results_dict[low_level_task].values())
+       
+        # Get the average across all subjects for each low-level task
+        low_level_task_portraits = np.nanmean(results_list, axis=0)
+        
+        # Append the average similarity portrait to the list
+        total_task_similarity_portraits.append(low_level_task_portraits)
+
+    # Get the max of the average similarity portraits
+    total_task_similarity_portrait = np.max(total_task_similarity_portraits, 
+                                            axis=0)
+
+    if total_task_similarity_portrait is None:
+        pass
+
+    return total_task_similarity_portrait
+
+def load_similarity_portrait(sensor_config: list[str], 
+                            time_window: list[int]=[0], # Default [0] might need to be [1] to match dashboard
+                            task1_name: tuple=(None, None, None), 
+                            task2_name: tuple=(None, None, None),
+                            biomechanical_difference: bool = False):
+    """
+    Load the similarity pickle file and calculate the similarity portrait for 
+    a given sensor configuration, time window, and task names.
+
+    Arguments:
+    -----------
+    sensor_config : list[str]
+        The sensor configuration to use.
+    time_window : list[int]
+        The time window to use.
+    task1_name : tuple
+        Task name, incline, and speed for the first task. Use None for any value.
+    task2_name : tuple
+        Task name, incline, and speed for the second task. Use None for any value.
+
+    Returns:
+    --------
+    np.ndarray
+    """
+
+    # Get the file name
+    file_name = f'results_dict_{sorted(sensor_config)}_time_window_{time_window}'
+    if biomechanical_difference:
+        file_name += f'_biomechanical_difference_{biomechanical_difference}'
+    directory = 'saved_similarity_portraits'
+
+    # Load the results dict
+    with open(os.path.join(directory, f'{file_name}.pkl'), 'rb') as f:
+        results_dict = pickle.load(f)
+
+    # Check if we want to to a lower-levl task pair
+    if task1_name != (None, None, None) and task2_name != (None, None, None):
+        # Get the similarity portrait
+        try:
+            subject_portraits = results_dict[(task1_name, task2_name)]
+        except KeyError:
+            print(f"KeyError: {(task1_name, task2_name)} not found in results dict")
+            print(f"Results dict keys: {results_dict.keys()}")
+            raise KeyError(f"{(task1_name, task2_name)} not found in results dict")
+
+        similarity_portrait = np.mean(list(subject_portraits.values()), axis=0)
+    
+    # We want to do the high level aggregation 
+    else:
+        # Get the similarity portrait
+        similarity_portrait = low_level_tasks_aggregation(results_dict)
+
+    if similarity_portrait is None:
+        pass
+
+    return similarity_portrait
+
+
+def load_results_dict(sensor_config: list[str], 
+                      time_window: list[int]=[0]): # Default [0] might need to be [1]
+    """
+    Load the results dict for a given sensor configuration, time window, and task names.
+    """
+    # Get the file name
+    file_name = f'results_dict_{sorted(sensor_config)}_time_window_{time_window}'
+    directory = 'saved_similarity_portraits'
+
+    # Load the results dict
+    with open(os.path.join(directory, f'{file_name}.pkl'), 'rb') as f:
+        results_dict = pickle.load(f)
+
+    return results_dict
+
+def load_input_output_similarity_portrait(sensor_config: list[str], 
+                                          output_config: list[str],
+                                          time_window: list[int]=[0], # Default [0] might need to be [1]
+                                          task1_name: tuple=(None, None, None), 
+                                          task2_name: tuple=(None, None, None),
+                                          biomechanical_difference: bool = False):
+    """
+    Load the similarity pickle file and calculate the similarity portrait for 
+    a given sensor configuration, time window, and task names.
+    """
+
+    # Load the input and output pickle files
+    directory = 'saved_similarity_portraits'
+    input_file_name = f'results_dict_{sorted(sensor_config)}_time_window_{time_window}'
+    output_file_name = f'results_dict_{sorted(output_config)}_time_window_{[0]}'
+    if biomechanical_difference:
+        output_file_name += f'_biomechanical_difference_{biomechanical_difference}'
+
+    input_results_dict = None
+    output_results_dict = None
+
+    # Load the input pickle file with error handling
+    try:
+        with open(os.path.join(directory, f'{input_file_name}.pkl'), 'rb') as f:
+            input_results_dict = pickle.load(f)
+    except FileNotFoundError:
+        print(f"Warning: Input similarity file not found: {input_file_name}.pkl")
+        # Return placeholder if input file is crucial and missing
+        # return np.zeros((150, 150))
+
+    # Load the output pickle file with error handling
+    try:
+        with open(os.path.join(directory, f'{output_file_name}.pkl'), 'rb') as f:
+            output_results_dict = pickle.load(f)
+    except FileNotFoundError:
+        print(f"Warning: Output similarity file not found: {output_file_name}.pkl")
+        # Decide if placeholder is needed if output file is missing
+        # If both are needed, might return placeholder here
+
+    # If either dict failed to load, return placeholder
+    if input_results_dict is None or output_results_dict is None:
+        print(f"Warning: Could not load required similarity data. Returning placeholder zeros.")
+        return np.zeros((150, 150))
+
+    # If the task1_name and task2_name are not None, then we want to do a 
+    # lower-level task pair
+    try:
+        if task1_name != (None, None, None) and task2_name != (None, None, None):
+            target_key = (task1_name, task2_name)
+            input_results_dict = {target_key: input_results_dict[target_key]}
+            output_results_dict = {target_key: output_results_dict[target_key]}
+    except KeyError:
+        print(f"KeyError: {(task1_name, task2_name)} not found in input or output results dicts")
+        return None
+
+    # Calculate the input and output similarity portrait
+    input_output_similarity_portrait = input_output_task_aggregation(
+        input_results_dict, output_results_dict
+    )
+
+    return input_output_similarity_portrait
+
+# Add back input_output_task_aggregation
+def input_output_task_aggregation(
+    input_results_dict: dict[tuple, list[np.ndarray]],
+    output_results_dict: dict[tuple, list[np.ndarray]],
+) -> np.ndarray:
+    """
+    Aggregate the similarity portraits for input and output tasks.
+    """
+    # Check if the input and output results dicts have the same keys
+    if input_results_dict.keys() != output_results_dict.keys():
+        input_keys = set(input_results_dict.keys())
+        output_keys = set(output_results_dict.keys())
+        matching_keys = input_keys & output_keys
+        input_only_keys = input_keys - output_keys
+        output_only_keys = output_keys - input_keys
+        
+        num_matching_keys = len(matching_keys)
+        num_input_only_keys = len(input_only_keys)
+        num_output_only_keys = len(output_only_keys)
+        
+        # This print might be too verbose for regular operation
+        # print(f"Keys do not match: {num_matching_keys} keys matching, {num_input_only_keys} keys only in input, {num_output_only_keys} keys only in output")
+        
+        # # Save the set of matching and not matching keys to a single file (for debugging)
+        # with open('matching_and_not_matching_keys.txt', 'w') as f:
+        #     f.write(f"Matching keys:\n")
+        #     for key in matching_keys:
+        #         f.write(f"{key}\n")
+            
+        #     f.write(f"\nNot matching keys:\n")
+        #     if input_only_keys:
+        #         f.write(f"Keys only in input dictionary:\n")
+        #         for key in input_only_keys:
+        #             f.write(f"{key}\n")
+            
+        #     if output_only_keys:
+        #         f.write(f"\nKeys only in output dictionary:\n")
+        #         for key in output_only_keys:
+        #             f.write(f"{key}\n")
+   
+   
+    common_keys = set(input_results_dict.keys()) & set(output_results_dict.keys())
+    if not common_keys:
+        # print("Warning: No common keys between input and output results dicts for aggregation.")
+        return np.zeros((150,150)) # Return a default empty portrait
+
+    total_task_similarity_portraits = []
+
+    # Get the average across all subjects for each low-level task
+    for low_level_task in common_keys:
+        if not input_results_dict[low_level_task] or not output_results_dict[low_level_task]:
+            # print(f"Warning: Empty subject data for low_level_task {low_level_task} in input or output dict. Skipping.")
+            continue
+
+        # Get the common subjects between the input and output results dicts for this specific low_level_task
+        common_subject_pairs = set(input_results_dict[low_level_task].keys()) & \
+                               set(output_results_dict[low_level_task].keys())
+
+        if not common_subject_pairs:
+            # print(f"Warning: No common subject pairs for low_level_task {low_level_task}. Skipping.")
+            continue
+
+        # Take the product of the input and output similarity portraits for 
+        # each subject pair
+        subject_input_output_portraits = []
+        for subject_pair in common_subject_pairs:
+            input_portrait = input_results_dict[low_level_task].get(subject_pair)
+            output_portrait = output_results_dict[low_level_task].get(subject_pair)
+
+            if input_portrait is not None and output_portrait is not None:
+                # Ensure they are numpy arrays for element-wise multiplication
+                input_portrait_np = np.array(input_portrait)
+                output_portrait_np = np.array(output_portrait)
+                if input_portrait_np.shape == output_portrait_np.shape:
+                     subject_input_output_portraits.append(
+                         input_portrait_np * output_portrait_np
+                     )
+                # else:
+                #     print(f"Warning: Shape mismatch for subject pair {subject_pair}, task {low_level_task}. Input: {input_portrait_np.shape}, Output: {output_portrait_np.shape}. Skipping.")
+            # else:
+            #     print(f"Skipping subject pair {subject_pair} for low-level task {low_level_task} because one of the portraits is None")
+                
+
+        if not subject_input_output_portraits:
+            # print(f"Warning: No valid subject_input_output_portraits for low_level_task {low_level_task}. Skipping.")
+            continue
+            
+        # Get the mean of the subject-specific input-output product portraits
+        # Changed from max to mean as per original intent for product aggregation before overall max
+        mean_subject_input_output_portrait = np.nanmean(
+            np.array(subject_input_output_portraits), axis=0 
+        )
+        if np.isnan(mean_subject_input_output_portrait).all():
+            # print(f"Warning: Mean subject input-output portrait is all NaN for {low_level_task}. Skipping.")
+            continue
+
+        # Append the aggregated similarity portrait for this low_level_task to the list
+        total_task_similarity_portraits.append(mean_subject_input_output_portrait)
+    
+    if not total_task_similarity_portraits:
+        # print("Warning: No task similarity portraits to aggregate after processing all common keys.")
+        return np.zeros((150,150))
+
+    # Get the max across all low_level_task aggregated portraits
+    final_aggregated_portrait = np.nanmax(
+        np.array(total_task_similarity_portraits), axis=0
+    )
+    if np.isnan(final_aggregated_portrait).all():
+        # print("Warning: Final aggregated portrait is all NaN. Returning zeros.")
+        return np.zeros((150,150))
+    
+    return final_aggregated_portrait

plot_similarity.py

@@ -0,0 +1,166 @@
+"""Visualization functions for similarity measures"""
+from plot_styling import PLOT_STYLE, PLOT_COLORS, set_plot_style
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from typing import Optional, Union
+import matplotlib as mpl
+from matplotlib.colors import LinearSegmentedColormap
+
+def plot_similarity_measure(measure_data: np.ndarray, ax: plt.Axes = None,  
+                            plot_type: str = 'input', cbar: bool = True,
+                          task_x_name: str = '', task_y_name: str = '',
+                          xlabel: Optional[str] = None, ylabel: Optional[str] = None, 
+                          cmap: Optional[Union[str, mpl.colors.Colormap]] = None,
+                          title: Optional[str] = None,
+                          fontsize: int = 12,
+                          y_label_pad: int = -13,
+                          cbar_labels: bool = True,
+                          cutoff_treshold:float=None,
+                          high_level_plot: bool = False):
+    """Plot similarity measure with consistent styling.
+    
+    Args:
+        ax: matplotlib axis object
+        measure_data: 2D array of similarity measures
+        plot_type: str, one of 'input', 'output', or 'conflict'
+        cbar: bool, whether to show colorbar
+        task_x_name: str, name of x-axis task (used if xlabel not provided)
+        task_y_name: str, name of y-axis task (used if ylabel not provided)
+        xlabel: str, optional custom x-axis label
+        ylabel: str, optional custom y-axis label
+        cmap: str or matplotlib colormap, optional custom colormap
+        title: str, optional custom title
+        fontsize: int, font size for all text elements
+        cbar_labels: bool, whether to show colorbar labels
+        cutoff_treshold: float, optional cutoff threshold that will count 
+          as a conflict. If it is not None, the amount of values above this 
+          threshold will be added as a percent text next to the colorbar.
+          If it is None, no text will be added.
+        high_level_plot: bool, whether to plot in a high-level format. This just
+          means that we subtract the diagonal from the thresholded values, since
+          this will trivially be 1 due to the fact that we compare the same task
+          to itself.
+    """
+    
+    if ax is None:
+        fig, ax = plt.subplots()
+
+    # Set color based on plot type
+    if cmap is None:
+        if plot_type == 'input':
+            cmap = PLOT_COLORS['input_similarity']
+        elif plot_type == 'output':
+            cmap = PLOT_COLORS['output_difference']
+        elif plot_type == 'output_biomechanical':
+            cmap = PLOT_COLORS['output_biomechanical']
+        else:  # conflict
+            cmap = PLOT_COLORS['conflict']
+
+    # Create heatmap with flipped y-axis
+    hm = sns.heatmap(np.flipud(measure_data), vmin=0, vmax=1, ax=ax, cmap=cmap,
+                        cbar=False, rasterized=False)
+
+    # Configure axes
+    ax.set_xticks([0, 149])
+    ax.set_xticklabels(['0%', '100%'], fontsize=fontsize)
+    ax.set_yticks([0, 149])
+    ax.set_yticklabels(['100%', '0%'], fontsize=fontsize)  # Flipped y-axis labels
+    
+    # Set labels with consistent padding
+    if xlabel is not None:
+        ax.set_xlabel(f'Gait Cycle (%)\n{xlabel}', labelpad=PLOT_STYLE['label_pad_x']-3, fontsize=fontsize)
+    elif task_x_name:
+        ax.set_xlabel(f'Gait Cycle (%)\n{task_x_name}', labelpad=PLOT_STYLE['label_pad_x']-3, fontsize=fontsize)
+    else:
+        ax.set_xlabel('Gait Cycle (%)', labelpad=PLOT_STYLE['label_pad_x']-3, fontsize=fontsize)
+        
+    if ylabel is not None:
+        ax.set_ylabel(f'{ylabel}\nGait Cycle (%)', labelpad=PLOT_STYLE['label_pad_y']-13+y_label_pad, fontsize=fontsize)
+    elif task_y_name:
+        ax.set_ylabel(f'{task_y_name}\nGait Cycle (%)', labelpad=PLOT_STYLE['label_pad_y']-13+y_label_pad, fontsize=fontsize)
+    else:
+        ax.set_ylabel('Gait Cycle (%)', labelpad=PLOT_STYLE['label_pad_y']-13+y_label_pad, fontsize=fontsize)
+    
+    # Configure ticks
+    ax.tick_params(axis='both', which='both',
+                  length=PLOT_STYLE['tick_length'],
+                  width=PLOT_STYLE['tick_width'],
+                  pad=PLOT_STYLE['tick_pad'],
+                  labelsize=fontsize)
+    
+    # Ensure x-axis labels are horizontal
+    ax.tick_params(axis='x', rotation=0)
+    
+    # Set the title
+    if title is not None:
+        ax.set_title(title, pad=2, fontsize=fontsize)
+
+    if cbar:
+        divider = make_axes_locatable(ax)
+        cax = divider.append_axes("right", size="5%", pad=0.05)  # Increased from 2% to 5%
+        cbar_obj = plt.colorbar(hm.collections[0], cax=cax)
+        cbar_obj.outline.set_visible(False)
+        cbar_obj.ax.yaxis.set_ticks_position('right')
+        cbar_obj.ax.tick_params(length=0, labelsize=fontsize)
+        if cbar_labels:
+            cbar_obj.set_ticks([0, 1])
+        else:
+            cbar_obj.set_ticks([])
+
+        # Implement cutoff threshold annotation
+        if cutoff_treshold is not None:
+
+            # The actual cutoff will depend on the plot type
+            if plot_type == 'input':
+                true_cutoff = cutoff_treshold
+            elif plot_type == 'output':
+                true_cutoff = 1 - cutoff_treshold
+            elif plot_type == 'output_biomechanical':
+                true_cutoff = 1 - cutoff_treshold
+            else:  # conflict
+                true_cutoff = cutoff_treshold * (1 - cutoff_treshold)
+
+
+            # Count percent of values above threshold
+            if high_level_plot:
+                # Subtract diagonal from thresholded values
+                mask = np.ones_like(measure_data, dtype=bool)
+                np.fill_diagonal(mask, False)
+                total = np.sum(mask)
+                above = np.sum((measure_data > true_cutoff) & mask)
+            else:
+                total = measure_data.size
+                above = np.sum(measure_data > true_cutoff)
+            percent = 100.0 * above / total if total > 0 else 0.0
+            # Format as e.g. "12.3% > 0.8"
+            annotation = f"{percent:.1f}% > {true_cutoff:g}"
+            # Place annotation to the right of the colorbar
+            cbar_obj.ax.text(1.2, 0.5, annotation, va='center', ha='left', 
+                             fontsize=fontsize, rotation=90, transform=cbar_obj.ax.transAxes)
+
+    # Set aspect ratio to equal
+    ax.set_aspect('equal')
+    
+    return hm
+
+# Create custom colormaps with transparency for low values
+def create_transparent_cmap(colors):
+    # Convert hex colors to RGB tuples with alpha
+    rgb_colors = [(1,1,1,0)]  # Start with transparent white
+    for hex_color in colors:
+        r = int(hex_color[1:3], 16)/255
+        g = int(hex_color[3:5], 16)/255 
+        b = int(hex_color[5:7], 16)/255
+        rgb_colors.append((r, g, b, 1.0))
+    return LinearSegmentedColormap.from_list('custom_cmap', rgb_colors)
+
+# Define color sequences
+blue_colors = ['#F7FBFF', '#DEEBF7', '#C6DBEF', '#9ECAE1', '#6BAED6', '#4292C6', '#2171B5']
+orange_colors = ['#FFF5EB', '#FEE6CE', '#FDD0A2', '#FDAE6B', '#FD8D3C', '#F16913', '#D94801']
+green_colors = ['#F7FCF5', '#E5F5E0', '#C7E9C0', '#A1D99B', '#74C476', '#41AB5D', '#238B45']
+
+sim_cmap = create_transparent_cmap(blue_colors)  # Blue sequential
+diff_cmap = create_transparent_cmap(orange_colors)  # Peach sequential  
+conflict_cmap = create_transparent_cmap(green_colors)  # Purple sequential

plot_styling.py

@@ -0,0 +1,56 @@
+"""Module for consistent plot styling across all visualizations"""
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+import matplotlib.font_manager as fm
+
+# Add Arial font
+fm.fontManager.addfont('/usr/share/fonts/truetype/msttcorefonts/Arial.ttf')
+
+# Plot styling constants
+PLOT_STYLE = {
+    'font_family': 'Arial',
+    'font_size': 18,
+    'title_size': 20,
+    'label_size': 18,
+    'tick_size': 15,
+    'tick_length': 5,
+    'tick_width': 0.5,
+    'tick_pad': 2,
+    'label_pad_x': -15,
+    'label_pad_y': -35,
+    'figure_dpi': 300,
+    'aspect_ratio': 'equal',
+    'subplot_wspace': 0.05,
+    'subplot_hspace': 0.1
+}
+
+# Color constants
+PLOT_COLORS = {
+    'input_similarity': sns.color_palette('rocket', as_cmap=True),
+    'output_difference': sns.cubehelix_palette(start=.2, rot=-.3, dark=0, light=0.85, 
+                                             reverse=True, as_cmap=True),
+    'conflict': sns.cubehelix_palette(start=2, rot=0, dark=0, light=0.85, 
+                                    reverse=True, as_cmap=True),
+    # Define a cubehelix palette starting dark (dark=0) and ending light purple (light=0.85, start=2.8)
+    'output_biomechanical': sns.cubehelix_palette(start=2.8, rot=0.4, dark=0, light=0.85, 
+                                             reverse=True, as_cmap=True)
+}
+
+
+purple_helix = sns.cubehelix_palette(start=.2, rot=-.4, dark=0, light=0.85, 
+                                             reverse=True, as_cmap=True)
+my_purple_helix = sns.cubehelix_palette(start=.2, rot=-.1, dark=0, light=0.85, 
+                                             reverse=True, as_cmap=True)
+
+def set_plot_style():
+    """Set consistent plot styling across all figures"""
+    plt.rcParams['font.family'] = PLOT_STYLE['font_family']
+    plt.rcParams['font.size'] = PLOT_STYLE['font_size']
+    plt.rcParams['axes.labelsize'] = PLOT_STYLE['label_size']
+    plt.rcParams['axes.titlesize'] = PLOT_STYLE['title_size']
+    plt.rcParams['xtick.labelsize'] = PLOT_STYLE['tick_size']
+    plt.rcParams['ytick.labelsize'] = PLOT_STYLE['tick_size']
+    plt.rcParams['figure.dpi'] = PLOT_STYLE['figure_dpi']
+    plt.rcParams['figure.subplot.wspace'] = PLOT_STYLE['subplot_wspace']
+    plt.rcParams['figure.subplot.hspace'] = PLOT_STYLE['subplot_hspace'] 

requirements.txt

@@ -1,3 +0,0 @@
-altair
-pandas
-streamlit

sensor_illustration.py

@@ -0,0 +1,426 @@
+# %%
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import List
+from dataclasses import dataclass
+from plot_styling import set_plot_style
+
+@dataclass
+class JointPosition:
+    """Stores the position of a joint in the illustration"""
+    name: str
+    x: float
+    y: float
+
+@dataclass
+class Segment:
+    """Stores the segment information connecting two joints"""
+    name: str
+    joint1: str
+    joint2: str
+
+class LegIllustration:
+    def __init__(self, mode: str = "level_walking"):
+        """Initialize the leg illustration with a background image based on the specified mode
+        
+        Args:
+            mode: A string specifying the background mode. Options are:
+                  "level_walking" (default),
+                  "level_walking_line_under", and
+                  "decline_walking".
+        """
+        # Set plot style at initialization
+        set_plot_style()
+        self.mode = mode  # store mode if needed later
+        
+        # Map modes to background images
+        background_images = {
+            "level_walking": "assets/level_ground_no_line_under.png",
+            "level_walking_line_under": "assets/level_ground_line_under.png",
+            "decline_walking": "assets/downhill_line_under.png"
+        }
+        if mode in background_images:
+            self.background_image_path = background_images[mode]
+        else:
+            print(f"Warning: Unknown mode '{mode}'. Defaulting to level_walking.")
+            self.background_image_path = background_images["level_walking"]
+        
+        # Set joint positions based on mode
+        if mode in ["level_walking"]:
+            self.image_vertical_offset = 0.02  # Space at bottom for gait cycle bar
+            self.joints_right = {
+                'hip_r': JointPosition('hip_r', 0.45, 0.825 + self.image_vertical_offset),
+                'knee_r': JointPosition('knee_r', 0.65, 0.46 + self.image_vertical_offset),
+                'ankle_r': JointPosition('ankle_r', 0.77, 0.075 + self.image_vertical_offset),
+                'toe_r': JointPosition('toe_r', 0.92, 0.057 + self.image_vertical_offset),
+            }
+
+            self.joints_left = {
+                'hip_l': JointPosition('hip_l', 0.35, 0.825 + self.image_vertical_offset),
+                'knee_l': JointPosition('knee_l', 0.235, 0.42 + self.image_vertical_offset),
+                'ankle_l': JointPosition('ankle_l', 0.06, 0.12 + self.image_vertical_offset),
+                'toe_l': JointPosition('toe_l', 0.17, 0.03 + self.image_vertical_offset),
+            }
+
+        elif mode == "level_walking_line_under":
+            self.image_vertical_offset = 0.01  # Slightly lower offset for decline walking
+            self.joints_right = {
+                'hip_r': JointPosition('hip_r', 0.48, 0.82 + self.image_vertical_offset),
+                'knee_r': JointPosition('knee_r', 0.62, 0.45 + self.image_vertical_offset),
+                'ankle_r': JointPosition('ankle_r', 0.695, 0.08 + self.image_vertical_offset),
+                'toe_r': JointPosition('toe_r', 0.80, 0.075 + self.image_vertical_offset),
+            }
+
+            self.joints_left = {
+                'hip_l': JointPosition('hip_l', 0.38, 0.82 + self.image_vertical_offset),
+                'knee_l': JointPosition('knee_l', 0.28, 0.39 + self.image_vertical_offset),
+                'ankle_l': JointPosition('ankle_l', 0.18, 0.12 + self.image_vertical_offset),
+                'toe_l': JointPosition('toe_l', 0.26, 0.04 + self.image_vertical_offset),
+            }
+
+        elif mode == "decline_walking":
+            self.image_vertical_offset = 0.01  # Slightly lower offset for decline walking
+            self.joints_right = {
+                'hip_r': JointPosition('hip_r', 0.63, 0.84 + self.image_vertical_offset),
+                'knee_r': JointPosition('knee_r', 0.72, 0.50 + self.image_vertical_offset),
+                'ankle_r': JointPosition('ankle_r', 0.795, 0.14 + self.image_vertical_offset),
+                'toe_r': JointPosition('toe_r', 0.93, 0.115 + self.image_vertical_offset),
+            }
+
+            self.joints_left = {
+                'hip_l': JointPosition('hip_l', 0.53, 0.84 + self.image_vertical_offset),
+                'knee_l': JointPosition('knee_l', 0.48, 0.55 + self.image_vertical_offset),
+                'ankle_l': JointPosition('ankle_l', 0.19, 0.36 + self.image_vertical_offset),
+                'toe_l': JointPosition('toe_l', 0.30, 0.27 + self.image_vertical_offset),
+            }
+        else:
+            # Fallback to level_walking settings for unknown mode values
+            self.image_vertical_offset = 0.09
+            self.joints_right = {
+                'hip_r': JointPosition('hip_r', 0.47, 0.825 + self.image_vertical_offset),
+                'knee_r': JointPosition('knee_r', 0.67, 0.46 + self.image_vertical_offset),
+                'ankle_r': JointPosition('ankle_r', 0.79, 0.075 + self.image_vertical_offset),
+                'toe_r': JointPosition('toe_r', 0.94, 0.057 + self.image_vertical_offset),
+            }
+            self.joints_left = {
+                'hip_l': JointPosition('hip_l', 0.37, 0.825 + self.image_vertical_offset),
+                'knee_l': JointPosition('knee_l', 0.255, 0.42 + self.image_vertical_offset),
+                'ankle_l': JointPosition('ankle_l', 0.08, 0.12 + self.image_vertical_offset),
+                'toe_l': JointPosition('toe_l', 0.19, 0.03 + self.image_vertical_offset),
+            }
+        
+        # Define segments
+        self.segments = [
+            Segment('thigh', 'hip', 'knee'),
+            Segment('shank', 'knee', 'ankle'),
+            Segment('foot', 'ankle', 'toe')
+        ]
+
+        # Add CoP and vGRF parameters
+        self.cop_offset = -0.07  # Offset from foot line
+        self.vgrf_arrow_height = 0.15  # Height of the force arrow
+        self.vgrf_arrow_offset = 0.07  # Horizontal offset from foot
+
+        # Add color mapping for different sensor types
+        self.color_map = {
+            'angle': 'yellow',
+            'velocity': 'blue',
+            'angle_velocity': 'purple',
+            'torque': 'orange'
+        }
+
+    def _get_joint_name(self, base_name: str, joints: dict) -> str:
+        """
+        Helper method to get the correct joint name with suffix 
+        based on the joints dictionary
+        """
+        suffix = '_r' if 'hip_r' in joints else '_l'
+        return f"{base_name}{suffix}"
+
+    def draw_illustration(self, 
+                         highlighted_elements: List[str] = None,
+                         title: str = None,
+                         gait_cycle_sections: List[int] | int = None,
+                         ax: plt.Axes = None,
+                         scale_factor: float = 1.0) -> plt.Figure:
+        """Draw the leg illustration with highlighted elements
+        
+        Args:
+            highlighted_elements: List of elements to highlight
+            title: Title for the figure
+            gait_cycle_sections: List of gait cycle sections to highlight
+            ax: Matplotlib axes to draw on. If None, creates new figure.
+        """
+        # Track whether we created a new figure
+        created_new_figure = False
+        
+        if ax is None:
+            # Use consistent figure size and make background transparent
+            fig = plt.figure(figsize=(3 * scale_factor, 6 * scale_factor), facecolor='none')
+            ax = fig.add_subplot(111)
+            created_new_figure = True
+        else:
+            fig = ax.figure
+        
+        ax.set_facecolor('none')  # Make axis background transparent
+        
+        # Draw leg illustration with adjusted vertical extent
+        # Calculate padding based on scale_factor
+        padding = 0  # 0.001 * scale_factor  # Increased padding
+        try:
+            img = plt.imread(self.background_image_path)
+            
+            # Keep original image positioning to maintain alignment with joint markers
+            ax.imshow(
+                img, 
+                extent=[-padding, 1 + padding,  # expanded x-axis
+                       self.image_vertical_offset - padding*2,  # original y-axis bottom
+                       1 + padding*2 + self.image_vertical_offset]  # expanded y-axis top
+            )  
+            
+            # Only extend the bottom of the axis limits to make room for phase window % if needed
+            bottom_limit = self.image_vertical_offset - padding*2
+            if gait_cycle_sections is not None and (
+                (isinstance(gait_cycle_sections, list) and len(gait_cycle_sections) > 1) or
+                (isinstance(gait_cycle_sections, np.ndarray) and len(gait_cycle_sections) > 1)
+            ):
+                bottom_limit = -0.08  # Lower bottom limit for phase window %
+                
+            # Update the axis limits
+            ax.set_xlim(-padding, 1 + padding)
+            ax.set_ylim(bottom_limit, 1 + padding*2 + self.image_vertical_offset)
+        except Exception as e:
+            print(f"Warning: Could not load background image: {e}")
+            # Also adjust fallback y-limits if loading fails
+            if gait_cycle_sections is not None and (
+                (isinstance(gait_cycle_sections, list) and len(gait_cycle_sections) > 1) or
+                (isinstance(gait_cycle_sections, np.ndarray) and len(gait_cycle_sections) > 1)
+            ):
+                bottom_limit = -0.08
+            else:
+                bottom_limit = -padding*2
+            ax.set_xlim(-padding, 1 + padding)
+            ax.set_ylim(bottom_limit, 1 + padding*2)
+        
+        # Draw legs
+        self._draw_leg(ax, self.joints_right, self.segments,
+                      highlighted_elements, scale_factor)
+        self._draw_leg(ax, self.joints_left, self.segments,
+                      highlighted_elements, scale_factor)
+        
+        if title:
+            ax.set_title(title, pad=20)
+        
+        # Draw phase window % if more than one section is provided
+        if gait_cycle_sections is not None:
+            # Convert to list if int
+            if isinstance(gait_cycle_sections, int):
+                sections = [gait_cycle_sections]
+            else:
+                sections = gait_cycle_sections
+            if len(sections) > 1:
+                self._draw_phase_window_percent(ax, sections, scale_factor)
+        
+        ax.axis('off')
+        
+        # Only apply figure-level settings if we created the figure
+        if created_new_figure:
+            fig.patch.set_alpha(0.0)  # Make figure background transparent
+            fig.tight_layout()
+            return fig
+        return None
+
+    def _draw_phase_window_percent(self, ax, gait_cycle_sections: List[int], scale_factor: float = 1.0):
+        """Draw the phase window percent as a number under the legs"""
+        # The gait cycle is 150 points (0-149)
+        n_sections = len(gait_cycle_sections)
+        if n_sections > 1:
+            percent = n_sections / 150 * 100
+            # Place the text under the legs, centered
+            y_position = -0.04  # Slightly below the image
+            fontsize = 32 * scale_factor
+            ax.text(0.5, y_position, f"Phase window: {percent:.1f}%", ha='center', va='top', fontsize=fontsize, color='black')
+
+    def _determine_highlight_color(self, elements: List[str], location: str) -> str:
+        """
+        Determine highlight color based on the types of sensors present for a specific location
+        
+        Args:
+            elements: List of sensor names to analyze
+            location: The joint or segment name to check (e.g., 'hip', 'thigh')
+            
+        Returns:
+            str: Color name from color_map
+        """
+        if not elements:
+            return 'gray'
+            
+        # Filter elements to only those containing this location
+        location_elements = [e for e in elements if location in e]
+        if not location_elements:
+            return 'gray'
+            
+        has_torque = any('torque' in e for e in location_elements)
+        has_angle = any('angle' in e and 'vel' not in e for e in location_elements)
+        has_velocity = any('vel' in e for e in location_elements)
+        
+        if has_torque:
+            return self.color_map['torque']
+        elif has_angle and has_velocity:
+            return self.color_map['angle_velocity']
+        elif has_velocity:
+            return self.color_map['velocity']
+        elif has_angle:
+            return self.color_map['angle']
+        
+        return 'gray'
+
+    def _draw_leg(self, ax, joints: dict, segments: List[Segment], 
+                  highlighted_elements: List[str],
+                  scale_factor: float = 1.0):
+        """Helper method to draw a single leg with highlights"""
+        suffix = '_r' if 'hip_r' in joints else '_l'
+        
+        # Get all highlighted elements for this leg
+        leg_elements = [e for e in (highlighted_elements or []) 
+                       if e.endswith(suffix)]
+        
+        # Calculate figure-relative sizes
+        fig_width, fig_height = ax.figure.get_size_inches()
+        # Scale marker size. Make it be a 12 marker size on a 3x6 figure
+        joint_size = int(np.sqrt(fig_width * fig_height) / 18 * 12 * 3.1 * scale_factor)
+        # Scale line width. Make it be a 3 line width on a 3x6 figure
+        segment_width = int(np.sqrt(fig_width * fig_height) / 18 * 3 * 3.1 * scale_factor)
+        
+        # joint_size = 12
+        # segment_width = 3
+
+        # Draw segments
+        for segment in segments:
+            # Get the correct joint names with suffixes
+            joint1_name = self._get_joint_name(segment.joint1, joints)
+            joint2_name = self._get_joint_name(segment.joint2, joints)
+            
+            joint1 = joints[joint1_name]
+            joint2 = joints[joint2_name]
+            x = [joint1.x, joint2.x]
+            y = [joint1.y, joint2.y]
+            
+            # Get the segment name with suffix and check if it's highlighted
+            base_segment = segment.name  # 'thigh', 'shank', or 'foot'
+            color = self._determine_highlight_color(leg_elements, base_segment)
+            ax.plot(x, y, '-', color=color, linewidth=segment_width, alpha=0.8)
+        
+        # Draw joints (excluding toe)
+        for joint_name, joint in joints.items():
+            if not joint_name.startswith('toe'):
+                # Check if any sensor for this joint is highlighted
+                base_joint = joint_name.split('_')[0]  # 'hip' from 'hip_r'
+                color = self._determine_highlight_color(leg_elements, base_joint)
+                ax.plot(joint.x, joint.y, 'o', 
+                       color=color if color != 'gray' else 'black', 
+                       markersize=joint_size)
+
+        # Draw CoP and vGRF only if mode doesn't have line under
+        if self.background_image_path.endswith('no_line_under.png'):
+            cop_name = f"cop_y{suffix}"
+            cop_h = highlighted_elements and cop_name in highlighted_elements
+            
+            grf_name = f"grf_y{suffix}"
+            grf_h = highlighted_elements and grf_name in highlighted_elements
+
+            self._draw_cop_and_vgrf(
+                ax, joints, cop_highlighted=cop_h, grf_highlighted=grf_h
+            )
+
+    def _draw_cop_and_vgrf(self, ax, joints, 
+                           cop_highlighted: bool, grf_highlighted: bool):
+        """
+        Draw the center of pressure line and 
+        vertical ground reaction force
+        """
+        ankle_name = self._get_joint_name('ankle', joints)
+        toe_name = self._get_joint_name('toe', joints)
+        ankle = joints[ankle_name]
+        toe = joints[toe_name]
+        
+        # Calculate CoP line parallel to foot
+        dx = toe.x - ankle.x
+        dy = toe.y - ankle.y
+        length = np.sqrt(dx**2 + dy**2)
+        
+        dx_norm = dx / length
+        dy_norm = dy / length
+        
+        # Calculate perpendicular offset for CoP line
+        offset_x = -dy_norm * self.cop_offset
+        offset_y = dx_norm * self.cop_offset
+        
+        # Draw CoP line
+        cop_x = [ankle.x + offset_x, toe.x + offset_x]
+        cop_y = [ankle.y + offset_y, toe.y + offset_y]
+        cop_color = 'red' if cop_highlighted else 'gray'
+        ax.plot(cop_x, cop_y, '--', color=cop_color, linewidth=2, alpha=0.8)
+        
+        # Draw vGRF arrow
+        arrow_x = toe.x + self.vgrf_arrow_offset
+        arrow_base_y = toe.y - 0.02
+        grf_color = 'red' if grf_highlighted else 'gray'
+        ax.arrow(arrow_x, arrow_base_y, 
+                0, self.vgrf_arrow_height,
+                head_width=0.02, 
+                head_length=0.04,
+                fc=grf_color, ec=grf_color,
+                alpha=0.8)
+
+def create_sensor_config_illustrations() -> None:
+    """Create and display multiple sensor configurations with different background modes"""
+    sensor_configs = [
+        {
+            'name': 'Hip Angle Only (Level Walking)',
+            'highlighted_elements': ['hip_angle_s_r', 'grf_y_r'],
+            'gait_cycle_sections': [0],
+            'mode': 'level_walking'
+        },
+        {
+            'name': 'Thigh Angle Only (Level Walking with Line Under)',
+            'highlighted_elements': ['thigh_angle_s_r'],
+            'gait_cycle_sections': [25, 26, 27],
+            'mode': 'level_walking_line_under'
+        },
+        {
+            'name': 'Hip Joint + Thigh Segment (Level Walking)',
+            'highlighted_elements': ['hip_angle_s_r', 'thigh_vel_s_r', 'grf_y_r'],
+            'gait_cycle_sections': [50, 51, 52],
+            'mode': 'level_walking'
+        },
+        {
+            'name': 'Multi Sensor (Decline Walking)',
+            'highlighted_elements': [
+                'hip_angle_s_r',          # Joint sensor
+                'thigh_vel_s_r',          # Segment sensor
+                'knee_torque_s_r',        # Joint sensor
+                'shank_angle_s_r',         # Segment sensor
+                'hip_angle_s_l',
+                'hip_vel_l',
+                'cop_r',
+                'grf_y_r'	
+            ],
+            'gait_cycle_sections': [74, 75, 76],
+            'mode': 'decline_walking'
+        }
+    ]
+    
+    for config in sensor_configs:
+        # Instantiate a new LegIllustration for each sensor config with the specified mode
+        illustrator = LegIllustration(mode=config.get('mode', 'level_walking'))
+        fig = illustrator.draw_illustration(
+            highlighted_elements=config['highlighted_elements'],
+            title=config['name'],
+            gait_cycle_sections=config.get('gait_cycle_sections')
+        )
+        plt.show()
+
+if __name__ == "__main__":
+    create_sensor_config_illustrations() 
+# %%

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))