"""Integration cases for the PR #7 mock transport/control replay fixture.""" import math from types import SimpleNamespace from unittest.mock import patch TRACE = [] def build_track_cases(fixture, pp, ptz_io, config, state, status): class PredictiveTrack(fixture.Replay): def setUp(self): cameras = [8, *[cam for cam in config.PTZ_CAM_IDS if cam != 8]] with patch.object(config, 'PTZ_CAM_IDS', cameras): super().setUp() def flight(self, enabled, center_x=720, *, record=False): f, st = self.fixture, self.st if enabled: self.stack.enter_context(patch.dict(config.CAMERA_CONFIG[self.cam], { "predictive_zoom": {"nominal_gain": .45, "upper_gain": .8}, })) self.stack.enter_context(patch.object(config, "PTZ_ZOOM_STOP_FORCE_AXES_ZERO", False, create=True)) self.stack.enter_context(patch.object(config, "PREDICTIVE_ZOOM_TELEMETRY_DIR", None, create=True)) decisions = [] capture = pp.telemetry_tick def remember(config, cam, controller, frame, decision, zoom, why, at): decisions.append((round(at-100, 2), decision.reason, round(zoom, 3), why, st.get("zoom_followup_reason"), st.get("zoom_step_last_delivery_result"))) estimated, narrowest = controller.optics.estimate(at) if record: TRACE.append({ "event": "tick", "cam": cam + 11, "elapsed_ms": round((at-100)*1000, 1), "FOV_actual": controller.optics.actual, "FOV_estimated": estimated, "FOV_min_estimated": narrowest, "bbox_px": frame.bbox_px, "detector_conf": frame.detector_conf, "tracker_score": frame.tracker_score, "reason": decision.reason, }) capture(config, cam, controller, frame, decision, zoom, why, at) self.stack.enter_context(patch.object(pp, "telemetry_tick", side_effect=remember)) box = (center_x - 13, 347, center_x + 13, 371) st.update(track_started_at=99.95, last_bbox=box, prev_cx=center_x / 1280, prev_cy=359 / 720, stable_frames=0) fov, zoom = 59.0, 1.0 status._update_runtime_state(self.cam, None, None, 99.99, zoom_ratio=zoom, hfov_deg=fov) delivered = [] last_status = 99.99 completed = [] early = [] for k in range(46): f._advance(.08 if k else 0) now = f.wall if k % 6 == 0: st.update(visual_tracker_last_detector_at=now - .015, visual_tracker_last_zoom_detector_at=now - .015, visual_tracker_last_detector_conf=.8) if k % 3 == 1: if st.get("zoom_step_physical_request_id"): fov *= .97 zoom *= 1.03 status._update_runtime_state(self.cam, None, None, now - .012, zoom_ratio=zoom, hfov_deg=fov) last_status = now - .012 st.update(status_rate_at=now - .01, pan_rate_at=now - .01, tilt_rate_at=now - .01, pan_rate_deg_s=.4, tilt_rate_deg_s=0.0) timer = st.get("zoom_step_stop_timer") if (timer and timer.is_alive() and f.mono + 1e-9 >= st["zoom_step_stop_started_mono"] + timer.delay): timer.fire() request_before = st.get("zoom_step_physical_request_id") self.seq += 1 scale = math.tan(math.radians(59 / 2)) / math.tan(math.radians(fov / 2)) half_w, half_h = round(13 * scale), round(12 * scale) box = (center_x - half_w, 359 - half_h, center_x + half_w, 359 + half_h) self.assertTrue(0 < box[0] < box[2] < 1280 and 0 < box[1] < box[3] < 720) track = fixture.tracker.VisualTrackResult(True, box, .8, 0, .8, 30, "synthetic captured", self.seq) sample = fixture.control.VisualSample(fixture.control.owner(st), self.seq, now-.01, track) pp.postprocess_control(self.cam, self.frame, SimpleNamespace(boxes=fixture.Boxes([])), True, self.seq, visual_sample=sample, visual_only=True) if not state.ptz_cmd_q.empty(): f._flush() request = st.get("zoom_step_physical_request_id") if request and request != request_before: delivered.append((round(now-100, 2), request, last_status)) if st.get("predictive_zoom_request") == request and st["zoom_step_finished_at"] > last_status: early.append(request) if request_before and not request: completed.append(request_before) self.assertEqual(st["mode"], "TRACK") return delivered, early, fov, decisions, completed def test_track_runs_burst_without_post_stop_status(self): delivered, early, fov, decisions, completed = self.flight(True, record=True) self.assertTrue(delivered, decisions) TRACE.insert(0, {"event": "first_zoom", "t_to_first_zoom_ms": delivered[0][0]*1000}) self.assertGreaterEqual(len(delivered), 3, (delivered, decisions)) self.assertLess(delivered[0][0], .5, decisions) self.assertGreaterEqual(len(early), 1, (early, delivered, decisions)) print(f"3.6s TRACK: {len(delivered)} starts, first {delivered[0][0]:.2f}s, " f"{len(early)} before a post-STOP poll, terminal simulated HFOV {fov:.1f} deg") self.assertTrue(any(row[1] == "burst" for row in decisions), decisions) self.assertGreaterEqual(self.st["zoom_in_pulse_count"], 2, (completed, decisions)) self.assertLess(fov, 59.0) def test_track_same_flight_legacy_reference(self): delivered, early, fov, decisions, completed = self.flight(False) first = delivered[0][0] if delivered else None print(f"3.6s legacy TRACK: {len(delivered)} starts, first {first}s, terminal simulated HFOV {fov:.1f} deg") self.assertLess(len(delivered), 7) self.assertFalse(early) def test_track_starts_at_26_percent_of_half_frame(self): delivered, _, _, decisions, _ = self.flight(True, 806) self.assertTrue(delivered, decisions) self.assertLess(delivered[0][0], .5) self.assertTrue(any(reason == "fast_start" and zoom > 0 for _, reason, zoom, *_ in decisions), decisions) def test_track_legacy_reference_at_26_percent_of_half_frame(self): delivered, _, _, _, _ = self.flight(False, 806) print(f"3.6s legacy TRACK at 26% half-frame: {len(delivered)} starts") self.assertFalse(delivered) def assert_early_stop_axes(self, full_stop): f, st = self.fixture, self.st from ptz_tracker_modular.zoom_controller import controller_for_track self.stack.enter_context(patch.dict(config.CAMERA_CONFIG[self.cam], { "predictive_zoom": {"nominal_gain": .45, "upper_gain": .8}, })) controller = controller_for_track(st, config.CAMERA_CONFIG[self.cam]) controller.optics.observe(99.95, 59.0, f.wall) cmd = pp._gate_zoom_in_pulse(st, f.wall, .10, True, pulse_floor=.10, pulse_timing=(.34, .40)) st["predictive_zoom_request"] = st["zoom_step_pending_id"] f._enqueue(cmd, pan=.12, tilt=-.08) f._flush() request = controller.request self.assertIsNotNone(request) class InlineThread: def __init__(self, *, target, **_): self.target = target def start(self): self.target() self.stack.enter_context(patch.object(ptz_io.threading, "Thread", InlineThread)) self.stack.enter_context(patch.object(config, "PTZ_ZOOM_STOP_FORCE_AXES_ZERO", full_stop, create=True)) ptz_io.stop_predictive_zoom_async(self.cam, controller, "edge_acceleration") axes = tuple(fixture.transport.xml_axis(f.sent[-1], axis) for axis in ("pan", "tilt", "zoom")) self.assertEqual(axes, (0, 0, 0) if full_stop else (12, -8, 0)) self.assertIsNone(controller.request) self.assertFalse(controller.repeat_after_stop(st, f.wall)) def test_priority_zoom_stop_honors_axis_policy(self): self.assert_early_stop_axes(full_stop=False) def test_priority_zoom_stop_does_not_override_full_stop(self): self.assert_early_stop_axes(full_stop=True) return PredictiveTrack