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.
194 lines
9.0 KiB
Python
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)
|