"""FIT parsing and feature engineering for playstyle analysis. python -m src.parser raw/*.fit # print the feature vector of each session One pass over a Garmin .fit file gives: * swings one row per detected swing: time, game, stroke (badminsens overhead gate + classifier), peak wrist rotation / acceleration, estimated racket-head speed * meta session totals the watch recorded (heart rate, training effect, calories) and the user's heart-rate profile (max / resting HR) * hr heart-rate samples (minutes since start, bpm) * features the session feature vector used by src.model (see FEATURES) Swings are detected and classified with the shipped badminsens models (BADS overhead strokes: smash, clear, drop, backhand clear; everything else is "Other"). """ import datetime as dt import hashlib import math import os import pickle import sys from collections import Counter import numpy as np ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) if ROOT not in sys.path: sys.path.insert(0, ROOT) from badminsens.gate import OverheadGate # noqa: E402 from badminsens.io import load_fit # noqa: E402 from badminsens.predict import MODELS_DIR, STROKES, classify, detect, load_model, registry, set_balance # noqa: E402 RACKET_M = 0.7 # wrist -> racket head distance for the speed estimate (same as badminsens.plot) GYRO_SAT_DPS = 1990.0 # Forerunner 255 gyro clips at +/-2000 deg/s per axis RALLY_GAP_S = 4.0 # consecutive swings closer than this belong to one rally MIN_REST_MIN = 2.0 # an IMU gap this long is a rest between games (watch app paused) CACHE_VERSION = 3 # stroke codes used in features and sequences CODE = {"ForehandKill": "smash", "ForehandHigh": "clear", "ForehandLob": "drop", "BackhandTransition": "backhand", "": "other"} # session feature vector, in the order src.model expects (name: description) FEATURES = { "active_min": "minutes of play (IMU recording, rests excluded)", "swings_per_min": "swings per active minute", "overhead_share": "share of swings that are one of the 4 overhead strokes", "smash_share": "smashes / all swings", "clear_share": "clears / all swings", "drop_share": "drops / all swings", "backhand_share": "backhand clears / all swings", "attack_ratio": "smashes / overhead forehand strokes (smash + clear + drop)", "smash_p75_dps": "75th percentile peak wrist rotation of smashes (deg/s)", "backhand_med_dps": "median peak wrist rotation of backhand clears (deg/s)", "smash_drop_gap_dps": "median smash minus median drop peak wrist rotation (deg/s)", "swing_p90_kmh": "90th percentile estimated racket-head speed, all swings (km/h)", "swing_med_kmh": "median estimated racket-head speed, all swings (km/h)", "acc_p90_g": "90th percentile peak wrist acceleration (g)", "saturated_share": "share of swings that hit the gyro range limit (true speed higher)", "speed_cv": "median coefficient of variation of swing speed within each stroke type", "mean_confidence": "mean classifier confidence on overhead strokes", "rally_len": "mean swings per rally (swings < 4 s apart)", "shot_interval_s": "median time between own shots inside a rally (s)", "transition_entropy": "Markov transition entropy between consecutive stroke types (bits, 0..log2 5)", "speed_retention": "median swing speed in the last third of play / first third", "hr_avg_pct_hrr": "average heart rate as % of heart-rate reserve", "hr_high_share": "share of time above 80 % of max heart rate", "aerobic_te": "Garmin aerobic training effect (0-5)", "anaerobic_te": "Garmin anaerobic training effect (0-5)", "move_g": "RMS dynamic wrist acceleration between swings (g): footwork / movement", } def file_id(path): h = hashlib.sha1() with open(path, "rb") as f: for chunk in iter(lambda: f.read(1 << 20), b""): h.update(chunk) return h.hexdigest()[:16] def _read_meta(path): """Session totals, user HR profile, HR samples and the UTC offset in one fitparse pass.""" import fitparse meta, hr, offset = {}, [], None for m in fitparse.FitFile(path).get_messages( ["session", "user_profile", "zones_target", "record", "timestamp_correlation", "activity"]): v = m.get_values() if m.name == "record": if v.get("timestamp") is not None and v.get("heart_rate") is not None: hr.append((v["timestamp"], v["heart_rate"])) elif m.name == "session": for k in ("start_time", "total_timer_time", "total_elapsed_time", "total_calories", "avg_heart_rate", "max_heart_rate", "total_training_effect", "total_anaerobic_training_effect", "sport", "sub_sport"): if v.get(k) is not None: meta[k] = v[k] elif m.name == "user_profile": for k in ("resting_heart_rate",): # only the HR profile; no personal details are kept if v.get(k) is not None: meta["user_" + k] = v[k] elif m.name == "zones_target": if v.get("max_heart_rate"): meta["user_max_heart_rate"] = v["max_heart_rate"] elif offset is None and v.get("local_timestamp") and v.get("timestamp"): if isinstance(v["local_timestamp"], dt.datetime): offset = round((v["local_timestamp"] - v["timestamp"]).total_seconds() / 3600, 2) meta["utc_offset_h"] = 7.0 if offset is None else offset return meta, hr def game_spans(segments, min_rest_min=MIN_REST_MIN): spans = [] for s in segments: a, b = s["t"][0] / 60, s["t"][-1] / 60 if spans and a - spans[-1][1] < min_rest_min: spans[-1] = (spans[-1][0], b) else: spans.append((a, b)) return spans def _movement_g(segments, swing_times_s, guard_s=1.0): """RMS of |acc| - 1 g (low-passed) outside swing windows: footwork / body movement.""" from scipy.signal import butter, sosfiltfilt sos = butter(2, 5.0, fs=100.0, output="sos") num = den = 0.0 sw = np.sort(np.asarray(swing_times_s, float)) for s in segments: if len(s["t"]) < 50: continue mag = np.linalg.norm(s["acc"], axis=1) / 9.80665 dyn = sosfiltfilt(sos, mag - 1.0) t = s["t"] keep = np.ones(len(t), bool) if len(sw): j = np.searchsorted(sw, t) near = np.minimum(np.abs(t - sw[np.clip(j, 0, len(sw) - 1)]), np.abs(t - sw[np.clip(j - 1, 0, len(sw) - 1)])) keep = near > guard_s num += float((dyn[keep] ** 2).sum()) den += int(keep.sum()) return math.sqrt(num / den) if den else float("nan") def _entropy_rate(seqs, k=5): """Markov-chain entropy rate (bits) of stroke-type sequences, with add-0.5 smoothing.""" cats = list(dict.fromkeys(CODE.values())) T = np.full((k, k), 0.5) for s in seqs: for a, b in zip(s[:-1], s[1:]): T[cats.index(a), cats.index(b)] += 1 rows = T.sum(1) P = T / rows[:, None] pi = rows / rows.sum() return float(-(pi[:, None] * P * np.log2(P)).sum()) def session_features(swings, meta, hr, games): """Feature vector (dict, keys = FEATURES) of one session or a slice of it.""" n = len(swings) active = sum(b - a for a, b in games) or 1e-9 codes = [s["code"] for s in swings] c = Counter(codes) kmh = np.array([s["racket_kmh"] for s in swings], float) dps = np.array([s["peak_gyro_dps"] for s in swings], float) acc = np.array([s["peak_acc_g"] for s in swings], float) t = np.array([s["time_s"] for s in swings], float) fwd = c["smash"] + c["clear"] + c["drop"] over = fwd + c["backhand"] of = lambda code: dps[[k == code for k in codes]] if n else np.array([]) # noqa: E731 smash, drop, back = of("smash"), of("drop"), of("backhand") cvs = [] for code in ("smash", "clear", "drop", "backhand", "other"): v = kmh[[k == code for k in codes]] if len(v) >= 5: cvs.append(v.std() / v.mean()) # rallies: runs of swings < RALLY_GAP_S apart rallies, cur = [], [] for i in range(n): if cur and t[i] - t[i - 1] > RALLY_GAP_S: rallies.append(cur) cur = [] cur.append(i) if cur: rallies.append(cur) intervals = [t[r[j + 1]] - t[r[j]] for r in rallies for j in range(len(r) - 1)] # speed retention: last third of play vs first third (by swing order) third = n // 3 retention = float(np.median(kmh[-third:]) / np.median(kmh[:third])) if third >= 10 else float("nan") hmax = meta.get("user_max_heart_rate") or 220 - 35 hrest = meta.get("user_resting_heart_rate") or 60 hv = np.array([h for _, h in hr], float) pct_hrr = float(np.mean((hv - hrest) / (hmax - hrest)) * 100) if len(hv) else float("nan") high = float(np.mean(hv >= 0.8 * hmax)) if len(hv) else float("nan") shares = {k: c[k] / n if n else 0.0 for k in ("smash", "clear", "drop", "backhand")} return { "active_min": active, "swings_per_min": n / active, "overhead_share": over / n if n else 0.0, "smash_share": shares["smash"], "clear_share": shares["clear"], "drop_share": shares["drop"], "backhand_share": shares["backhand"], "attack_ratio": c["smash"] / fwd if fwd else float("nan"), "smash_p75_dps": float(np.percentile(smash, 75)) if len(smash) >= 3 else float("nan"), "backhand_med_dps": float(np.median(back)) if len(back) >= 3 else float("nan"), "smash_drop_gap_dps": float(np.median(smash) - np.median(drop)) if len(smash) >= 3 and len(drop) >= 3 else float("nan"), "swing_p90_kmh": float(np.percentile(kmh, 90)) if n else float("nan"), "swing_med_kmh": float(np.median(kmh)) if n else float("nan"), "acc_p90_g": float(np.percentile(acc, 90)) if n else float("nan"), "saturated_share": float(np.mean([s["saturated"] for s in swings])) if n else 0.0, "speed_cv": float(np.median(cvs)) if cvs else float("nan"), "mean_confidence": float(np.mean([s["confidence"] for s in swings if s["code"] != "other"] or [np.nan])), "rally_len": float(np.mean([len(r) for r in rallies])) if rallies else float("nan"), "shot_interval_s": float(np.median(intervals)) if intervals else float("nan"), "transition_entropy": _entropy_rate([[codes[i] for i in r] for r in rallies]), "speed_retention": retention, "hr_avg_pct_hrr": pct_hrr, "hr_high_share": high, "aerobic_te": float(meta.get("total_training_effect", float("nan"))), "anaerobic_te": float(meta.get("total_anaerobic_training_effect", float("nan"))), "move_g": meta.get("_move_g", float("nan")), } def parse_fit(path, model="default", min_peak_dps=800.0, min_rest_min=MIN_REST_MIN, cache_dir=None, models_dir=MODELS_DIR): """Full analysis of one .fit file -> dict(meta, swings, hr, games, features, per_game).""" fid = file_id(path) cache = None if cache_dir: os.makedirs(cache_dir, exist_ok=True) cache = os.path.join(cache_dir, f"{fid}_{model}_{int(min_peak_dps)}_v{CACHE_VERSION}.pkl") if os.path.exists(cache): with open(cache, "rb") as f: return pickle.load(f) meta, hr_raw = _read_meta(path) segments = load_fit(path) games = game_spans(segments, min_rest_min) acc, gyr, info = detect(path, min_peak_dps, segments=segments) reg = registry(models_dir) if info: gate = OverheadGate.load(os.path.join(models_dir, reg["gate"]["file"])) m = load_model(model, models_dir) set_balance(m, reg.get("balance_iters", 0)) rows = classify(m, acc, gyr, info, gate.accept(acc, gyr)) sat = (np.abs(np.degrees(gyr[:, 80:110])) >= GYRO_SAT_DPS).any(axis=(1, 2)) else: rows, sat = [], np.zeros(0, bool) mid = np.array([(a + b) / 2 for a, b in games]) if games else np.zeros(1) swings = [] for r, s in zip(rows, sat): tm = r["time_s"] / 60 g = next((i for i, (a, b) in enumerate(games) if a - 0.05 <= tm <= b + 0.05), int(np.abs(mid - tm).argmin())) code = CODE[r["label"] if r["gate"] == "accepted" else ""] swings.append({ "time_s": r["time_s"], "clock": r["clock"], "game": g + 1, "code": code, "stroke": STROKES[r["label"]][0] if code != "other" else "Other", "confidence": r["confidence"] if r["confidence"] != "" else float("nan"), "peak_gyro_dps": r["peak_gyro_dps"], "peak_acc_g": r["peak_acc_g"], "racket_kmh": round(math.radians(r["peak_gyro_dps"]) * RACKET_M * 3.6, 1), "saturated": bool(s), }) meta["_move_g"] = _movement_g(segments, [s["time_s"] for s in swings]) t0 = hr_raw[0][0] if hr_raw else meta.get("start_time") start = meta.get("start_time") or t0 hr = [((ts - start).total_seconds() / 60, h) for ts, h in hr_raw] if start else [] local = start + dt.timedelta(hours=meta["utc_offset_h"]) if start else None feats = session_features(swings, meta, hr, games) per_game = [] for i, (a, b) in enumerate(games): sw = [s for s in swings if s["game"] == i + 1] h = [(tm, v) for tm, v in hr if a <= tm <= b] if len(sw) >= 30: gm = {**meta, "total_training_effect": float("nan"), "total_anaerobic_training_effect": float("nan")} per_game.append({"game": i + 1, "start_min": a, "end_min": b, "features": session_features(sw, gm, h, [(a, b)])}) out = { "file_id": fid, "file_name": os.path.basename(path), "activity_id": os.path.basename(path).split("_")[0], "start_local": local.isoformat() if local else None, "model": model, "meta": {k: (v.isoformat() if isinstance(v, dt.datetime) else v) for k, v in meta.items()}, "games": games, "swings": swings, "hr": hr, "features": feats, "per_game": per_game, } if cache: with open(cache, "wb") as f: pickle.dump(out, f) return out def main(): import argparse ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("fit", nargs="+") ap.add_argument("--model", default="default") ap.add_argument("--cache", default=os.path.join(ROOT, ".cache", "sessions")) args = ap.parse_args() for p in args.fit: s = parse_fit(p, args.model, cache_dir=args.cache) print(f"\n{s['file_name']} {s['start_local']} {len(s['swings'])} swings, {len(s['games'])} games") for k, v in s["features"].items(): print(f" {k:20s} {v:9.3f}") if __name__ == "__main__": main()