Rytterne Backyard 2025

from tcxreader.tcxreader import TCXReader, TCXExercise
import pandas as pd
import numpy as np

fil = 'Peter_Edström_2025-05-03_09-58-30.TCX' # filen från flow.polar.com

tcx_reader = TCXReader()

data: TCXExercise = tcx_reader.read(fil)

data.start_time, data.end_time
# (datetime.datetime(2025, 5, 3, 7, 58, 31, 673000),
# datetime.datetime(2025, 5, 3, 11, 14, 52, 673000))

len(data.trackpoints)
# 11758

tp = data.trackpoints[150]
tp.time, tp.distance, tp.hr_value, tp.latitude, tp.longitude, tp.tpx_ext

# (datetime.datetime(2025, 5, 3, 8, 1, 1, 673000),
# 150.9854736328125,
# 136,
# 59.49238718,
# 16.34682158,
# {})

def localize_time(t):
    t = pd.to_datetime(t)
    if t.tzinfo is None:
        t = t.tz_localize("UTC")
    return t.tz_convert("Europe/Stockholm").tz_localize(None)

df = pd.DataFrame([{
    "time": localize_time(tp.time),
    "distance": tp.distance,
    "hr_value": tp.hr_value,
    # "latitude": tp.latitude,  # jag behöver inte gps-koordinaterna men
    # "longitude": tp.longitude # vill visa att de finns här
} for tp in data.trackpoints])

# Runda av tiden till sekund
df["time"] = df["time"].dt.floor("s")

# Sortera time-kolumnen
df = df.sort_values("time").reset_index(drop=True)

# Beräkna tidsskillnad i sekunder mellan varje punkt
df["delta_time"] = df["time"].diff().dt.total_seconds()

# Beräkna distansskillnad i meter mellan varje punkt
df["delta_dist"] = df["distance"].diff()

# Beräkna tempo i min/km
df["tempo"] = (df["delta_time"] / (df["delta_dist"] / 1000)) / 60

# Beräkna hastighet i km/h
df["speed_kmh"] = (df["delta_dist"] / df["delta_time"]) * 3.6

# Ta bort tillfälliga kolumner
df.drop(columns=['delta_time', 'delta_dist'], inplace=True)

# Passa på och sätt time som indexkolumn
df.set_index('time', inplace=True)

df.loc['2025-05-03 10:15':]

df['varv'] = 0
df['varvdistans'] = 0.0

starttid0 = pd.to_datetime('2025-05-03 10:00:00')

# Fixa tre varv
for i in range(0,3):
    # Ta reda på när varvet slutade och sätt varv till varvnummer för alla
    # datapunkter från från starttid till då.
    # Räkna även ut relativ distans

    starttid = starttid0 + pd.Timedelta(hours=i)

    startdistans = df.loc[starttid,'distance']
    index = df.loc[
        ( df['distance'] > startdistans + 6700 ) & ( df['speed_kmh'] < 1 )
    ].index[0]
    
    # Skriv varv
    df.loc[starttid:index, 'varv'] = 1 + i

    # Skriv relativ distans
    df.loc[starttid:index, 'varvdistans'] = df.loc[
        starttid:index, 'distance'] - startdistans

df.loc[df['varv'] == 2]

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))

for varv in range(1, 4):  # Varv 1 till 3
    df_varv = df[df['varv'] == varv].sort_values(by='varvdistans')
    plt.plot(
        df_varv['varvdistans'],
        df_varv['hr_value'],
        label=f'Varv {varv}'
    )

plt.xlabel('Relativ distans (m)')
plt.ylabel('HR (bpm)')
plt.title('Jämförelse puls mellan varv 1–3')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.savefig("rytterne-backyard-2025-puls.png", dpi=300, bbox_inches="tight")

plt.figure(figsize=(12, 6))

for varv in range(1, 4):  # Varv 1 till 3
    # Jag kör ett glidande medelvärde (se nedan) för att minska hackigheten
    # men fular till det lite på varv 3 eftersom det är extra hackigt...
    win = 75 if varv == 4 else 20
    df_varv = df[df['varv'] == varv].sort_values(by='varvdistans')
    plt.plot(
        df_varv['varvdistans'],
        # Här kommer det glidande medelvärdet...
        df_varv['tempo'].rolling(window=win).mean(),
        label=f'Varv {varv}',
        linewidth=0.9
    )

plt.xlabel('Relativ distans (m)')
plt.ylabel('Tempo [min/km]')
plt.title('Jämförelse tempo mellan varv 1–3')
plt.legend()
plt.ylim(17, 4)
plt.grid(True)
plt.tight_layout()
plt.savefig("rytterne-backyard-2025-tempo.png", dpi=150, bbox_inches="tight")

# Glidande medelvärden
df["tempo_smooth"] = df["tempo"].rolling(window=10, center=True).mean()
df["hr_smooth"] = df["hr_value"].rolling(window=10, center=True).mean()

# Plotta för varje varv
for varv in sorted(df["varv"].unique()):
    if varv == 0:
        continue

    df_varv = df[df["varv"] == varv]

    # Filtrera bort orimliga värden
    mask = (
        df_varv["tempo_smooth"].notna() &
        df_varv["hr_smooth"].notna() &
        (df_varv["tempo_smooth"] < 40) &
        (df_varv["tempo_smooth"] > 3)
    )
    df_clean = df_varv[mask]

    x = df_clean["tempo_smooth"]
    y = df_clean["hr_smooth"]

    # Median är trevligare än medelvärde
    median_tempo = x.median()
    median_hr = y.median()

    # Plotta lite
    plt.figure(figsize=(8, 5))
    plt.scatter(x, y, alpha=0.4, s=10, color="#deb3ff", label="Data")
    plt.scatter(median_tempo, median_hr, color="black", marker="x", s=100, label="Median")

    # Lägg till textetiketter för medianvärden
    label = f"{median_tempo:.1f} min/km\n {median_hr:.0f} bpm"
    plt.text(median_tempo + 0.2, median_hr - 1.5, label, fontsize=10, color="black", ha="left")
    
    plt.xlabel("Tempo (min/km)")
    plt.ylabel("Puls (bpm)")
    plt.title(f"Varv {varv}: Puls mot Tempo")
    plt.legend()
    plt.grid(True)
    plt.ylim(110, 180)
    plt.xlim(5, 15)
    plt.tight_layout()
    plt.savefig(f"rytterne-backyard-2025-scatter-varv{varv:.0f}.png", dpi=150, bbox_inches="tight")