| |
| """Reprocess P1-P21 force CSVs using participant-specific ignore rules.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import importlib.util |
| import shutil |
| from pathlib import Path |
|
|
| import pandas as pd |
|
|
|
|
| DEFAULT_PROCESSOR = Path("/media/lab/Seagate Portable Drive/ECCV_dataset/zero_correct.py") |
|
|
|
|
| def load_processor(path: Path): |
| spec = importlib.util.spec_from_file_location("feel_zero_correct", path) |
| if spec is None or spec.loader is None: |
| raise RuntimeError(f"Cannot import processor: {path}") |
| module = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(module) |
| return module |
|
|
|
|
| def enabled(value: str): |
| return value.strip().lower() in {"1", "true", "yes", "y"} |
|
|
|
|
| def parse_ignore_before(value: str, side: str = "right"): |
| """Parse a global cutoff or sensor-specific cutoffs such as ``4r@2050``.""" |
| value = value.strip().lower() |
| if not value: |
| return None, {} |
| if value.isdigit(): |
| return int(value), {} |
|
|
| rules = {} |
| for token in value.split(","): |
| token = token.strip() |
| if token.count("@") != 1: |
| raise ValueError( |
| f"invalid ignore_before rule {token!r}; expected SENSORr@ROW, e.g. 4r@2050" |
| ) |
| base, end_text = token.split("@") |
| if len(base) < 2 or base[-1] not in {"l", "r"} or not base[:-1].isdigit(): |
| raise ValueError( |
| f"invalid ignore_before sensor {base!r}; expected e.g. 4r" |
| ) |
| if not end_text.isdigit(): |
| raise ValueError( |
| f"invalid ignore_before row {end_text!r}; expected a non-negative integer" |
| ) |
| hand = base[-1] |
| if (hand == "l" and side == "left") or (hand == "r" and side == "right"): |
| rules.setdefault(int(base[:-1]), []).append((0, int(end_text))) |
| return None, rules |
|
|
|
|
| def raw_input_from_existing(path: Path): |
| df = pd.read_csv(path) |
| sensor_cols = sorted( |
| (column for column in df.columns if column.startswith("sensor") and column[6:].isdigit()), |
| key=lambda column: int(column[6:]), |
| ) |
| if not sensor_cols: |
| raise RuntimeError(f"No sensorN columns in {path}") |
| for column in sensor_cols: |
| raw_column = f"raw_{column}" |
| if raw_column not in df.columns: |
| raise RuntimeError(f"{path} lacks {raw_column}; cannot reconstruct original sensor data") |
| df[column] = df[raw_column] |
| |
| drop = [f"raw_{column}" for column in sensor_cols] + ["raw_force", "force"] |
| return df.drop(columns=[column for column in drop if column in df.columns]) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--config", type=Path, default=Path(__file__).with_name("non_named_ignore_rules.csv")) |
| parser.add_argument("--feel-root", type=Path, default=Path(__file__).resolve().parent) |
| parser.add_argument("--processor", type=Path, default=DEFAULT_PROCESSOR) |
| parser.add_argument("--apply", action="store_true", help="Write results; otherwise only validate and report") |
| parser.add_argument("--only", nargs="*", help="Optional participant subset, for example --only P1 P4") |
| args = parser.parse_args() |
| processor = load_processor(args.processor) |
| selected = set(args.only or []) |
|
|
| with args.config.open(newline="") as handle: |
| rules = list(csv.DictReader(handle)) |
| failures = [] |
| for row in rules: |
| participant = row["participant"].strip() |
| if not enabled(row.get("enabled", "true")) or (selected and participant not in selected): |
| continue |
| destination = args.feel_root / participant / "force_aligned_.csv" |
| ignore = (row.get("ignore") or "").strip() |
| before_text = (row.get("ignore_before") or "").strip() |
| try: |
| raw_df = raw_input_from_existing(destination) |
| parsed = processor.parse_ignore(ignore, "right") |
| ignore_before, before_rules = parse_ignore_before(before_text, "right") |
| for sensor, spans in before_rules.items(): |
| parsed.setdefault(sensor, []).extend(spans) |
| if not args.apply: |
| if ignore_before is not None and not 0 <= ignore_before <= len(raw_df): |
| raise ValueError(f"ignore_before must be between 0 and {len(raw_df)}") |
| for sensor, spans in before_rules.items(): |
| for _, end in spans: |
| if not 0 <= end <= len(raw_df): |
| raise ValueError( |
| f"ignore_before cutoff for sensor {sensor} must be between " |
| f"0 and {len(raw_df)}" |
| ) |
| print(f"VALID {participant}: rows={len(raw_df)}, ignore={ignore or '(none)'}, " |
| f"ignore_before={before_text or '(none)'}") |
| continue |
| corrected = processor.apply_piecewise_zero_correction( |
| raw_df, parsed, ignore_before=ignore_before |
| ) |
| if len(corrected) != len(raw_df): |
| raise RuntimeError("correction changed row count") |
| backup = destination.with_name("force_aligned_.before_reprocess.csv") |
| if not backup.exists(): |
| shutil.copy2(destination, backup) |
| temporary = destination.with_suffix(".csv.tmp") |
| corrected.to_csv(temporary, index=False) |
| temporary.replace(destination) |
| print(f"WROTE {participant}: {len(corrected)} rows, ignore={ignore or '(none)'}, " |
| f"ignore_before={before_text or '(none)'}") |
| except Exception as error: |
| failures.append((participant, str(error))) |
| print(f"ERROR {participant}: {error}") |
| if failures: |
| raise SystemExit(f"Failed participants: {', '.join(name for name, _ in failures)}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
