删除深度重算引擎；修好回放视频每帧重开文件导致的无法播放，运输控制改到状态轨主按钮 - What: 1) 彻底删除深度重算引擎：shared/.../record/depth.py（DepthRecomputer/DepthResult）与 depth_backends.py（BoxReplay/FingerReplay）、其专属测试 test_depth_replay.py，record/__init__ 不再导出，playback.py::replay_warnings 不再报 depth_recomputed；apps/studio/replay.py 由 515 行瘦身为只做读盘+游标+视频帧+提示，回放视图的 2D 面板只提供「原始图像」；session.json 的 depth.replay 由 recompute 改为 none；删除 31 个只剩深度使用的文案键（depth_*/warn_state_*/warn_reset_*），warn_config_changed 与 warn_sdk_changed 改为描述"由视频重算"；ui_check 深度段、studio 两个深度用例、test_playback 三例、drive_shared 的 test_depth_replay 与 reproduce.py 的深度段一并清理（shared 套件 150→134 项）。2) 无法播放的根因是 RecordingReader.video_frame_at 每帧都 cv2.VideoCapture 重开并 seek：小片段已 ~10 ms/帧，1080p H.264 每次 seek 需从关键帧解码（上百 ms），而播放每 33 ms 要一帧且全在 UI 线程上，视频因此看着不动；改为按分段缓存解码器、顺序帧用 read() 步进（实测 10 ms → 0.5 ms/帧）、跳转才 seek，新增 RecordingReader.close() 释放。运输控制按用户建议上移到状态轨主按钮：toolbar.set_run_role("playback") 使回放视图的主按钮变成「▶ 回放」/「⏸ 暂停」（实时视图仍是「▶ 运行」），点按以 1× 推进游标（墙钟计时，漏拍不变慢）、到末尾自动停，拖动游标/框选/滚轮/拖总览条经 ForcePlotsPanel.timeline_taken_over 自动暂停，空格键同效；曲线表头不再放第二个播放按钮；按钮样式在回放角色下不再套用"停止"的红色语义。 - Why: 用户要求先清掉深度重算引擎、并反馈"现在无法播放视频"，建议把上方播放按钮在历史回放形式下改为回放。 - Verification: ui_check.py 554 项 0 失败（新增 seek<250ms/步进<60ms 的解码预算、回放按钮文字随播放/暂停切换、手动拖游标即暂停、切回实时视图按钮恢复运行、按深度视图已移除）；test_ui_smoke.py 71 项 0 失败；drive_shared.py 134 项 0 失败（深度引擎用例随代码删除）；locale_studio.py 262 键齐全、zh==en；reproduce.py 退出 0；.repro/probe_play.py 实测按「回放」后 0.75 s 内游标推进 0.689 s、面板 12/12 帧都在更新；两张复核图（回放视图的「▶ 回放」、实时视图的「▶ 运行」）。 - Not in this change: 录制文件格式与 CSV 列序不变（raw_*.mp4 与 forces.csv 继续一起写）；「由视频重算」复核模式保留（它复用实时管线，是有状态、只能顺序前进的一遍）。

shared/tests/test_depth_replay.py

