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]}")