add v3 pressure meter feature coverage

README.md

@@ -11,10 +11,37 @@ pinned: false
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
 
+## Development Environment Setup
 
-## Dev install virtual environment -- python 3.11.5
-```python -m venv .venv```
-```source .venv/bin/activate```
+### Option 1: Conda Environment (Recommended)
+```bash
+# Create new conda environment with Python 3.11
+conda create -n topshelf python=3.11
+
+# Activate the environment
+conda activate topshelf
+
+# Install PyTorch first (CPU-only version)
+conda install pytorch cpuonly -c pytorch
+
+# Then install other requirements
+pip install -r requirements-cpu.txt  # For CPU-only installation
+# OR
+pip install -r requirements.txt      # For full installation with GPU support
+```
+
+### Option 2: Python Virtual Environment
+```bash
+# Create virtual environment
+python -m venv .venv
+source .venv/bin/activate
+
+# Install PyTorch first (CPU-only version)
+pip install torch --index-url https://download.pytorch.org/whl/cpu
+
+# Then install other requirements
+pip install -r requirements-cpu.txt
+```
 
 ## Update requirements.txt
 There are two requirements.txt files, the requirements-cpu.txt can be used for smaller installations but will only use CPU based 

requirements-cpu.txt

@@ -80,9 +80,6 @@ tenacity==8.5.0
 thinc==8.2.5
 threadpoolctl==3.5.0
 toml==0.10.2
-torch==2.4.1+cpu
-torchaudio==2.4.1+cpu
-torchvision==0.19.1+cpu
 tornado==6.4.1
 tqdm==4.66.5
 typer==0.12.5

src/About.py

@@ -1,20 +0,0 @@
-import streamlit as st
-
-import logging
-
-st.set_page_config(page_title='About TopShelf', layout="wide",
-                   page_icon="🥅")
-
-st.title('Welcome To Top Shelf :goal_net:',
-         help=':video_camera: + :ice_hockey_stick_and_puck: = :clipboard:')
-st.subheader('Artificial Intelligence for Hockey Coaches and Players',
-             help='Proof of concept application')
-
-overview = '''**Top Shelf** helps coaches and players analyze their gameplay, providing helpful suggestions on areas for improvement.
-
-The secret behind **Top Shelf** is *Computer Vision* AI technology that recognizes various hockey related objects in videos. 
-This model can recognize players, nets, referees, rink markings and more. 
-
-**Top Shelf** uses this technology to analyze game play and provide insightful suggestions on areas for improvement. 
-'''
-st.markdown(overview)

src/Home.py

@@ -1,71 +1,4 @@
 import streamlit as st
-from ultralytics import YOLO
-from huggingface_hub import hf_hub_download
-import cv2
-import numpy as np
-
-import logging
-
-@st.cache_resource
-def get_model():
-    repo_id = "danbiagini/hockey_breeds_v2"
-    return hf_hub_download(repo_id=repo_id, filename="hockey_breeds-v2-101623.pt")
-
-
-def run_inference(img, model, thresh=0.5):
-    model = YOLO(model_f)
-    st.session_state.results = model(img)
-    return draw_hockey_boxes(img, st.session_state.results, thresh)
-
-
-def draw_hockey_boxes(frame, results, thresh=0.5):
-    colors = {0: (0, 255, 0), 1: (255, 0, 0), 2: (0, 0, 255), 3: (128, 0, 0), 4: (
-        0, 128, 0), 5: (0, 0, 128), 6: (0, 64, 0), 7: (64, 0, 0), 8: (0, 0, 64)}
-    font_scale = frame.shape[0] / 500
-    objects = []
-
-    for name in results:
-        for box in name.boxes.data.tolist():
-            x1, y1, x2, y2, score, class_id = box
-            objects.append((name.names[int(class_id)], score))
-
-            if score > thresh:
-                cv2.rectangle(frame, (int(x1), int(y1)),
-                              (int(x2), int(y2)), colors[(class_id % 9)], 3)
-                cv2.putText(frame, f'{name.names[int(class_id)].upper()}: {score:.2f}', (int(x1), int(y1 - 10)),
-                  cv2.FONT_HERSHEY_SIMPLEX, font_scale, colors[(class_id % 9)], 3, cv2.LINE_AA)
-            else:
-                print(
-                    f'Found an object under confidence threshold {thresh} type: {name.names[class_id]}, score:{score}, x1, y2:{x1}, {y2}')
-    return objects
-
-def reset_image():
-    st.session_state.img = None
-
-def upload_img():
-    if st.session_state.upload_img is not None:
-        st.session_state.img = st.session_state.upload_img
-
-def get_naked_image():
-    if st.session_state.img is not None:
-        img = st.session_state.img
-        img.seek(0)
-        return(cv2.imdecode(np.frombuffer(img.read(), np.uint8), 1))
-    return None
-
-def use_sample_image():
-    st.session_state.img = open('src/images/samples/v2/net-chaos.jpg', 'rb')
-
-# Init state
-if 'results' not in st.session_state:
-    st.session_state.results = []
-
-if 'thresh' not in st.session_state:
-    st.session_state.thresh = 0.5
-
-if 'img' not in st.session_state:
-    st.session_state.img = None
-
 
 st.set_page_config(page_title='TopShelf POC', layout="wide",
                    page_icon="🥅")
