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.
Chameleon/integration/ptz_predictive_zoom/track_integration.py

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