@@ -1,424 +0,0 @@
-"""Offline depth replay: where to start, how far to step, which chain to run.
-
-P1-3 and P1-4: the pane kept showing the previous frame's depth after the cursor
-moved, the recomputer re-read ``target`` frames on every call (so requesting
-frames 2 and 3 landed on 5), it skipped the live processing chain, and it
-reduced the recorded config path to a name that could load a different file.
-"""
-
-from __future__ import annotations
-
-import shutil
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import patch
-
-import numpy as np
-import pytest
-
-from orisys_app_shared.record.depth import (
-    STATE_APPROXIMATE,
-    STATE_EXACT,
-    STATE_PREROLL,
-    DepthRecomputer,
-)
-
-SCRATCH = Path(__file__).resolve().parent / "_scratch"
-
-
-def _root() -> Path:
-    shutil.rmtree(SCRATCH, ignore_errors=True)
-    SCRATCH.mkdir(parents=True, exist_ok=True)
-    return SCRATCH
-
-
-class _CountingSensor:
-    """A sensor whose reported depth is the number of frames it has read."""
-
-    opened: list[dict] = []
-
-    def __init__(self, *args, **kwargs):
-        _CountingSensor.opened.append({"args": args, "kwargs": kwargs})
-        self.n = 0
-        self.chain_calls = 0
-        self.initial_img = "reference-frame"
-        # The real Sensor opens its source in the constructor, so the first
-        # source is part of its history too.
-        self.vid_src = str(args[0]) if args else ""
-        self.sources: list[str] = [self.vid_src] if self.vid_src else []
-        self.resets = 0
-        self.info = SimpleNamespace(DEPTH=1)
-
-    def get_img(self):
-        self.n += 1
-        return np.ones((2, 2))
-
-    def compute_deformation(self, **_kwargs):
-        self.chain_calls += 1
-
-    def compute_contact(self):
-        self.chain_calls += 1
-
-    def reset(self):
-        self.resets += 1
-
-    def read_info(self, _channel):
-        return np.array([self.n])
-
-    def _open_video_source(self, _override, _box):
-        self.sources.append(str(self.vid_src))
-        # A real reopen restarts the file from its first frame.
-        self.n = 0
-
-    def disconnect(self):
-        return None
-
-
-def _reader(session: dict, *, segments=("raw_0001.mp4",), frames=()):
-    directory = _root()
-    for name in segments:
-        (directory / name).write_bytes(b"")
-    return SimpleNamespace(
-        session=lambda: session,
-        segment_path=lambda segment: directory / f"raw_{segment:04d}.mp4",
-        segments=lambda: [directory / name for name in segments],
-        info=lambda: SimpleNamespace(frames=list(frames)),
-        frame_of=lambda frame_id: next(
-            (frame for frame in frames if frame.frame_id == frame_id), None
-        ),
-        frame_at=lambda t: None,
-        last_reset_frame=lambda frame_id: None,
-        segment_start_frame=lambda segment: next(
-            (frame for frame in frames if frame.segment == segment), None
-        ),
-        preroll_frames=lambda: 0,
-        preroll_segment=lambda: None,
-        directory=directory,
-    )
-
-
-def _session(config_ref: str) -> dict:
-    return {"device": {"config_ref": config_ref, "sensor_type": "box"}}
-
-
-def _config_file() -> str:
-    """A config that exists, so ``preflight`` is not what a test measures."""
-    path = _root() / "sensor.json"
-    path.write_text("{}", encoding="utf-8")
-    return str(path)
-
-
-def _reader_with_config(frames):
-    """A reader whose recorded config really exists on disk.
-
-    ``_reader`` recreates the scratch directory, so the config file is written
-    *after* the reader is built.
-    """
-    directory = _root()
-    config = directory / "sensor.json"
-    reader = _reader(_session(str(config)), frames=frames)
-    config.write_text("{}", encoding="utf-8")
-    return reader
-
-
-def test_stepping_continues_from_the_current_position():
-    """The old code re-read ``target`` frames every call: 2 then 3 landed on 5."""
-    _CountingSensor.opened.clear()
-    computer = DepthRecomputer(_reader(_session("/cfg/sensor.json")))
-    with patch("orisys.Sensor", _CountingSensor):
-        first = computer._depth_from_segment(Path("raw_0001.mp4"), 2)
-        second = computer._depth_from_segment(Path("raw_0001.mp4"), 3)
-    assert first.tolist() == [2]
-    assert second.tolist() == [3]
-    # One sensor for the whole replay: reopening would reset the algorithm state.
-    assert len(_CountingSensor.opened) == 1
-    computer.close()
-
-
-def test_stepping_backwards_reopens_the_source_but_keeps_the_processor():
-    _CountingSensor.opened.clear()
-    computer = DepthRecomputer(_reader(_session("/cfg/sensor.json")))
-    with patch("orisys.Sensor", _CountingSensor):
-        assert computer._depth_from_segment(Path("raw_0001.mp4"), 5).tolist() == [5]
-        # Reading an earlier frame restarts the file; the processor object (and
-        # therefore the tracker) is not thrown away.
-        assert computer._depth_from_segment(Path("raw_0001.mp4"), 2).tolist() == [2]
-        sensor = computer._sensor._sensor
-    assert len(_CountingSensor.opened) == 1, "the processor was recreated"
-    assert len(sensor.sources) == 2
-    assert all(source.endswith("raw_0001.mp4") for source in sensor.sources)
-    computer.close()
-
-
-def test_the_live_processing_chain_runs_for_every_replayed_frame():
-    """Without it the replay is a different algorithm than the recording."""
-    _CountingSensor.opened.clear()
-    computer = DepthRecomputer(_reader(_session("/cfg/sensor.json")))
-    with patch("orisys.Sensor", _CountingSensor):
-        computer._depth_from_segment(Path("raw_0001.mp4"), 3)
-        sensor = computer._sensor._sensor
-    assert sensor.chain_calls == 6, "one deformation + one contact per frame"
-    computer.close()
-
-
-def test_the_exact_config_path_is_opened(tmp_path=None):
-    """A reduced name could load a different file with the same name."""
-    _CountingSensor.opened.clear()
-    config = Path("D:/custom/box/sensor.json")
-    computer = DepthRecomputer(_reader(_session(str(config))))
-    with patch("orisys.Sensor", _CountingSensor):
-        computer._depth_from_segment(Path("raw_0001.mp4"), 1)
-    assert _CountingSensor.opened[0]["kwargs"]["config_name"] == str(config)
-    computer.close()
-
-
-def test_the_plan_starts_at_the_last_reset_in_the_same_segment():
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=1,
-            segment_frame=index + 1,
-            in_video=True,
-            dropped=False,
-        )
-        for index in range(10)
-    ]
-    reader = _reader(_session("/cfg/sensor.json"), frames=frames)
-    reader.last_reset_frame = lambda frame_id: 6
-    computer = DepthRecomputer(reader)
-    plan = computer.plan_for(frames[8])
-    assert plan.stop_at == 9
-    assert plan.anchor == "reset"
-    assert plan.state == STATE_EXACT
-    assert plan.reset_frame_id == 6
-    assert len(plan.steps) == 1
-    step = plan.steps[0]
-    assert step.source == reader.directory / "raw_0001.mp4"
-    assert step.to_frame == 9
-    assert step.reset_after == 7, "the reset boundary is not re-applied by the plan"
-    assert plan.frames_to_read == 9
-    assert plan.preroll is None
-    assert plan.warnings == ()
-    computer.close()
-
-
-def test_a_reset_that_is_not_in_the_video_is_not_a_recovered_state():
-    """Finding the event is not the same as being able to start there."""
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=1,
-            segment_frame=index + 1,
-            in_video=index != 6,  # the reset frame never reached the video
-            dropped=False,
-        )
-        for index in range(10)
-    ]
-    reader = _reader(_session("/cfg/sensor.json"), frames=frames)
-    reader.last_reset_frame = lambda frame_id: 6
-    computer = DepthRecomputer(reader)
-    plan = computer.plan_for(frames[8])
-    assert plan.anchor != "reset"
-    assert plan.state == STATE_APPROXIMATE
-    assert "reset_frame_not_in_video" in plan.warnings
-    assert "state_approximate" in plan.warnings
-    computer.close()
-
-
-def test_the_plan_uses_the_pre_roll_for_the_start_of_a_recording():
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=1,
-            segment_frame=index + 1,
-            in_video=True,
-            dropped=False,
-        )
-        for index in range(5)
-    ]
-
-    def reader_factory():
-        reader = _reader(_session("/cfg/sensor.json"), frames=frames)
-        reader.preroll_frames = lambda: 30
-        reader.preroll_segment = lambda: reader.directory / "preroll_0001.mp4"
-        return reader
-
-    reader = reader_factory()
-    (reader.directory / "preroll_0001.mp4").write_bytes(b"")
-    computer = DepthRecomputer(reader)
-    plan = computer.plan_for(frames[3])
-    assert plan.preroll is not None
-    assert plan.preroll_frames == 30
-    assert plan.anchor == "preroll"
-    assert plan.state == STATE_PREROLL
-    assert plan.warnings == ()
-    computer.close()
-
-
-def test_a_segment_without_history_is_flagged_approximate():
-    """Starting mid-recording with no reset and no pre-roll cannot be exact."""
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=2,
-            segment_frame=index + 1,
-            in_video=True,
-            dropped=False,
-        )
-        for index in range(5)
-    ]
-    reader = _reader(_session("/cfg/sensor.json"), frames=frames)
-    computer = DepthRecomputer(reader)
-    plan = computer.plan_for(frames[2])
-    assert plan.state == STATE_APPROXIMATE
-    assert plan.anchor == "segment_start"
-    assert "state_approximate" in plan.warnings
-    computer.close()
-
-
-def test_a_reset_in_an_earlier_segment_is_carried_across_by_swapping_the_source():
-    """The processor survives the swap, so the state *can* cross a segment."""
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=1 if index < 3 else 2,
-            segment_frame=index + 1 if index < 3 else index - 2,
-            in_video=True,
-            dropped=False,
-        )
-        for index in range(6)
-    ]
-    reader = _reader(
-        _session("/cfg/sensor.json"),
-        segments=("raw_0001.mp4", "raw_0002.mp4"),
-        frames=frames,
-    )
-    reader.last_reset_frame = lambda frame_id: 1
-    computer = DepthRecomputer(reader)
-    plan = computer.plan_for(frames[5])
-    assert plan.anchor == "reset"
-    assert plan.state == STATE_EXACT
-    assert "state_across_segment" not in plan.warnings
-    assert [step.source.name for step in plan.steps] == ["raw_0001.mp4", "raw_0002.mp4"]
-    assert plan.steps[0].reset_after == 2
-    assert plan.steps[1].to_frame == 3
-    computer.close()
-
-
-def test_a_replay_that_would_read_too_far_back_is_reported_not_attempted():
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=1,
-            segment_frame=index + 1,
-            in_video=True,
-            dropped=False,
-        )
-        for index in range(20)
-    ]
-    reader = _reader(_session("/cfg/sensor.json"), frames=frames)
-    reader.last_reset_frame = lambda frame_id: 1
-    computer = DepthRecomputer(reader)
-    with patch("orisys_app_shared.record.depth.MAX_REPLAY_FRAMES", 5):
-        plan = computer.plan_for(frames[10])
-    assert "state_too_far_back" in plan.warnings
-    assert plan.state == STATE_APPROXIMATE
-    computer.close()
-
-
-def test_the_same_frame_is_answered_from_the_cache():
-    """A second request for the frame just read is a cache hit, not None."""
-    _CountingSensor.opened.clear()
-    computer = DepthRecomputer(_reader(_session("/cfg/sensor.json")))
-    with patch("orisys.Sensor", _CountingSensor):
-        first = computer._depth_from_segment(Path("raw_0001.mp4"), 3)
-        second = computer._depth_from_segment(Path("raw_0001.mp4"), 3)
-        sensor = computer._sensor._sensor
-    assert first.tolist() == [3]
-    assert second is not None and second.tolist() == [3]
-    assert sensor.n == 3, "the cached answer re-read the stream"
-    computer.close()
-
-
-def test_the_processor_survives_a_pre_roll_to_segment_switch():
-    """Only the video source is replaced; the tracker state must survive."""
-    _CountingSensor.opened.clear()
-    reader = _reader(_session("/cfg/sensor.json"))
-    preroll = reader.directory / "preroll_0001.mp4"
-    preroll.write_bytes(b"")
-    computer = DepthRecomputer(reader)
-    with patch("orisys.Sensor", _CountingSensor):
-        computer._feed(preroll, 2)
-        sensor = computer._sensor._sensor
-        assert sensor.n == 2, "the pre-roll frames were not fed"
-        # Feed the segment: same processor, new source, position restarted.
-        computer._feed(reader.directory / "raw_0001.mp4", 1)
-    assert len(_CountingSensor.opened) == 1, "the processor was recreated"
-    assert computer._sensor._sensor is sensor
-    assert len(sensor.sources) == 2
-    assert sensor.sources[0].endswith("preroll_0001.mp4")
-    assert sensor.sources[1].endswith("raw_0001.mp4")
-    assert sensor.initial_img == "reference-frame", "the tracker reference was reset"
-    computer.close()
-
-
-def test_a_reset_boundary_is_re_applied_during_the_replay():
-    """The live zeroing cleared the tracker; the replay must do the same."""
-    _CountingSensor.opened.clear()
-    frames = [
-        SimpleNamespace(
-            frame_id=index,
-            t_rel_s=index / 30.0,
-            segment=1,
-            segment_frame=index + 1,
-            in_video=True,
-            dropped=False,
-        )
-        for index in range(10)
-    ]
-    reader = _reader_with_config(frames)
-    reader.last_reset_frame = lambda frame_id: 6
-    reader.frame_at = lambda _t: frames[8]
-    computer = DepthRecomputer(reader)
-    with patch("orisys.Sensor", _CountingSensor):
-        result = computer.depth_at(frames[8].t_rel_s)
-        sensor = computer._sensor._sensor
-    assert result.ok, result.error
-    assert sensor.resets == 1, "the reset boundary was not re-applied"
-    assert result.warnings == (), result.warnings
-    computer.close()
-
-
-def test_a_dropped_frame_is_reported_not_substituted():
-    """The index marks the hole; replay must say so instead of showing a neighbour."""
-    frames = [
-        SimpleNamespace(
-            frame_id=0,
-            t_rel_s=0.0,
-            segment=1,
-            segment_frame=1,
-            in_video=True,
-            dropped=False,
-        ),
-        SimpleNamespace(
-            frame_id=1,
-            t_rel_s=1 / 30.0,
-            segment=1,
-            segment_frame=0,
-            in_video=False,
-            dropped=True,
-        ),
-    ]
-    reader = _reader_with_config(frames)
-    reader.frame_at = lambda _t: frames[1]
-    computer = DepthRecomputer(reader)
-    result = computer.depth_at(1 / 30.0)
-    assert not result.ok
-    assert result.error == "frame_not_recorded"
-    computer.close()

