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.
121 lines
6.2 KiB
Python
121 lines
6.2 KiB
Python
import json
|
|
from pathlib import Path
|
|
from tempfile import TemporaryDirectory
|
|
import unittest
|
|
from types import SimpleNamespace
|
|
from unittest.mock import patch
|
|
|
|
import zoom_controller as z
|
|
from fit_tele_profile import summarize
|
|
from test_zoom_controller import frame, tick
|
|
|
|
|
|
class BroadTeleTests(unittest.TestCase):
|
|
def make(self, fov, **settings):
|
|
c = z.ZoomController(z.ZoomConfig(.5, .9, **settings), (3, 100.))
|
|
c.optics.observe(99.99, fov, 100.)
|
|
return c
|
|
|
|
def test_broad_converging_entry_beyond_static_band(self):
|
|
ctrl = self.make(59)
|
|
for k, x in enumerate((.173, .167, .161)):
|
|
decision = tick(ctrl, frame(100 + .08*k, k+1,
|
|
offset=(x,0), detector_at=99.99))
|
|
self.assertEqual(decision.reason, "fast_start")
|
|
self.assertEqual(decision.gate, "initial")
|
|
self.assertGreater(decision.margin, ctrl.cfg.edge_margin)
|
|
ctrl = self.make(59)
|
|
for k in range(3):
|
|
decision = tick(ctrl, frame(100+.08*k,k+1,offset=(.161,0),detector_at=99.99))
|
|
self.assertEqual(decision.reason, "not_centered")
|
|
|
|
def test_margin_curve_and_floor_keep_legacy_wire_from_bypassing(self):
|
|
ctrl = self.make(10.6)
|
|
self.assertAlmostEqual(ctrl.cfg.margin_for(59), .16)
|
|
self.assertAlmostEqual(ctrl.cfg.margin_for(12), .32)
|
|
self.assertGreater(ctrl.cfg.margin_for(15), ctrl.cfg.margin_for(20))
|
|
decision = tick(ctrl, frame(100.08, 1, offset=(.2,0), detector_at=99.99))
|
|
self.assertEqual(decision.reason, "min_hfov_limit")
|
|
self.assertIsNone(decision.window)
|
|
self.assertTrue(decision.step_back)
|
|
profile = {"predictive_zoom": {"nominal_gain": .5, "upper_gain": .9}}
|
|
self.assertEqual(z.transport_zoom_block_reason({"predictive_zoom_hfov":(99.9,10.6)},
|
|
profile,100.,.12),"min_hfov_limit")
|
|
self.assertIsNone(z.transport_zoom_block_reason({"predictive_zoom_hfov":(99.9,59.)},
|
|
profile,100.,.40))
|
|
self.assertEqual(z.transport_zoom_block_reason({"predictive_zoom_hfov":(98.9,59.)},
|
|
profile,100.,.40),"min_hfov_limit")
|
|
self.assertIsNone(z.transport_zoom_block_reason({}, {}, 100., .40))
|
|
|
|
def test_latency_horizon_moves_prediction_in_residual_direction(self):
|
|
def command(horizon):
|
|
ctrl = self.make(14, latency_horizon_ms=horizon)
|
|
f = frame(100.20,2,offset=(.025, -.03),detector_at=99.99)
|
|
ctrl.latest_pose = (2,(.34,-.20),(.5,-.2),True)
|
|
result=ctrl.tele_aim(f,100.25,(0.,0.))
|
|
self.assertIsNotNone(result)
|
|
return result[0]
|
|
slow,fast = command(120),command(245)
|
|
self.assertGreater(fast[0],slow[0])
|
|
self.assertLess(fast[1],slow[1])
|
|
|
|
def test_measured_pulse_reports_settled_delta_rtt_and_tail(self):
|
|
ctrl = self.make(14.5)
|
|
st=dict(predictive_zoom_controller=ctrl,mode="TRACK",tracking_active=True,
|
|
ptz_generation=3,track_started_at=100.,
|
|
predictive_zoom_request=1,zoom_step_start_status_at=99.99,
|
|
zoom_step_start_hfov_deg=14.5,last_ptz_physical_cmd=(0.,0.,0.))
|
|
with patch.object(z,"_episode_telemetry") as submit:
|
|
cfg=SimpleNamespace()
|
|
z.transport_accepted(cfg,8,st,1,10,100.03,100.08,100.21,.05)
|
|
ctrl.optics.observe(100.15,13.9,100.15)
|
|
z.transport_stopped(cfg,8,st,1,100.21,reason="priority_stop:watchdog",
|
|
confirmed=True,clean=True,duration_s=.18,stop_issued_at=100.16,
|
|
stop_rtt_s=.05)
|
|
self.assertTrue(ctrl.calibration_hold(100.22))
|
|
for at,fov in ((100.25,13.6),(100.48,13.4),(100.63,13.4)):
|
|
z.observe_calibration(cfg,8,st,at,fov,at)
|
|
self.assertFalse(ctrl.calibration_hold(100.64))
|
|
row=submit.call_args.kwargs
|
|
self.assertEqual(row["outcome"],"settled")
|
|
self.assertEqual(row["put_rtt_ms"],50.)
|
|
self.assertEqual(row["stop_rtt_ms"],50.)
|
|
self.assertAlmostEqual(row["delta_hfov_deg"],-1.1)
|
|
self.assertAlmostEqual(row["post_stop_tail_deg"],.2)
|
|
self.assertAlmostEqual(row["stop_bracket_narrowing_deg"],.5)
|
|
self.assertGreater(row["effective_tele_log_rate_s"],0.)
|
|
|
|
def test_offline_fit_excludes_censored_rows_and_duplicate_requests(self):
|
|
base=dict(event="native10_pulse_calibration", cam=8, generation=3,
|
|
outcome="settled", effective_tele_log_rate_s=.4, HFOV_before=14.,
|
|
HFOV_after=13., put_rtt_ms=50., stop_rtt_ms=55., put_at=101.,
|
|
stop_status_at=101.11, stop_issued_at=101.16, HFOV_stop_sample=13.2)
|
|
records = [dict(base, track_start_utc=100.+i//2, request=i+1) for i in range(3)]
|
|
records += [records[0], dict(base, track_start_utc=102., request=5, outcome="next_pulse")]
|
|
with TemporaryDirectory() as tmp:
|
|
path=Path(tmp)/"episode.jsonl"
|
|
path.write_text("".join(json.dumps(x)+"\n" for x in records),encoding="utf-8")
|
|
result=summarize([path])
|
|
self.assertFalse(result["production_enable"])
|
|
camera=result["cameras"]["8"]
|
|
self.assertEqual(camera["qualified"],3)
|
|
self.assertEqual(camera["candidate_for_review"]["qualified_stop_brackets"],3)
|
|
|
|
def test_episode_counts_and_snapshot_values(self):
|
|
cfg=SimpleNamespace()
|
|
st=dict(ptz_generation=2,track_started_at=100.)
|
|
with patch.object(z,"_episode_telemetry") as emit:
|
|
z.record_zoom_blocks(cfg,8,st,100.1,{"angle_tol":{"pan_deg":4.}})
|
|
z.record_zoom_blocks(cfg,8,st,100.2,{"angle_tol":{"pan_deg":4.2},"put_inflight":{"request":2}})
|
|
self.assertEqual(emit.call_count,1)
|
|
z.flush_zoom_blocks(cfg,8,st,100.3,final=True)
|
|
last=emit.call_args.kwargs
|
|
self.assertEqual(last["zoom_block_reason"],{"angle_tol":2,"put_inflight":1})
|
|
self.assertEqual(last["last_values"]["angle_tol"]["pan_deg"],4.2)
|
|
self.assertTrue(last["final"])
|
|
self.assertNotIn("episode_zoom_blocks",st)
|
|
|
|
|
|
if __name__=="__main__":
|
|
unittest.main()
|