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/legacy_ptz_frame_handoff/test_legacy_frame_handoff.py

194 lines
9.0 KiB
Python

"""Offline tests for the legacy PTZ frame handoff using the actual server functions."""
from __future__ import annotations
import ast
from contextlib import nullcontext
from functools import wraps
from pathlib import Path
from types import SimpleNamespace
from typing import NamedTuple
import unittest
ROOT = Path(__file__).resolve().parent / 'ptz_tracker_modular'
def definitions(file, names, env):
path = ROOT / file
tree = ast.parse(path.read_text(encoding='utf-8'))
definitions = [node for node in tree.body if getattr(node, 'name', None) in names]
future = tree.body[0] if isinstance(tree.body[0], ast.ImportFrom) and tree.body[0].module == '__future__' else None
exec(compile(ast.Module(body=([future] if future else []) + definitions, type_ignores=[]), str(path), 'exec'), env)
class FrameHandoffTests(unittest.TestCase):
def setUp(self):
self.source = object()
self.frame = object()
self.utc, self.mono = 100., 50.
self.owner = (0, 3, 99., 1)
self.st = {'mode': 'TRACK', 'tracking_active': True}
self.st.update(owner=self.owner)
self.ptz = []
self.tracker = []
self.saved = None
self.env = dict(
NamedTuple=NamedTuple, _visual_source=self.source, state=SimpleNamespace(ptz_states={0: self.st}),
time=SimpleNamespace(time=lambda: self.utc, monotonic=lambda: self.mono),
visual_control=SimpleNamespace(control_lock=lambda cam: nullcontext(),
owner=lambda st: st['owner'], enabled=lambda: True,
VisualSample=lambda owner, seq, at, result: SimpleNamespace(owner=owner, source_seq=seq, captured_at=at, result=result),
retain=self.retain, latest=lambda *args: self.saved),
visual_control_probe=SimpleNamespace(trace_feed_update=lambda f:f,
call_tracker_update=lambda update,*args,**kwargs: update(*args,**kwargs)),
visual_tracker_manager=SimpleNamespace(update=self.update_tracker),
config=SimpleNamespace(), _visual_feed_is_active=lambda *args: True,
_store_visual_feed_result=lambda *args: None,
postprocess_control=lambda *args,**kw:self.ptz.append((args,kw)),
)
definitions('streaming.py', ('_VisualReceipt','_visual_receipt_current','_update_visual_feed',
'_prepare_visual_inference_item','_postprocess_inference_item'), self.env)
def retain(self, camera, frame, sample):
self.saved = frame, sample
def update_tracker(self, camera, frame, source_seq):
self.tracker.append((camera, frame, source_seq))
return SimpleNamespace(ok=True)
def visual(self, **overrides):
fields = dict(source=self.source, owner=self.owner, utc=100., monotonic=50.)
fields.update(overrides)
receipt = self.env['_VisualReceipt'](**fields)
self.env['_update_visual_feed'](0, self.frame, 1, receipt=receipt)
def test_recent_frame_centers_with_original_decode_time(self):
self.utc += .11
self.mono += .11
self.visual()
self.assertEqual(self.tracker, [(0,self.frame,1)])
self.assertTrue(self.ptz[0][1]['visual_only'])
self.assertEqual(self.ptz[0][1]['visual_sample'].captured_at, 100.)
def test_stale_foreign_and_future_frames_do_not_reach_tracker(self):
for override in ({'monotonic':49.7}, {'utc':100.2}, {'source':object()},
{'owner':(0,2,99.,1)}):
with self.subTest(override=override):
self.visual(**override)
self.assertEqual(self.tracker, [])
self.assertEqual(self.ptz, [])
def test_frame_aging_during_tracker_update_is_not_sent_to_ptz(self):
def update(*args, **kw):
self.mono += .3
return self.update_tracker(*args, **kw)
self.env['visual_tracker_manager'].update = update
self.visual()
self.assertEqual(len(self.tracker), 1)
self.assertEqual(self.ptz, [])
def test_paired_detection_keeps_image_and_rejects_late_result(self):
self.visual()
queued = (0, object(), True, 2, SimpleNamespace(), 51.)
cam, frame, ptz, seq, future, _ = self.env['_prepare_visual_inference_item'](queued)
self.assertIs(frame, self.frame)
self.assertEqual(seq, 1)
self.utc += .4
self.mono += .4
self.env['_postprocess_inference_item'](cam, frame, 'legacy results', ptz, seq, future)
self.assertEqual(self.ptz[-1][0][2], 'legacy results')
self.assertIs(self.ptz[-1][1]['visual_sample'], self.saved[1])
self.mono += .3
self.env['_postprocess_inference_item'](cam, frame, 'late results', ptz, seq, future)
self.assertEqual(len(self.ptz), 2)
def test_paired_detection_discarded_after_reconnect(self):
self.visual()
cam, frame, ptz, seq, future, _ = self.env['_prepare_visual_inference_item'](
(0, object(), True, 2, SimpleNamespace(), 51.))
self.env['_visual_source'] = object()
self.env['_postprocess_inference_item'](cam, frame, 'legacy results', ptz, seq, future)
self.assertEqual(len(self.ptz), 1)
def test_unpaired_detector_results_keep_legacy_entry_point(self):
post = self.env['_postprocess_inference_item']
for ptz in (True,False):
post(0, self.frame, 'legacy results', ptz, 1, SimpleNamespace())
self.assertEqual(self.ptz[-1], ((0, self.frame, 'legacy results', ptz, 1), {}))
def test_decoder_busy_branch_uses_original_receipt_on_both_preview_paths(self):
class StopProbe(Exception):
pass
async def stop_after_connection(delay):
raise StopProbe
class Socket:
async def __aenter__(self):
return self
async def __aexit__(self, *exc):
pass
async def __aiter__(self):
yield b'\x01\x00\x00\x17'
for preview in (False, True):
with self.subTest(preview=preview):
seen, errors, decoded = [], [], []
self.utc, self.mono = 100., 50.
self.st.update(proc_busy=True, last_source_seq=0)
def image_decode(buffer, mode):
decoded.append(1)
return self.frame
def publish(*args, **kwargs):
self.utc, self.mono = 100.2, 50.2
self.env.update(
websockets=SimpleNamespace(connect=lambda *args,**kwargs:Socket()),
asyncio=SimpleNamespace(sleep=stop_after_connection),
logger=SimpleNamespace(info=lambda *args:None, error=lambda *args:errors.append(args)),
config=SimpleNamespace(CAMERA_CONFIG={0:{}}, PTZ_CAM_IDS=(0,),
DROP_DECODE_WHEN_BUSY=True, CPP_WS_URI='offline'),
cv2=SimpleNamespace(imdecode=image_decode,IMREAD_COLOR=1),
np=SimpleNamespace(frombuffer=lambda data,dtype:data,uint8=int),
_cpp_stream_map_logged=set(), _resolve_cpp_cam_id=int,
ensure_runtime_state_for_camera=lambda *args:None,
_has_recent_video_client=lambda *args:True,
_frontend_raw_preview_due=lambda *args:preview,
_publish_frontend_raw_preview=publish,
_target_predecode_fps=lambda *args:0,
_feed_visual_tracker_frame=lambda *args,**kw:seen.append((args,kw['receipt'],self.env['_visual_source'])),
)
self.env['time'].perf_counter=lambda:50.
self.env['state'].detected_cameras={0}
definitions('streaming.py', ('cpp_ws_loop',), self.env)
with self.assertRaises(StopProbe):
self.env['cpp_ws_loop']().send(None)
self.assertFalse(errors)
self.assertEqual(len(decoded),1)
self.assertEqual(len(seen),1)
args, receipt, source = seen[0]
self.assertEqual(args, (0,self.frame,self.st,1))
self.assertIs(receipt.source, source)
self.assertEqual((receipt.utc, receipt.monotonic), (100.,50.))
self.assertIsNone(self.env['_visual_source'])
def test_probe_decorators_forward_receipt(self):
got = []
env = dict(wraps=wraps, _perf=lambda:0., _wall=lambda:100.,
_context=SimpleNamespace(), _safe_record=lambda *args,**kwargs:None)
definitions('visual_control_probe.py', ('trace_enqueue','trace_feed_update'), env)
def enqueue(camera, frame, st, source_seq, *, receipt):
got.append(receipt)
def update(camera, frame, source_seq, captured_at=None, *, receipt):
got.append(receipt)
env['trace_enqueue'](enqueue)(0, self.frame, {}, 1, receipt=self.source)
env['trace_feed_update'](update)(0, self.frame, 1, 100., receipt=self.source)
self.assertEqual(got, [self.source,self.source])
if __name__ == '__main__':
unittest.main(verbosity=2)