shared/tests/test_module_boundaries.py

@@ -92,14 +92,9 @@ def test_the_moved_models_are_the_same_objects_everywhere():
 
 
 def test_the_recording_pieces_are_separate_modules():
-    from orisys_app_shared.record import depth, experiment
-    from orisys_app_shared.record.depth_backends import BoxReplay, FingerReplay
+    from orisys_app_shared.record import experiment
     from orisys_app_shared.record.video_writer import VideoSegments
 
-    # The depth replay no longer defines its backends inline...
-    assert not hasattr(depth, "BoxReplay")
-    assert not hasattr(depth, "_BoxReplay")
-    # ...and the writer delegates video encoding to its own component.
+    # The writer delegates video encoding to its own component.
     assert not hasattr(experiment, "_open_segment")
     assert callable(VideoSegments.write) and callable(VideoSegments.close)
-    assert BoxReplay.__name__ == "BoxReplay" and FingerReplay.__name__ == "FingerReplay"

shared/tests/test_playback.py

@@ -24,7 +24,6 @@ from orisys_app_shared.record import (
     RecordingReader,
     list_recordings,
 )
-from orisys_app_shared.record.depth import DepthRecomputer
 
 SCRATCH = Path(__file__).resolve().parent / "_scratch_playback"
 
@@ -219,60 +218,12 @@ def test_depth_policy_says_recompute_and_warns_about_drift(recording):
     # The config file on disk no longer matches what was recorded.
     codes = reader.replay_warnings(sdk_version="0.5.1")
     assert "config_changed" in codes