@@ -75,56 +8,21 @@ st.title('Welcome To Top Shelf :goal_net:',
 st.subheader('Artificial Intelligence for Hockey Coaches and Players',
              help='Proof of concept application')
 
-overview = '''**Top Shelf** helps coaches and players analyze their gameplay, providing helpful suggestions & recommendations on areas for improvement.  
+overview = '''**Top Shelf** helps coaches and players analyze their gameplay using Machine Learning, providing helpful suggestions & recommendations on areas for improvement.  
 
 We're starting with a focus on ice hockey, however this same technology could apply to other "invasion" games and sports, for example lacrosse, basketball, soccer, etc.
 
-The special sauce behind **Top Shelf** is AI *Computer Vision*  technology that recognizes various hockey related objects in videos. 
-The foundation of the technology is an AI model that can recognize players, nets, referees, pucks, and rink areas. 
+The special sauce behind **Top Shelf** AI is *Computer Vision* and *Machine Learning* technology that tracks various hockey game objects in videos, determines player team memberships and measures game dynamics. 
 
 **Top Shelf** uses this technology to analyze game play and provide insightful suggestions on areas for improvement. 
 '''
 st.markdown(overview)
 
-st.subheader('Getting Started')
-st.markdown('''We're currently in the training and testing phase of **Top Shelf** development.  This is a proof of concept application that friends of **Top Shelf** can use to help in development. 
-To help us understand how our *Computer Vision* model is working you can upload hockey pictures and then the app will display what hockey objects were found. ''')
-
-st.write("Upload an image file to try detecting hockey objects in your own hockey image, or use a sample image below.")
-
-
-if st.session_state.img is None:
-    st.file_uploader("Upload an image and Hockey Breeds v2 will find the hockey objects in the image",
-            type=["jpg", "jpeg", "png"], key='upload_img', on_change=upload_img)
-
-    with st.expander("Sample Images"):
-        st.image('src/images/samples/v2/net-chaos.jpg')
-        st.button("Use Sample", on_click=use_sample_image)
-
-img = get_naked_image()
-if img is not None:
-
-    thresh = st.slider('Set the object confidence threshold', key='thresh',
-                  min_value=0.0, max_value=1.0, value=0.5, step=0.05)
-
-    with st.status("Detecting hockey objects..."):
-        st.write("Loading model...")
-        model_f = get_model()
+st.subheader('Hockey Pressure Meter')
 
-        st.write("Running inference on image...")
-        objects = run_inference(img, model_f, thresh)
-        
-        st.dataframe(objects, column_config={
-                "0": "Object",
-                "1": "Confidence"
-        })
+st.markdown('''The Hockey Pressure Meter is a visualization of the Top Shelf ML pipeline which uses the location and team membership of each player on the ice to calculate the pressure applied by each team during the course of the game.
 
-    # check if the results list is empty
-    if len(st.session_state.results) == 0:
-        st.write('**No hockey objects found in image!**')
-        st.image(img, caption='Uploaded Image had no hockey objects')
-    else:
-        st.image(img, caption='Image with hockey object bounding boxes')
+''')
 
-    st.button("Reset Image", on_click=reset_image)
+st.image('src/images/samples/v3/pressure_meter.png')
 

src/app.py

@@ -3,9 +3,9 @@ import streamlit as st
 import logging
 
 app = st.navigation(
-    {"App": [st.Page("Home.py", title="Home", icon=":material/home:"),
-             st.Page("About.py", icon="🥅")],
+    {"App": [st.Page("Home.py", title="Home", icon=":material/home:")],
      "Models": [
+                st.Page("pressure_meter.py", title="v3 - Pressure Meter", icon=":material/filter_b_and_w:"),
                 st.Page("hockey_object_detection.py", title="v2 - Hockey Object Detection", icon=":material/filter_b_and_w:"),
                 st.Page("Hockey_Breeds.py", title="v1 - Hockey Breeds", icon=":material/gradient:")
                 ]

src/hockey_object_detection.py

@@ -1,4 +1,71 @@
 import streamlit as st
+from ultralytics import YOLO
+from huggingface_hub import hf_hub_download
+import cv2
+import numpy as np
+
+import logging
+
+@st.cache_resource
+def get_model():
+    repo_id = "danbiagini/hockey_breeds_v2"
+    return hf_hub_download(repo_id=repo_id, filename="hockey_breeds-v2-101623.pt")
+
+
+def run_inference(img, model, thresh=0.5):
+    model = YOLO(model_f)
+    st.session_state.results = model(img)
+    return draw_hockey_boxes(img, st.session_state.results, thresh)
+
+
+def draw_hockey_boxes(frame, results, thresh=0.5):
+    colors = {0: (0, 255, 0), 1: (255, 0, 0), 2: (0, 0, 255), 3: (128, 0, 0), 4: (
+        0, 128, 0), 5: (0, 0, 128), 6: (0, 64, 0), 7: (64, 0, 0), 8: (0, 0, 64)}
+    font_scale = frame.shape[0] / 500
+    objects = []
+
+    for name in results:
+        for box in name.boxes.data.tolist():
+            x1, y1, x2, y2, score, class_id = box
+            objects.append((name.names[int(class_id)], score))
+
+            if score > thresh:
+                cv2.rectangle(frame, (int(x1), int(y1)),
+                              (int(x2), int(y2)), colors[(class_id % 9)], 3)
+                cv2.putText(frame, f'{name.names[int(class_id)].upper()}: {score:.2f}', (int(x1), int(y1 - 10)),
+                  cv2.FONT_HERSHEY_SIMPLEX, font_scale, colors[(class_id % 9)], 3, cv2.LINE_AA)
+            else:
+                print(
+                    f'Found an object under confidence threshold {thresh} type: {name.names[class_id]}, score:{score}, x1, y2:{x1}, {y2}')
+    return objects
+
+def reset_image():
+    st.session_state.img = None
+
+def upload_img():
+    if st.session_state.upload_img is not None:
+        st.session_state.img = st.session_state.upload_img
+
+def get_naked_image():
+    if st.session_state.img is not None:
+        img = st.session_state.img
+        img.seek(0)
+        return(cv2.imdecode(np.frombuffer(img.read(), np.uint8), 1))
+    return None
+
+def use_sample_image():
+    st.session_state.img = open('src/images/samples/v2/net-chaos.jpg', 'rb')
+
+# Init state
+if 'results' not in st.session_state:
+    st.session_state.results = []
+
+if 'thresh' not in st.session_state:
+    st.session_state.thresh = 0.5
+
+if 'img' not in st.session_state:
+    st.session_state.img = None
+
 
 # Top down page rendering 
 st.set_page_config(page_title='Hockey Breeds v2 - Objects', layout="wide",
@@ -10,11 +77,54 @@ with the ability to recognize individual "objects" within an image, which paves
 
 st.markdown(intro)
 
+st.subheader('Try Hockey Breeds v2')
+st.markdown('''To help us understand how our *Computer Vision* model is working you can upload hockey pictures and then the app will display what hockey objects were found. ''')
+
+st.write("Upload an image file to try detecting hockey objects in your own hockey image, or use a sample image below.")
+
+
+if st.session_state.img is None:
+    st.file_uploader("Upload an image and Hockey Breeds v2 will find the hockey objects in the image",
+            type=["jpg", "jpeg", "png"], key='upload_img', on_change=upload_img)
+
+    with st.expander("Sample Images"):
+        st.image('src/images/samples/v2/net-chaos.jpg')
+        st.button("Use Sample", on_click=use_sample_image)
+
+img = get_naked_image()
+if img is not None:
+
+    thresh = st.slider('Set the object confidence threshold', key='thresh',
+                  min_value=0.0, max_value=1.0, value=0.5, step=0.05)
+
+    with st.status("Detecting hockey objects..."):
+        st.write("Loading model...")
+        model_f = get_model()
+
+        st.write("Running inference on image...")
+        objects = run_inference(img, model_f, thresh)
+        
+        st.dataframe(objects, column_config={
+                "0": "Object",
+                "1": "Confidence"
+        })
+
+    # check if the results list is empty
+    if len(st.session_state.results) == 0:
+        st.write('**No hockey objects found in image!**')
+        st.image(img, caption='Uploaded Image had no hockey objects')
+    else:
+        st.image(img, caption='Image with hockey object bounding boxes')
+
+    st.button("Reset Image", on_click=reset_image)
+
+
+
 st.subheader('Object Detection Technical Details')
 
 desc = '''Hockey Breed detector v2 uses a state of the art (circa 2023) computer vision approach.
 
-I used the same training images as the first version of the Hockey Breeds model, but change the ML algorithm to use YOLO object detection (YOLO v8).
+I used the same training images as the first version of the Hockey Breeds model, but change the Neural Network to use YOLO object detection (YOLO v8).
 The output will be a set of hockey objects (defined by "bounding boxes") with labels for any hockey image uploaded.
 
 **Object List**:
@@ -29,8 +139,12 @@ The output will be a set of hockey objects (defined by "bounding boxes") with la
 st.markdown(desc)
 
 st.subheader("Sample")
-st.image('src/images/samples/v2/v2-sample1-090124.png',
+
+try:
+    st.image('src/images/samples/v2/v2-sample1-090124.png',
          caption='Sample image with hockey objects detected')
+except Exception as e:
+    st.error(f"Error loading image: {e}")
 
 st.subheader("Validation Results")
 

src/pressure_meter.py

@@ -0,0 +1,269 @@
+from datetime import datetime
+import json
+import os
+import streamlit as st
+import requests
+import pandas as pd
+from io import StringIO
+import plotly.graph_objects as go
+
+# Top down page rendering 
+st.set_page_config(page_title='Hockey Breeds v3 - Pressure Meter', layout="wide",
+                   page_icon=":frame_with_picture:")
+
+st.title('Hockey Breeds v3 - Pressure Meter')
+intro = '''Version 3 of Hockey Breeds introduces a new feature: the **Pressure Meter**.  Pressure is a term used in hockey to describe the buildup of offensive momuntum  which often leads to goals.
+
+The **Pressure Meter** builds on a number of major enhancements to the Top-Shelf AI platform:
+1. Improved and expanded data set and improved model
+1. Parallelized processing pipeline for processing input video and generating output metrics in *real time*
+1. Analysis and metrics include:
+    * Team jersey color determination
+    * Player team assignments
+    * Skater speeds and accelerations
+    * Player positions relative to nearest goalie & net
+    * Improved puck tracking and interpolation
+    * Game play state analysis (stoppage vs live play)
+'''
+st.markdown(intro)
+
+st.subheader('Pressure Meter Visualization')
+
+# get  the data file location   
+data_location = st.text_input('Enter the location of the stream analytics metadata file', 
+                              value='https://storage.googleapis.com/topshelf-clients/pressure-meter/2025-02-09/22809/stream_metadata.json')
+metadata = None
+stream_base_url = None
+if data_location:
+    # should be an http link
+    if not data_location.startswith('http'):
+        st.error('Data location must be an http link')
+    else:
+        # download the data from the link
+        if data_location.endswith('/'):
+            data_location = data_location + 'stream_metadata.json'
+        data = requests.get(data_location)
+        # load the data from the json file
+        metadata = json.loads(data.text)
+
+        # determine the base url for the stream
+        stream_base_url = data_location.split('stream_metadata.json')[0]
+
+
+# load the data from the csv files
+if metadata:
+    # get the data from the csv files
+    files = metadata['output_files']
+
+    # get the base timestamp for the stream
+    base_timestamp = datetime.fromisoformat(metadata['video_start_time'])
+
+    # Create an empty list to store individual dataframes
+    dfs = []
+    
+    for ts, file in files.items():
+        try:
+            response = requests.get(stream_base_url + file)
+            response.raise_for_status()
+            
+            data_string = StringIO(response.text)
+            df = pd.read_csv(data_string)
+            
+            ts_delta = datetime.fromtimestamp(int(ts)).astimezone(base_timestamp.tzinfo) - base_timestamp
+            df['second_offset'] = df['second_offset'] + ts_delta.total_seconds()
+            
+            dfs.append(df)
+            
+        except Exception as e:
+            st.error(f"Failed to load data for timestamp {ts}, file: {file}")
+            st.error(f"Error: {str(e)}")
+            continue
+    
+    # Log the number of files processed
+    st.info(f"Successfully loaded {len(dfs)} out of {len(files)} files")
+    
+    # Concatenate all dataframes and sort by the second_offset
+    combined_df = pd.concat(dfs, ignore_index=True)
+    combined_df = combined_df.sort_values('second_offset')
+    
+    # Check for gaps in the sequence
+    expected_range = set(range(int(combined_df['second_offset'].min()), 
+                             int(combined_df['second_offset'].max()) + 1))
+    actual_range = set(combined_df['second_offset'].astype(int))
+    missing_seconds = sorted(expected_range - actual_range)
+    
+    if missing_seconds:
+        st.warning("Found gaps in the data sequence:")
+        # Group consecutive missing seconds into ranges for cleaner output
+        gaps = []
+        start = missing_seconds[0]
+        prev = start
+        for curr in missing_seconds[1:] + [None]:
+            if curr != prev + 1:
+                if start == prev:
+                    gaps.append(f"{start}")
+                else:
+                    gaps.append(f"{start}-{prev}")
+                start = curr
+            prev = curr
+        
+        st.warning(f"Missing seconds: {', '.join(gaps)}")
+
+    # Calculate cumulative counts and ratios - only count actual pressure values
+    combined_df['team1_cumulative'] = (combined_df['pressure_balance'] > 0).astype(int).cumsum()
+    combined_df['team2_cumulative'] = (combined_df['pressure_balance'] < 0).astype(int).cumsum()
+    combined_df['total_cumulative'] = combined_df['team1_cumulative'] + combined_df['team2_cumulative']
+    
+    # Avoid division by zero by using where
+    combined_df['team1_pressure_ratio'] = (combined_df['team1_cumulative'] / 
+                                         combined_df['total_cumulative'].where(combined_df['total_cumulative'] > 0, 1))
+    combined_df['team2_pressure_ratio'] = (combined_df['team2_cumulative'] / 
+                                         combined_df['total_cumulative'].where(combined_df['total_cumulative'] > 0, 1))
+    
+    # Calculate the ratio difference for the balance visualization
+    combined_df['pressure_ratio_diff'] = combined_df['team1_pressure_ratio'] - combined_df['team2_pressure_ratio']
+
+    # Add pressure balance visualization using the ratio difference
+    st.subheader("Pressure Waves")
+    balance_df = pd.DataFrame({
+        'second_offset': combined_df['second_offset'],
+        'pressure_ratio_diff': combined_df['pressure_ratio_diff']
+    })
+    
+    # Get team colors from metadata and parse them
+    def parse_rgb(color_str):
+        # Extract numbers from format 'rgb(r,g,b)'
+        r, g, b = map(int, color_str.strip('rgb()').split(','))
+        return r, g, b
+
+    team1_color = metadata.get('team1_color', 'rgb(54, 162, 235)')  # default blue if not found
+    team2_color = metadata.get('team2_color', 'rgb(255, 99, 132)')  # default red if not found
+    
+    # Parse RGB values
+    team1_rgb = parse_rgb(team1_color)
+    team2_rgb = parse_rgb(team2_color)
+    
+    fig = go.Figure()
+    
+    # Add positive values with team1 color
+    fig.add_trace(
+        go.Scatter(
+            x=combined_df['second_offset'],
+            y=combined_df['pressure_ratio_diff'].clip(lower=0),
+            fill='tozeroy',
+            fillcolor=f'rgba{(*team1_rgb, 0.2)}',
+            line=dict(
+                color=team1_color,
+                shape='hv'
+            ),
+            name='Team 1 Dominant',
+            hovertemplate='Time: %{x:.1f}s<br>Dominance: %{y:.2f}<br>Team 1<extra></extra>',
+            hoveron='points+fills'
+        )
+    )
+    
+    # Add negative values with team2 color
+    fig.add_trace(
+        go.Scatter(
+            x=combined_df['second_offset'],
+            y=combined_df['pressure_ratio_diff'].clip(upper=0),
+            fill='tozeroy',
+            fillcolor=f'rgba{(*team2_rgb, 0.2)}',
+            line=dict(
+                color=team2_color,
+                shape='hv'
+            ),
+            name='Team 2 Dominant',
+            hovertemplate='Time: %{x:.1f}s<br>Dominance: %{y:.2f}<br>Team 2<extra></extra>',
+            hoveron='points+fills'
+        )
+    )
+
+    fig.update_layout(
+        yaxis=dict(
+            range=[-1, 1],
+            zeroline=True,
+            zerolinewidth=2,
+            zerolinecolor='rgba(0,0,0,0.2)',
+            gridcolor='rgba(0,0,0,0.1)',
+            title='Team Dominance'
+        ),
+        xaxis=dict(
+            title='Time (seconds)',
+            gridcolor='rgba(0,0,0,0.1)'
+        ),
+        plot_bgcolor='white',
+        height=400,
+        margin=dict(l=0, r=0, t=20, b=0),
+        showlegend=True,
+        legend=dict(
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=0.01
+        )
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    with st.expander("Pressure Data"):
+        st.write(combined_df)
+
+    # add details in a sub section with expander
+    with st.expander("Pressure Meter Details"):
+        st.write("""
+        The Pressure Meter is a visualization of the pressure waves in the game.  It is a line chart of the cumulative pressure counts for each team over time.
+        """)
+
+        # Create two columns for charts
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Cumulative Pressure Counts")
+            st.line_chart(combined_df, x='second_offset', y=['team1_cumulative', 'team2_cumulative'])
+        
+        with col2:
+            st.subheader("Pressure Ratio Over Time")
+            st.area_chart(combined_df, 
+                        x='second_offset', 
+                        y=['team1_pressure_ratio', 'team2_pressure_ratio'])
+
+
+        # Show current dominance percentage
+        current_ratio = combined_df.iloc[-1]['pressure_balance']
+        if current_ratio > 0:
+            dominant_team = 'Team 1'
+            pressure_value = current_ratio
+        elif current_ratio < 0:
+            dominant_team = 'Team 2'
+            pressure_value = abs(current_ratio)
+        else:
+            dominant_team = 'Neutral'
+            pressure_value = 0
+
+        st.metric(
+            label="Dominant Team Pressure", 
+            value=f"{dominant_team}",
+            delta=f"{pressure_value*100:.1f}%"
+        )
+
+    # After loading metadata
+    st.subheader("Data Files Analysis")
+    
+    # Analyze the timestamps in the metadata
+    timestamps = sorted([int(ts) for ts in files.keys()])
+    time_diffs = [timestamps[i+1] - timestamps[i] for i in range(len(timestamps)-1)]
+    
+    st.info(f"Number of data files: {len(files)}")
+    st.info(f"Time range: {datetime.fromtimestamp(timestamps[0])} to {datetime.fromtimestamp(timestamps[-1])}")
+    st.info(f"Time differences between files: {set(time_diffs)} seconds")
+    
+    # Show the actual files and timestamps
+    with st.expander("Stream Metadata Details"):
+        st.write(metadata)
+        # Log the data range
+        st.write(f"Data range: {combined_df['second_offset'].min():.1f}s to {combined_df['second_offset'].max():.1f}s")
+        st.write(f"Total rows: {len(combined_df)}")
+
+        for ts in sorted(files.keys()):
+            st.text(f"Timestamp: {datetime.fromtimestamp(int(ts))} - File: {files[ts]}")