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_field_calibration/test_calibrate_tele_profile.py

239 lines
13 KiB
Python

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

import json
import math
from pathlib import Path
import subprocess
import sys
from tempfile import TemporaryDirectory
import unittest
import calibrate_tele_profile as c
def envelope(cam, start, event, at, **fields):
return dict(cam=cam, generation=4, track_start_utc=start, utc=at,
elapsed_ms=round((at - start) * 1000, 1), event=event, dropped_before=0, **fields)
def episode(cam=8, start=1000., *, initial=11., settled=10.4, margin=.40, request=1):
def row(event, elapsed, **fields):
return envelope(cam, start, event, start + elapsed, **fields)
put = start + 1.
stop_fov = settled + (initial - settled) * .5
first_fov = settled + (initial - settled) / 6
rows = [row("first_zoom", 1.04, t_to_first_zoom_ms=1040., t_to_first_zoom_put_ms=1000.,
request=request, native=10)]
for seq, (offset, status_offset, hfov) in enumerate((
(1., .95, initial), (1.10, 1.10, stop_fov), (1.20, 1.20, first_fov),
(1.30, 1.20, first_fov), (1.40, 1.40, settled), (1.50, 1.40, settled),
(1.57, 1.57, settled),
), 1):
rows.append(row("tick", offset, seq=seq, frame_utc=start+offset-.10,
zoom_cmd=.10 if offset <= 1.10 else 0., reason="pulse_active",
stop_requested=False, FOV_actual=hfov, FOV_status_utc=start+status_offset,
FOV_estimated=hfov, FOV_min_estimated=hfov-.05, bbox_px=[18,15],
tracker_score=.80, detector_conf=.71, detector_utc=start+.95,
margin=margin, edge_margin_required=.32, gate="tracking_zoom", ff_deg_s=[0.,0.]))
rows.extend((
row("stop", 1.17, request=request, reason="priority_stop:watchdog", confirmed=True, clean=True),
row(c.PULSE, 1.60, request=request, native=10, put_at=put, ack_at=start+1.04,
put_rtt_ms=40., HFOV_before=initial, before_at=start+.95, stop_issued_at=start+1.12,
stop_ack_at=start+1.17, stop_rtt_ms=50., duration_s=.17, stop_reason="priority_stop:watchdog",
stop_status_at=start+1.10, HFOV_stop_sample=stop_fov, clean_stop=True, outcome="settled",
HFOV_after=settled, after_at=start+1.57, delta_hfov_deg=settled-initial,
first_post_stop_at=start+1.20, HFOV_first_post_stop=first_fov, post_stop_tail_deg=first_fov-settled,
stop_bracket_narrowing_deg=stop_fov-settled, stop_sample_age_ms=20.,
effective_tele_log_rate_s=(c.focal(settled)-c.focal(initial))/.17 if initial < 15 else None),
row("zoom_block_summary", 1.80, final=True, zoom_block_reason={"min_hfov_limit":5},
last_values={"min_hfov_limit":{"hfov":settled,"minimum":10.}}),
))
return rows
def run(rows, observations=None, limits=c.Limits()):
grouped = {}
for r in rows:
key = (r["cam"], r["generation"], r["track_start_utc"])
grouped.setdefault(key, []).append(r)
return c.analyze(grouped, c.load_profiles(None), limits, observations)
def pulse(rows):
return next(r for r in rows if r["event"] == c.PULSE)
def write(path, rows):
path.write_text("".join(json.dumps(row)+"\n" for row in rows),encoding="utf-8")
class CalibrationTests(unittest.TestCase):
def test_poll_cadence_counts_fresh_optics_separately_from_cache(self):
rows = episode()
for i in range(5):
now = 1000.5 + .08 * i
rows.append(envelope(8, 1000., "status_sample", now, request_ms=40.,
status_ok=True, FOV_actual=13.,
FOV_status_utc=now if i != 2 else now-.08, optics_fresh=i != 2))
report, _ = run(rows)
status = report["episodes"][0]["isapi_track_status"]
self.assertEqual(status["success"], 5)
self.assertEqual(status["fresh_optics"]["samples"], 4)
self.assertAlmostEqual(status["successful_status"]["hz"], 12.5)
self.assertAlmostEqual(status["fresh_optics"]["gap_ms"]["max"], 160.)
self.assertEqual(status["request_ms"]["p95"], 40.)
def test_recovers_rate_tail_rtt_and_bounded_lower_profile(self):
report, candidate = run(sum((episode(start=1000.+i*10) for i in range(3)), []))
camera = candidate["cameras"]["19"]
self.assertEqual(camera["qualified_tele_pulses"],3)
result = camera["predictive_zoom_for_review"]
expected = math.log(math.tan(math.radians(11 / 2))/math.tan(math.radians(10.4 / 2))) / .17
self.assertAlmostEqual(result["nominal_gain"]*c.FULL_SWEEP_LOG_RATE,expected)
self.assertGreaterEqual(result["upper_gain"],c.BASELINE[8][1])
self.assertEqual(result["min_allowed_hfov_deg"],9.5)
self.assertFalse(candidate["production_enable"])
bins = report["cameras"]["19"]["pulses_by_native_and_hfov_band"]["10"]["10_to_lt_12"]
self.assertAlmostEqual(bins["effective_log_rate_s"]["p50"],expected)
self.assertAlmostEqual(bins["pre_stop_hfov_narrowing_deg_s"]["p50"],3.)
self.assertAlmostEqual(bins["post_stop_tail_deg"]["p95"],.10)
self.assertAlmostEqual(bins["stop_bracket_narrowing_deg"]["max"],.30)
self.assertEqual(bins["put_rtt_ms"]["p95"],40.)
self.assertEqual(bins["stop_rtt_ms"]["p95"],50.)
self.assertAlmostEqual(bins["native10_profile_comparison"]["median_observed_over_nominal"],
expected/(c.BASELINE[8][0]*c.FULL_SWEEP_LOG_RATE))
def test_all_hfov_bands_and_native_are_separate(self):
rows = []
for i,(initial,settled) in enumerate(((48.,47.),(35.,34.),(18.,17.),(12.,11.),(10.,9.5),(9.,8.8))):
rows.extend(episode(start=1000+i*10, initial=initial, settled=settled))
other = episode(start=1100.)
pulse(other)["native"] = 11
report,_=run(rows+other)
bins=report["cameras"]["19"]["pulses_by_native_and_hfov_band"]
self.assertEqual(set(bins["10"]),set(c.BINS))
self.assertEqual(bins["10"]["18_to_35"]["seen"],2)
self.assertEqual(bins["11"]["10_to_lt_12"]["seen"],1)
def test_stale_status_sparse_polling_and_owner_loss_are_excluded(self):
a=episode(start=1000.)
pulse(a)["before_at"]=1000.1
b=episode(start=1010.)
pulse(b)["first_post_stop_at"]=1011.48
d=[r for r in episode(start=1020.) if not (r["event"]=="tick" and r["seq"] in (5,6))]
e=episode(start=1030.)
pulse(e).update(outcome="owner_changed", clean_stop=False, stop_reason="priority_stop:track_lost")
report, candidate = run(a+b+d+e)
observed=[ep["pulses"][0]["excluded"] for ep in report["episodes"]]
self.assertIn("stale_before_status",observed[0])
self.assertIn("late_post_stop_status",observed[1])
self.assertIn("sparse_post_stop_status",observed[2])
self.assertIn("interrupted_or_unclean_stop",observed[3])
self.assertIsNone(candidate["cameras"]["19"]["predictive_zoom_for_review"])
def test_outlier_is_excluded_from_fit_but_retained_as_safety_evidence(self):
normal=sum((episode(start=1000.+i*10) for i in range(5)), [])
extreme=episode(start=1050., initial=11., settled=9.85)
report,candidate=run(normal+extreme)
rejected=report["episodes"][-1]["pulses"][0]
self.assertIn("rate_outlier",rejected["excluded"])
profile=candidate["cameras"]["19"]
self.assertEqual(profile["qualified_tele_pulses"],5)
self.assertIsNone(profile["next_floor_review"]["proposed_next_test_deg"])
self.assertGreaterEqual(profile["predictive_zoom_for_review"]["upper_gain"],
1.25*rejected["effective_log_rate_s"]/c.FULL_SWEEP_LOG_RATE)
def test_no_floor_decrease_on_small_margin_or_data_far_from_floor(self):
for opts,reason in (({"margin":.325},"no_lower_step_with_observed_margin"),
({"initial":14.,"settled":13.},"insufficient_near_floor_status_and_framing")):
with self.subTest(opts=opts):
_,candidate=run(sum((episode(start=1000.+i*10,**opts) for i in range(3)), []))
camera=candidate["cameras"]["19"]
self.assertEqual(camera["next_floor_review"]["reason"],reason)
self.assertEqual(camera["predictive_zoom_for_review"]["min_allowed_hfov_deg"],10.)
def test_floor_rejected_when_tick_coverage_or_episode_missing(self):
a=episode(start=1000.)
b=episode(start=1010.)
d=[r for r in episode(start=1020.) if r["event"]!="zoom_block_summary"]
_,candidate=run(a+b+d)
self.assertIsNone(candidate["cameras"]["19"]["next_floor_review"]["proposed_next_test_deg"])
e=episode(start=1030.)
e[3]["dropped_before"]=1
_,candidate=run(a+b+e)
self.assertIsNone(candidate["cameras"]["19"]["next_floor_review"]["proposed_next_test_deg"])
def test_episode_summary_counts_cumulative_snapshots_and_preserves_unknowns(self):
rows=episode()
rows.extend((
envelope(8,1000., "zoom_block_summary",1001.69, final=False,
zoom_block_reason={"min_hfov_limit":3,"edge_margin":4},
last_values={"edge_margin":{"measured":.22}}),
envelope(10,1020., "zoom_block_summary",1023., final=True,
zoom_block_reason={"bbox_check":3,"angle_tol":5},last_values={}),
))
for row in rows:
if row["event"]=="tick" and row["seq"] in (4,5):
row["zoom_cmd"]=-.10
report,_=run(rows)
ep, no=report["episodes"]
self.assertAlmostEqual(ep["t_to_first_zoom_s"],1.04)
self.assertEqual(ep["min_hfov_deg"],10.4)
self.assertEqual(ep["min_sampled_measured_edge_margin"],.22)
self.assertEqual(ep["negative_zoom_request_runs"],1)
self.assertEqual(ep["zoom_block_reason"],{"min_hfov_limit":5,"edge_margin":4})
self.assertIsNone(ep["tele_center_fraction"])
self.assertIsNone(ep["confirmed_safety_step_back_count"])
self.assertEqual(no["classification"],"no_positive_ack_observed")
self.assertEqual(no["top_block_reasons"],[("angle_tol",5),("bbox_check",3)])
def test_optional_matched_frames_provide_time_weighted_center_and_acks(self):
rows=episode()
ticks=[r for r in rows if r["event"]=="tick"]
observations=[dict(event="frame_observation",seq=r["seq"],frame_utc=r["frame_utc"],
dx_norm=.20 if r["seq"]==5 else .05,dy_norm=0.,measured_edge_margin=.24)
for r in ticks if r["seq"]>=4]
ack=dict(event="safety_step_back_ack",command_seq=30,utc=1001.4)
observed={(8,4,1000.):observations+[ack,ack]}
report,_=run(rows,observed)
ep=report["episodes"][0]
self.assertAlmostEqual(ep["tele_center_covered_s"],.27)
self.assertAlmostEqual(ep["tele_center_fraction"],.17/.27)
self.assertEqual(ep["min_independently_measured_edge_margin"],.24)
self.assertEqual(ep["confirmed_safety_step_back_count"],1)
def test_cli_directory_file_duplicates_and_custom_baseline(self):
with TemporaryDirectory() as work:
root=Path(work)
data=root/"in"
data.mkdir()
rows=sum((episode(start=1000.+i*10) for i in range(3)), [])
write(data/"samples.jsonl",rows)
write(root/"copy.jsonl",rows)
profile=root/"profile.json"
profile.write_text(json.dumps({"cameras":{"19":{"predictive_zoom":
{"nominal_gain":.52,"upper_gain":1.1,"min_allowed_hfov_deg":10.,
"latency_horizon_ms":245.}}}}),encoding="utf-8")
out=root/"out"
command=[sys.executable,str(Path(c.__file__)),str(data),str(root/"copy.jsonl"),
"--output-dir",str(out),"--profile",str(profile)]
subprocess.run(command,check=True,capture_output=True,text=True)
cand=json.loads((out/"native10_calibrated.json").read_bytes())
report=json.loads((out/"field_report.json").read_bytes())
self.assertEqual(report["input"]["duplicate_rows"],len(rows))
self.assertEqual(cand["cameras"]["19"]["baseline_predictive_zoom"]["nominal_gain"],.52)
self.assertEqual(cand["cameras"]["19"]["predictive_zoom_for_review"]["latency_horizon_ms"],245.)
self.assertIn("1,72 с",(out/"field_report.md").read_text(encoding="utf-8"))
def test_bad_input_leaves_no_outputs(self):
with TemporaryDirectory() as work:
path=Path(work)/"malformed.jsonl"
path.write_text('{"event":"tick","cam":8}\n',encoding="utf-8")
out=Path(work)/"out"
with self.assertRaises(ValueError):
c.load_episodes([path])
self.assertFalse(out.exists())
if __name__ == "__main__":
unittest.main()