-    assert "depth_recomputed" in codes
 
     # Same SDK: no version warning.
     assert "sdk_changed" not in codes
     assert "sdk_changed" in reader.replay_warnings(sdk_version="9.9.9")
 
 
-def test_depth_recompute_preflight_states_why_it_cannot_run(recording):
-    reader = RecordingReader(recording)
-    recomputer = DepthRecomputer(reader)
-    try:
-        problem = recomputer.preflight()
-        assert problem in ("", "sdk_unavailable"), problem
-
-        # A recording with no config reference is refused, not guessed at.
-        missing = RecordingReader(recording)
-        missing._info = None  # noqa: SLF001 - force a re-read below
-        empty = SCRATCH / "empty"
-        empty.mkdir(exist_ok=True)
-        (empty / "forces.csv").write_text(
-            ",".join(("session_id", "frame_id", "t_rel_s", "FN_raw", "FX_raw", "FY_raw",
-                      "FN_N", "FX_N", "FY_N", "valid", "calibration_id")) + "\n",
-            encoding="utf-8",
-        )
-        (empty / "session.json").write_text(json.dumps({"depth": {"stored": False}}), encoding="utf-8")
-        bare = DepthRecomputer(RecordingReader(empty))
-        assert bare.preflight() in ("config_missing", "no_video", "sdk_unavailable")
-    finally:
-        recomputer.close()
-
-
-def test_depth_result_is_failed_not_blank_when_sdk_is_missing(recording):
-    """A missing SDK must produce an explicit error, never a stand-in image."""
-    saved = sys.modules.get("orisys")
-    blocker = types.ModuleType("orisys")
-    try:
-        # A module object with no Sensor/DEPTH surface: importing succeeds but
-        # nothing can be recomputed with it.
-        sys.modules["orisys"] = blocker
-        reader = RecordingReader(recording)
-        recomputer = DepthRecomputer(reader)
-        problem = recomputer.preflight()
-        assert problem in ("sdk_unavailable", ""), problem
-        if problem:
-            result = recomputer.depth_at(1.0)
-            assert not result.ok
-            assert result.depth is None
-            assert result.error
-    finally:
-        if saved is None:
-            sys.modules.pop("orisys", None)
-        else:
-            sys.modules["orisys"] = saved
-
 
 def test_list_recordings_finds_directories_newest_first(recording):
     second = SCRATCH / "zzz_later"