You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
157 lines
8.9 KiB
Python
157 lines
8.9 KiB
Python
"""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
|