| """Samsung Galaxy Fit3 watch loader -- the non-LEVEL reference (heart rate, cadence, speed). |
| |
| Fit3 data is day-level: data/<subject>/<day>/fit3/. Two on-disk layouts, same Fit3 object out: |
| released dataset (our own schema): |
| fit3_live.csv 10 s samples: time(us), heart_rate, cadence, speed |
| fit3_summary.csv one row: start_time(us), duration_s, hr_mean/max/min, cadence_mean/max, ... |
| Samsung Health export ("Download personal data"), staged into fit3/: |
| live_data.json 10 s samples: heart_rate, cadence, distance, power, speed, start_time(ms) |
| location_data.json 1 s samples: latitude, longitude, altitude, accuracy, start_time(ms) |
| exercise_summary.csv the summary CSV -- avg/max HR etc. |
| |
| Times are epoch-us, on the same clock as the IMU and phone streams. |
| """ |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import os |
| from dataclasses import dataclass |
|
|
| import pandas as pd |
|
|
| LIVE_COLS = ["time", "heart_rate", "cadence", "speed"] |
|
|
|
|
| @dataclass |
| class Fit3: |
| live: pd.DataFrame |
| loc: pd.DataFrame |
| summary: dict |
|
|
|
|
| def _load_series(fit3_dir: str) -> tuple[pd.DataFrame, pd.DataFrame]: |
| public = os.path.join(fit3_dir, "fit3_live.csv") |
| if os.path.exists(public): |
| live = pd.read_csv(public) |
| return live[[c for c in LIVE_COLS if c in live]].sort_values("time").reset_index(drop=True), pd.DataFrame() |
|
|
| def js(name): |
| p = os.path.join(fit3_dir, name) |
| return json.load(open(p)) if os.path.exists(p) else [] |
|
|
| live = pd.DataFrame(js("live_data.json")) |
| if not live.empty: |
| live["time"] = live["start_time"].astype("int64") * 1000 |
| live = live[[c for c in LIVE_COLS if c in live]].sort_values("time").reset_index(drop=True) |
|
|
| loc = pd.DataFrame(js("location_data.json")) |
| if not loc.empty: |
| loc["time"] = loc["start_time"].astype("int64") * 1000 |
| loc = loc.rename(columns={"latitude": "lat", "longitude": "lon"}) |
| loc = loc[["time", "lat", "lon", "altitude", "accuracy"]].sort_values("time").reset_index(drop=True) |
| return live, loc |
|
|
|
|
| def _parse_summary(fit3_dir: str, start_us: int | None) -> dict: |
| """The run's summary: fit3_summary.csv, else the matching row of Samsung's exercise_summary.csv. |
| |
| Samsung header (line 2) is prefix-labelled (com.samsung.health.exercise.<field>); rows carry one extra |
| trailing field, but zip(header, row) aligns the leading columns we need. We pick the running |
| workout (exercise_type 1002) nearest the session start, else the longest running workout. |
| """ |
| pub = os.path.join(fit3_dir, "fit3_summary.csv") |
| if os.path.exists(pub): |
| rows = pd.read_csv(pub).to_dict("records") |
| if not rows: |
| return {} |
| r = {k: (None if pd.isna(v) else v) for k, v in rows[0].items()} |
| return {"start_time": r.get("start_time"), "duration_min": (r.get("duration_s") or 0) / 60.0, |
| "hr_mean": r.get("hr_mean"), "hr_max": r.get("hr_max"), "hr_min": r.get("hr_min"), |
| "cadence_mean": r.get("cadence_mean"), "cadence_max": r.get("cadence_max"), |
| "mean_speed": r.get("speed_mean_mps"), "calorie": r.get("calorie_kcal")} |
| p = os.path.join(fit3_dir, "exercise_summary.csv") |
| if not os.path.exists(p): |
| return {} |
| lines = open(p, encoding="utf-8-sig").read().splitlines() |
| if len(lines) < 3: |
| return {} |
| hdr = next(csv.reader([lines[1]])) |
| idx = {h.split(".")[-1]: i for i, h in enumerate(hdr)} |
|
|
| def g(row, key, cast=str): |
| j = idx.get(key) |
| if j is None or j >= len(row) or row[j] == "": |
| return None |
| try: |
| return cast(row[j]) |
| except ValueError: |
| return row[j] |
|
|
| best, best_key = None, None |
| for ln in lines[2:]: |
| row = next(csv.reader([ln])) |
| if g(row, "exercise_type") != "1002": |
| continue |
| dur = g(row, "duration", float) or 0.0 |
| st = g(row, "start_time") |
| key = dur |
| if start_us is not None and st: |
| try: |
| t = pd.Timestamp(st, tz="UTC").value // 1000 |
| key = -abs(t - start_us) |
| except Exception: |
| pass |
| if best_key is None or key > best_key: |
| best, best_key = row, key |
| if best is None: |
| return {} |
| return { |
| "start_time": g(best, "start_time"), |
| "duration_min": (g(best, "duration", float) or 0) / 60000.0, |
| "hr_mean": g(best, "mean_heart_rate", float), |
| "hr_max": g(best, "max_heart_rate", float), |
| "hr_min": g(best, "min_heart_rate", float), |
| "cadence_mean": g(best, "mean_cadence", float), |
| "cadence_max": g(best, "max_cadence", float), |
| "mean_speed": g(best, "mean_speed", float), |
| "calorie": g(best, "calorie", float), |
| } |
|
|
|
|
| def load_fit3(day_path: str) -> Fit3 | None: |
| """Fit3 for one day folder (data/<subject>/<day>), or None if that day has no watch data.""" |
| fit3_dir = os.path.join(day_path, "fit3") |
| if not os.path.isdir(fit3_dir): |
| return None |
| live, loc = _load_series(fit3_dir) |
| if live.empty and loc.empty: |
| return None |
| start_us = int(live["time"].iloc[0]) if not live.empty else int(loc["time"].iloc[0]) |
| return Fit3(live=live, loc=loc, summary=_parse_summary(fit3_dir, start_us)) |
|
|
