286 lines
9.0 KiB
Python
Executable File
286 lines
9.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
TCX Parser - Extraherar träningsdata från TCX-filer
|
|
Skapar kompakt JSON-sammanfattning för analys
|
|
|
|
Användning:
|
|
python3 parse_tcx.py <tcx-fil>
|
|
python3 parse_tcx.py Data/training/activity_12345.tcx
|
|
|
|
Output:
|
|
Skapar <tcx-fil>.json med sammanfattad data
|
|
"""
|
|
|
|
import xml.etree.ElementTree as ET
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
|
|
|
|
# Namespace definitions för TCX
|
|
NAMESPACES = {
|
|
'tcx': 'http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2',
|
|
'ns3': 'http://www.garmin.com/xmlschemas/ActivityExtension/v2'
|
|
}
|
|
|
|
|
|
def parse_tcx_file(tcx_path):
|
|
"""Parsar TCX-fil och extraherar all relevant data"""
|
|
|
|
tree = ET.parse(tcx_path)
|
|
root = tree.getroot()
|
|
|
|
# Hitta aktiviteten
|
|
activity = root.find('.//tcx:Activity', NAMESPACES)
|
|
if activity is None:
|
|
raise ValueError("Ingen aktivitet hittades i TCX-filen")
|
|
|
|
# Grundläggande info
|
|
sport = activity.get('Sport', 'Unknown')
|
|
activity_id = activity.find('tcx:Id', NAMESPACES).text
|
|
|
|
# Samla data från varv
|
|
laps = activity.findall('.//tcx:Lap', NAMESPACES)
|
|
lap_data = []
|
|
total_time = 0
|
|
total_distance = 0
|
|
total_calories = 0
|
|
max_speed = 0
|
|
|
|
for i, lap in enumerate(laps, 1):
|
|
lap_info = {
|
|
'number': i,
|
|
'start_time': lap.get('StartTime'),
|
|
}
|
|
|
|
# Extrahera varvdata
|
|
time_elem = lap.find('tcx:TotalTimeSeconds', NAMESPACES)
|
|
dist_elem = lap.find('tcx:DistanceMeters', NAMESPACES)
|
|
cal_elem = lap.find('tcx:Calories', NAMESPACES)
|
|
max_speed_elem = lap.find('tcx:MaximumSpeed', NAMESPACES)
|
|
avg_hr_elem = lap.find('.//tcx:AverageHeartRateBpm/tcx:Value', NAMESPACES)
|
|
max_hr_elem = lap.find('.//tcx:MaximumHeartRateBpm/tcx:Value', NAMESPACES)
|
|
avg_cad_elem = lap.find('tcx:Cadence', NAMESPACES)
|
|
|
|
if time_elem is not None:
|
|
lap_time = float(time_elem.text)
|
|
lap_info['time_seconds'] = lap_time
|
|
total_time += lap_time
|
|
|
|
if dist_elem is not None:
|
|
lap_dist = float(dist_elem.text)
|
|
lap_info['distance_meters'] = lap_dist
|
|
total_distance += lap_dist
|
|
|
|
if cal_elem is not None:
|
|
lap_cal = int(cal_elem.text)
|
|
lap_info['calories'] = lap_cal
|
|
total_calories += lap_cal
|
|
|
|
if max_speed_elem is not None:
|
|
lap_max_speed = float(max_speed_elem.text)
|
|
lap_info['max_speed_ms'] = lap_max_speed
|
|
max_speed = max(max_speed, lap_max_speed)
|
|
|
|
if avg_hr_elem is not None:
|
|
lap_info['avg_hr'] = int(avg_hr_elem.text)
|
|
if max_hr_elem is not None:
|
|
lap_info['max_hr'] = int(max_hr_elem.text)
|
|
if avg_cad_elem is not None:
|
|
lap_info['avg_cadence'] = int(avg_cad_elem.text)
|
|
|
|
lap_data.append(lap_info)
|
|
|
|
# Samla data från trackpoints
|
|
trackpoints = root.findall('.//tcx:Trackpoint', NAMESPACES)
|
|
|
|
hr_data = []
|
|
power_data = []
|
|
cadence_data = []
|
|
altitude_data = []
|
|
speed_data = []
|
|
|
|
for tp in trackpoints:
|
|
# Puls
|
|
hr_elem = tp.find('.//tcx:HeartRateBpm/tcx:Value', NAMESPACES)
|
|
if hr_elem is not None:
|
|
hr_data.append(int(hr_elem.text))
|
|
|
|
# Effekt
|
|
power_elem = tp.find('.//ns3:Watts', NAMESPACES)
|
|
if power_elem is not None:
|
|
power_data.append(int(power_elem.text))
|
|
|
|
# Kadans
|
|
cad_elem = tp.find('tcx:Cadence', NAMESPACES)
|
|
if cad_elem is not None:
|
|
cadence_data.append(int(cad_elem.text))
|
|
|
|
# Höjd
|
|
alt_elem = tp.find('tcx:AltitudeMeters', NAMESPACES)
|
|
if alt_elem is not None:
|
|
altitude_data.append(float(alt_elem.text))
|
|
|
|
# Hastighet
|
|
speed_elem = tp.find('.//ns3:Speed', NAMESPACES)
|
|
if speed_elem is not None:
|
|
speed_data.append(float(speed_elem.text))
|
|
|
|
# Beräkna pulsstatistik och zoner
|
|
hr_stats = None
|
|
hr_zones = None
|
|
|
|
if hr_data:
|
|
avg_hr = sum(hr_data) / len(hr_data)
|
|
min_hr = min(hr_data)
|
|
max_hr = max(hr_data)
|
|
|
|
# Pulszoner (baserat på 5-zonssystem)
|
|
# Kan justeras baserat på individuell maxpuls
|
|
zone1 = sum(1 for hr in hr_data if hr < 110)
|
|
zone2 = sum(1 for hr in hr_data if 110 <= hr < 129)
|
|
zone3 = sum(1 for hr in hr_data if 129 <= hr < 147)
|
|
zone4 = sum(1 for hr in hr_data if 147 <= hr < 166)
|
|
zone5 = sum(1 for hr in hr_data if hr >= 166)
|
|
total_points = len(hr_data)
|
|
|
|
hr_stats = {
|
|
'avg': round(avg_hr, 1),
|
|
'min': min_hr,
|
|
'max': max_hr,
|
|
}
|
|
|
|
hr_zones = {
|
|
'zone1_pct': round(zone1 / total_points * 100, 1),
|
|
'zone2_pct': round(zone2 / total_points * 100, 1),
|
|
'zone3_pct': round(zone3 / total_points * 100, 1),
|
|
'zone4_pct': round(zone4 / total_points * 100, 1),
|
|
'zone5_pct': round(zone5 / total_points * 100, 1),
|
|
'note': 'Zoner baserade på: Z1<110, Z2:110-129, Z3:129-147, Z4:147-166, Z5>166 bpm'
|
|
}
|
|
|
|
# Beräkna effektstatistik
|
|
power_stats = None
|
|
if power_data:
|
|
power_stats = {
|
|
'avg': round(sum(power_data) / len(power_data), 1),
|
|
'min': min(power_data),
|
|
'max': max(power_data),
|
|
}
|
|
|
|
# Beräkna kadansstatistik
|
|
cadence_stats = None
|
|
if cadence_data:
|
|
cadence_stats = {
|
|
'avg': round(sum(cadence_data) / len(cadence_data), 1),
|
|
'min': min(cadence_data),
|
|
'max': max(cadence_data),
|
|
}
|
|
|
|
# Beräkna höjdstatistik
|
|
altitude_stats = None
|
|
if altitude_data:
|
|
elevation_gain = 0
|
|
for i in range(1, len(altitude_data)):
|
|
diff = altitude_data[i] - altitude_data[i-1]
|
|
if diff > 0:
|
|
elevation_gain += diff
|
|
|
|
altitude_stats = {
|
|
'min': round(min(altitude_data), 1),
|
|
'max': round(max(altitude_data), 1),
|
|
'gain': round(elevation_gain, 1),
|
|
}
|
|
|
|
# Beräkna hastighetsstatistik
|
|
speed_stats = None
|
|
if speed_data:
|
|
avg_speed = sum(speed_data) / len(speed_data)
|
|
speed_stats = {
|
|
'avg_ms': round(avg_speed, 2),
|
|
'avg_kmh': round(avg_speed * 3.6, 1),
|
|
'max_ms': round(max(speed_data), 2),
|
|
'max_kmh': round(max(speed_data) * 3.6, 1),
|
|
}
|
|
|
|
# Bygg sammanfattning
|
|
summary = {
|
|
'file': str(tcx_path),
|
|
'parsed_at': datetime.now().isoformat(),
|
|
'activity': {
|
|
'sport': sport,
|
|
'id': activity_id,
|
|
'date': activity_id.split('T')[0] if 'T' in activity_id else activity_id,
|
|
},
|
|
'summary': {
|
|
'total_time_seconds': round(total_time, 1),
|
|
'total_time_formatted': f"{int(total_time//60)}:{int(total_time%60):02d}",
|
|
'total_distance_meters': round(total_distance, 2),
|
|
'total_distance_km': round(total_distance / 1000, 2),
|
|
'avg_speed_kmh': round((total_distance / total_time) * 3.6, 1) if total_time > 0 else 0,
|
|
'max_speed_kmh': round(max_speed * 3.6, 1),
|
|
'total_calories': total_calories,
|
|
'num_laps': len(laps),
|
|
'num_trackpoints': len(trackpoints),
|
|
},
|
|
'heart_rate': hr_stats,
|
|
'heart_rate_zones': hr_zones,
|
|
'power': power_stats,
|
|
'cadence': cadence_stats,
|
|
'altitude': altitude_stats,
|
|
'speed': speed_stats,
|
|
'laps': lap_data,
|
|
}
|
|
|
|
return summary
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 2:
|
|
print("Användning: python3 parse_tcx.py <tcx-fil>")
|
|
print("Exempel: python3 parse_tcx.py Data/training/activity_12345.tcx")
|
|
sys.exit(1)
|
|
|
|
tcx_file = Path(sys.argv[1])
|
|
|
|
if not tcx_file.exists():
|
|
print(f"Fel: Filen {tcx_file} hittades inte")
|
|
sys.exit(1)
|
|
|
|
try:
|
|
print(f"Parsar {tcx_file}...")
|
|
summary = parse_tcx_file(tcx_file)
|
|
|
|
# Spara som JSON
|
|
output_file = tcx_file.with_suffix('.tcx.json')
|
|
with open(output_file, 'w', encoding='utf-8') as f:
|
|
json.dump(summary, f, indent=2, ensure_ascii=False)
|
|
|
|
print(f"✓ Klar! Sammanfattning sparad i: {output_file}")
|
|
print(f"\nSnabb sammanfattning:")
|
|
print(f" Sport: {summary['activity']['sport']}")
|
|
print(f" Datum: {summary['activity']['date']}")
|
|
print(f" Tid: {summary['summary']['total_time_formatted']}")
|
|
print(f" Distans: {summary['summary']['total_distance_km']} km")
|
|
print(f" Genomsnittshastighet: {summary['summary']['avg_speed_kmh']} km/h")
|
|
|
|
if summary['heart_rate']:
|
|
print(f" Genomsnittspuls: {summary['heart_rate']['avg']} bpm")
|
|
print(f" Max puls: {summary['heart_rate']['max']} bpm")
|
|
|
|
if summary['power']:
|
|
print(f" Genomsnittseffekt: {summary['power']['avg']} W")
|
|
|
|
print(f"\nAnvänd denna JSON-fil för snabb analys istället för stora TCX-filen!")
|
|
|
|
except Exception as e:
|
|
print(f"Fel vid parsning: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|