| """Action sequence → phase spans + per-phase turn anchor. |
| |
| Port of the segmentation algorithm used by `whab13/temporal-navigation`: |
| |
| > Major-segment boundaries are derived from the action sequence (rock-solid): |
| > a route is a series of forward-runs separated by SUSTAINED turns (>=2 consecutive |
| > same-direction turns). Short single-step turns are course corrections kept |
| > inside a segment. This yields ~3-6 segments matching the instruction's clause |
| > count, not the ~20 micro-turns a naive split would give. |
| |
| Inputs: |
| actions: list[int] -1=stop, 1=forward, 2=left-turn, 3=right-turn |
| Outputs: |
| spans: list[(start, end)] half-open ranges into `actions` |
| kinds: list[str] one of 'forward' | 'left' | 'right' | 'stop' |
| (per-phase alignment anchor) |
| """ |
| from __future__ import annotations |
| from typing import List, Tuple |
|
|
| FORWARD = 1 |
| LEFT = 2 |
| RIGHT = 3 |
| STOP = -1 |
|
|
|
|
| def _runs(actions: List[int]): |
| """Yield (value, start, end) for each maximal run of equal values in `actions`.""" |
| if not actions: return |
| cur = actions[0]; start = 0 |
| for i in range(1, len(actions)): |
| if actions[i] != cur: |
| yield cur, start, i |
| cur = actions[i]; start = i |
| yield cur, start, len(actions) |
|
|
|
|
| def segment_actions(actions: List[int], |
| sustained_turn_min: int = 2, |
| ) -> Tuple[List[Tuple[int, int]], List[str]]: |
| """Returns (spans, kinds). |
| |
| Algorithm: |
| 1. Walk the action sequence left-to-right. |
| 2. Phase boundaries are placed at the START of a SUSTAINED-turn run |
| (>= `sustained_turn_min` consecutive turns of the same direction). |
| 3. Single-step or short turns get absorbed into the surrounding forward |
| phase. (They're course corrections, not the operator's intended turn.) |
| 4. The phase kind = the dominant action in that phase: |
| - if the phase contains a sustained-turn run, kind = direction of that run |
| - else kind = 'forward' |
| - if the entire phase is only STOPs, kind = 'stop' |
| """ |
| if not actions: |
| return [], [] |
|
|
| |
| sustained_turn_starts = [] |
| for v, s, e in _runs(actions): |
| if v in (LEFT, RIGHT) and (e - s) >= sustained_turn_min: |
| sustained_turn_starts.append((s, e, v)) |
|
|
| |
| boundaries = [0] |
| for s, e, _ in sustained_turn_starts: |
| if s not in boundaries: |
| boundaries.append(s) |
| |
| if e not in boundaries and e < len(actions): |
| boundaries.append(e) |
| if boundaries[-1] != len(actions): |
| boundaries.append(len(actions)) |
| boundaries = sorted(set(boundaries)) |
|
|
| spans: List[Tuple[int, int]] = [] |
| for i in range(len(boundaries) - 1): |
| s, e = boundaries[i], boundaries[i + 1] |
| if e > s: spans.append((s, e)) |
|
|
| |
| kinds: List[str] = [] |
| for s, e in spans: |
| sub = actions[s:e] |
| if not sub: |
| kinds.append("stop"); continue |
| |
| kind = None |
| for ts, te, tv in sustained_turn_starts: |
| if s <= ts < te <= e: |
| kind = "left" if tv == LEFT else "right" |
| break |
| if kind is None: |
| |
| if all(a == STOP for a in sub): |
| kind = "stop" |
| else: |
| kind = "forward" |
| kinds.append(kind) |
|
|
| return spans, kinds |
|
|
|
|
| def _self_test(): |
| |
| |
| actions = [-1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 2, 2, 2, 1, 3, 1, 2, 1, 3, |
| 1, 2, 2, 2, 1, 1, 3, 1, 2, 2, 1, 1, 1, 2, 1] |
| spans, kinds = segment_actions(actions) |
| print(f"n_phases={len(spans)}") |
| for s, k in zip(spans, kinds): |
| print(f" {s} kind={k} actions={actions[s[0]:s[1]]}") |
| assert len(spans) >= 3, "should detect multiple phases" |
| assert "left" in kinds and "forward" in kinds, "should detect a left phase and a forward phase" |
| print("self-test OK") |
|
|
|
|
| if __name__ == "__main__": |
| _self_test() |
|
|
