Compare commits
8 Commits
main
...
feature/pt
| Author | SHA1 | Date |
|---|---|---|
|
|
a7a017e7d1 | 2 weeks ago |
|
|
a25d2bfc0f | 2 weeks ago |
|
|
3b92c16bef | 2 weeks ago |
|
|
0733a4b95c | 2 weeks ago |
|
|
273fb58c31 | 2 weeks ago |
|
|
fbf8017665 | 2 weeks ago |
|
|
dc6c03f594 | 2 weeks ago |
|
|
5a2a2e9822 | 2 weeks ago |
@ -0,0 +1,6 @@
|
|||||||
|
integration/ptz_zoom_zero_decision/server.patch text eol=lf -whitespace
|
||||||
|
integration/ptz_native_floor_continuation/server.patch text eol=lf -whitespace
|
||||||
|
integration/ptz_same_native_diagnostics/server.patch text eol=lf -whitespace
|
||||||
|
integration/ptz_zoom_threshold_diagnostics/server.patch text eol=lf -whitespace
|
||||||
|
integration/ptz_predictive_zoom/server.patch text eol=lf -whitespace
|
||||||
|
integration/ptz_predictive_zoom/*.py text eol=lf
|
||||||
@ -0,0 +1,12 @@
|
|||||||
|
{
|
||||||
|
"requires": "PTZ zoom decision PR #4",
|
||||||
|
"files": {
|
||||||
|
"ptz_tracker_modular/postprocess.py": {
|
||||||
|
"before": "8eb5f6beb79141ef1f1ce9dbad3577006821202557a87c7195e770bbba7b4ba3",
|
||||||
|
"after": "376f705fb3be06ab04afc1ebb718cb71a2c27a67987023b099f5d921148b64ad"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"unchanged": {
|
||||||
|
"ptz_tracker_modular/ptz_io.py": "13d31539193b1a773a5d1db2187cc2a0c8db67d0aacaad89082face64df07499"
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,37 @@
|
|||||||
|
--- a/ptz_tracker_modular/postprocess.py
|
||||||
|
+++ b/ptz_tracker_modular/postprocess.py
|
||||||
|
@@ -4619,10 +4619,33 @@
|
||||||
|
if useful_cmd > 0.0:
|
||||||
|
# A useful-pulse caller revalidates its entire framing envelope on
|
||||||
|
# every frame. Never turn one accepted pulse into 10 -> 5 -> 1.
|
||||||
|
+ below_useful = float(zoom_cmd) < useful_cmd - 1e-9
|
||||||
|
+ same_native = False
|
||||||
|
+ if below_useful and (
|
||||||
|
+ pulse_kind == st.get("zoom_step_pending_kind") == "normal"
|
||||||
|
+ and pulse_timing is not None
|
||||||
|
+ and optics_observed_now is not None
|
||||||
|
+ and max(float(now), float(optics_observed_now)) < pulse_until
|
||||||
|
+ and not st.get("zoom_stop_obligation_active", False)
|
||||||
|
+ and st.get("zoom_step_stop_started", False)
|
||||||
|
+ and st.get("zoom_step_stop_timer") is not None
|
||||||
|
+ and st.get("zoom_step_stop_source") == "track"
|
||||||
|
+ and st.get("zoom_step_stop_direction") == 1
|
||||||
|
+ and st.get("zoom_step_stop_generation") == st.get("ptz_generation")
|
||||||
|
+ ):
|
||||||
|
+ # A newly authorized fraction in the same native bucket
|
||||||
|
+ # sends the same lens speed for the original owned pulse.
|
||||||
|
+ native = _zoom_speed_to_int(useful_cmd)
|
||||||
|
+ same_native = (
|
||||||
|
+ 10 <= native <= 12
|
||||||
|
+ and _zoom_speed_to_int(zoom_cmd) == native
|
||||||
|
+ and _zoom_speed_to_int(pulse_floor) == native
|
||||||
|
+ and _zoom_native_pending_matches(st, native)
|
||||||
|
+ )
|
||||||
|
if (
|
||||||
|
not math.isfinite(float(pulse_floor))
|
||||||
|
or float(pulse_floor) <= 0.0
|
||||||
|
- or float(zoom_cmd) < useful_cmd - 1e-9
|
||||||
|
+ or (below_useful and not same_native)
|
||||||
|
or float(getattr(config, "ZOOM_STEP_MAX_IN_CMD", 0.12)) < useful_cmd
|
||||||
|
):
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
{
|
||||||
|
"baseline_tests": 16,
|
||||||
|
"candidate_tests": 16,
|
||||||
|
"matched_real_stop_windows": 2,
|
||||||
|
"fractional_frame_inputs": "synthetic",
|
||||||
|
"original_nominal_and_hard_deadlines_preserved": true,
|
||||||
|
"matched_earlier_worker_cases": 19,
|
||||||
|
"unchanged_controller_frames": 23,
|
||||||
|
"exact_patch_round_trip": true,
|
||||||
|
"real_device_or_model_access": false
|
||||||
|
}
|
||||||
@ -0,0 +1,45 @@
|
|||||||
|
{
|
||||||
|
"scope": "offline_replay_only",
|
||||||
|
"production_enable": false,
|
||||||
|
"cameras": {
|
||||||
|
"19": {
|
||||||
|
"paired_pulses": 3,
|
||||||
|
"observed_effective_log_rate_range": [
|
||||||
|
0.26096,
|
||||||
|
0.51553
|
||||||
|
],
|
||||||
|
"replay_settings": {
|
||||||
|
"nominal_gain": 0.44648,
|
||||||
|
"upper_gain": 0.95109
|
||||||
|
},
|
||||||
|
"telephoto_rate_measured": false
|
||||||
|
},
|
||||||
|
"21": {
|
||||||
|
"paired_pulses": 2,
|
||||||
|
"observed_effective_log_rate_range": [
|
||||||
|
0.40197,
|
||||||
|
0.59657
|
||||||
|
],
|
||||||
|
"replay_settings": {
|
||||||
|
"nominal_gain": 0.73468,
|
||||||
|
"upper_gain": 1.09732
|
||||||
|
},
|
||||||
|
"telephoto_rate_measured": false
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"validation": {
|
||||||
|
"wide_pairs": 12,
|
||||||
|
"narrow_pairs": 8,
|
||||||
|
"narrow_lateral_acceleration_pairs": 4,
|
||||||
|
"first_zoom_speedup_s_range": [
|
||||||
|
0.0,
|
||||||
|
2.7
|
||||||
|
],
|
||||||
|
"candidate_smallest_model_margin_narrow": 0.2164,
|
||||||
|
"candidate_smallest_model_margin_lateral": 0.1844,
|
||||||
|
"candidate_model_edge_clips": 0,
|
||||||
|
"confirmed_live_retention_or_speed": false,
|
||||||
|
"additional_put_rtt_pairs": 8,
|
||||||
|
"candidate_smallest_model_margin_put_rtt_narrow": 0.1852
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,17 @@
|
|||||||
|
{
|
||||||
|
"postprocess.py": {
|
||||||
|
"before": "776b5b337e5f898e69770fec517c4459560f4cc6adeb951af40ac8f0b2178534",
|
||||||
|
"after": "82ba632e7e2696e5b48daa99e77741482b98a02103eaf7fb416c58fd686e4327"
|
||||||
|
},
|
||||||
|
"ptz_io.py": {
|
||||||
|
"before": "13d31539193b1a773a5d1db2187cc2a0c8db67d0aacaad89082face64df07499",
|
||||||
|
"after": "0b0651b0e0344e4f78aeaf01f76c969d0043148a4ac92e4b7b6fd4a5f0d6a2e7"
|
||||||
|
},
|
||||||
|
"status.py": {
|
||||||
|
"before": "2fca9a2000c2cac9af42ad3f637416c66e1bb87f2f8166c7aefbbebbe5d07b06",
|
||||||
|
"after": "820db8615638c728d1017ea365f3d16b95edfe61dbb684ba0cda8de051ea8bd1"
|
||||||
|
},
|
||||||
|
"zoom_controller.py": {
|
||||||
|
"after": "7197baba29976215b05f6f86ae1563e8b5c28b314a80894600ede517de00f91e"
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,73 @@
|
|||||||
|
"""Render an episode JSONL as a static SVG without plotting dependencies."""
|
||||||
|
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
from pathlib import Path
|
||||||
|
from xml.sax.saxutils import escape
|
||||||
|
|
||||||
|
|
||||||
|
def render(rows):
|
||||||
|
samples = sorted((r for r in rows if r["event"] == "tick"), key=lambda r: r["elapsed_ms"])
|
||||||
|
if not samples:
|
||||||
|
raise ValueError("The episode has no TRACK ticks.")
|
||||||
|
last = max(1.0, samples[-1]["elapsed_ms"])
|
||||||
|
groups = (
|
||||||
|
("HFOV (deg)", 60.0, (
|
||||||
|
("ISAPI actual", "#2563eb", lambda r: r["FOV_actual"]),
|
||||||
|
("Estimated", "#c2410c", lambda r: r["FOV_estimated"]),
|
||||||
|
("Narrow bound", "#64748b", lambda r: r["FOV_min_estimated"]),
|
||||||
|
)),
|
||||||
|
("BBox (px)", max(48.0, max(max(r["bbox_px"]) for r in samples)), (
|
||||||
|
("Width", "#2563eb", lambda r: r["bbox_px"][0]),
|
||||||
|
("Height", "#c2410c", lambda r: r["bbox_px"][1]),
|
||||||
|
)),
|
||||||
|
("Confidence", 1.0, (
|
||||||
|
("YOLO last match", "#2563eb", lambda r: r["detector_conf"]),
|
||||||
|
("OSTrack score", "#c2410c", lambda r: r["tracker_score"]),
|
||||||
|
)),
|
||||||
|
)
|
||||||
|
content = [
|
||||||
|
'<svg xmlns="http://www.w3.org/2000/svg" width="980" height="680" viewBox="0 0 980 680">',
|
||||||
|
'<rect width="100%" height="100%" fill="white"/>',
|
||||||
|
'<g fill="#0f172a" font-family="sans-serif" font-size="15">',
|
||||||
|
f'<text x="68" y="27">PTZ {escape(str(samples[0]["cam"]))} · TRACK telemetry</text>',
|
||||||
|
]
|
||||||
|
first = next((r.get("t_to_first_zoom_ms") for r in rows if r["event"] == "first_zoom"), None)
|
||||||
|
for panel, (title, ymax, series) in enumerate(groups):
|
||||||
|
y0 = 76 + 190 * panel
|
||||||
|
plot_h = 133
|
||||||
|
content.append(f'<text x="68" y="{y0-12}">{title}</text>')
|
||||||
|
content.append(f'<path d="M68 {y0} v{plot_h} h850" fill="none" stroke="#94a3b8"/>')
|
||||||
|
for frac in (0, .5, 1):
|
||||||
|
content.append(f'<text x="17" y="{y0 + plot_h * (1-frac) + 5}">{ymax*frac:.1f}</text>')
|
||||||
|
for number, (label, color, extract) in enumerate(series):
|
||||||
|
content.append(f'<text fill="{color}" x="{265 + 170 * number}" y="{y0-12}">{label}</text>')
|
||||||
|
path = []
|
||||||
|
for row in samples:
|
||||||
|
value = extract(row)
|
||||||
|
if value is None:
|
||||||
|
if path and path[-1]:
|
||||||
|
path.append("")
|
||||||
|
continue
|
||||||
|
x = 68 + 850 * row["elapsed_ms"] / last
|
||||||
|
y = y0 + plot_h * (1 - value / ymax)
|
||||||
|
command = "L" if path and path[-1] else "M"
|
||||||
|
path.append(f"{command}{x:.1f} {y:.1f}")
|
||||||
|
content.append(f'<path d="{" ".join(path)}" stroke="{color}" stroke-width="2" fill="none"/>')
|
||||||
|
if first is not None and 0 <= first <= last:
|
||||||
|
x = 68 + 850 * first / last
|
||||||
|
content.append(f'<path d="M{x:.1f} {y0} v{plot_h}" stroke="#334155" stroke-dasharray="3 3"/>')
|
||||||
|
for k in range(6):
|
||||||
|
content.append(f'<text x="{68 + 170*k}" y="623">{last*k/5000:.2f}</text>')
|
||||||
|
content.append('<text x="68" y="654">Seconds since TRACK_START. Dashed marker = first acknowledged zoom.</text>')
|
||||||
|
content.append('</g></svg>')
|
||||||
|
return "\n".join(content) + "\n"
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
parser = argparse.ArgumentParser(description=__doc__)
|
||||||
|
parser.add_argument("episode", type=Path)
|
||||||
|
parser.add_argument("output", type=Path)
|
||||||
|
args = parser.parse_args()
|
||||||
|
rows = [json.loads(line) for line in args.episode.read_text(encoding="utf-8").splitlines() if line]
|
||||||
|
args.output.write_text(render(rows), encoding="utf-8")
|
||||||
@ -0,0 +1,42 @@
|
|||||||
|
from pathlib import Path
|
||||||
|
import json, os, sys
|
||||||
|
|
||||||
|
v,z,root,variant=map(Path,sys.argv[1:])
|
||||||
|
candidate=v/"ptz_predictive_zoom_candidate_20261111"
|
||||||
|
pr7=v/"ptz_zoom_threshold_diagnostics_20261111"
|
||||||
|
pins=json.loads((z/"pins.json").read_text())
|
||||||
|
dest=v/f"predictive_zoom_regression_{variant}.json"
|
||||||
|
before=str(variant)=="before"
|
||||||
|
p=(v/"ptz_zoom_threshold_maintenance_20261111" if before else candidate)/"postprocess.py"
|
||||||
|
i=(v/"ptz_zoom_zero_decision_20261109" if before else candidate)/"ptz_io.py"
|
||||||
|
s=(v/"ptz_monitor/server_unknown_source_20261109_043525" if before else candidate)/"status.py"
|
||||||
|
source=v/"ptz_monitor/server_unknown_source_20261109_043525"
|
||||||
|
key="before" if before else "after"
|
||||||
|
sys.path.insert(0,str(pr7))
|
||||||
|
if not before:
|
||||||
|
sys.path.insert(0,str(z))
|
||||||
|
sys.argv=[str(pr7/"replay.py"),str(source),str(i),
|
||||||
|
str(v/"ptz_zoom_stop_maintenance_20261109/ssh_7c7ae84464cc400dbc7dc1327124bbf7/telemetry.json"),
|
||||||
|
str(v/"cc1_cc2_control_replay_20261026/test_control_replay.py"),str(p),
|
||||||
|
pins["postprocess.py"][key],pins["ptz_io.py"][key],str(root),str(dest),
|
||||||
|
str(v/"ptz_zoom_zero_maintenance_20261109/ssh_8f0f9accd24b4f40b6466d0566cafbce/telemetry.json"),"fixed","--thresholds"]
|
||||||
|
r=(pr7/"replay.py").read_text(encoding="utf-8")
|
||||||
|
if not before:
|
||||||
|
r=r.replace(" ptz_io=load",f" load(PKG+'.zoom_controller', Path({str(z/'zoom_controller.py')!r}))\n ptz_io=load")
|
||||||
|
r=r.replace(" pp=load",f" status=load(PKG+'.status', Path({str(s)!r}))\n pp=load")
|
||||||
|
r=r.replace(" result=unittest.TextTestRunner", """ from track_integration import TRACE as zoom_trace, build_track_cases
|
||||||
|
integration = build_track_cases(before, pp, ptz_io, config, state, status)
|
||||||
|
for case in ("test_track_runs_burst_without_post_stop_status",
|
||||||
|
"test_track_same_flight_legacy_reference",
|
||||||
|
"test_track_starts_at_26_percent_of_half_frame",
|
||||||
|
"test_track_legacy_reference_at_26_percent_of_half_frame",
|
||||||
|
"test_priority_zoom_stop_honors_axis_policy",
|
||||||
|
"test_priority_zoom_stop_does_not_override_full_stop"):
|
||||||
|
suite.addTest(integration(case))
|
||||||
|
result=unittest.TextTestRunner""")
|
||||||
|
r=r.replace(" result_file=Path", f""" if result.wasSuccessful():
|
||||||
|
Path({str(v/"predictive_zoom_simulated_episode.jsonl")!r}).write_text(
|
||||||
|
"".join(json.dumps(row, allow_nan=False) + "\\n" for row in zoom_trace), encoding="utf-8")
|
||||||
|
result_file=Path""")
|
||||||
|
code=compile(r,str(pr7/"replay.py"),"exec")
|
||||||
|
exec(code,{"__file__":str(pr7/"replay.py"),"__name__":"__main__"})
|
||||||
@ -0,0 +1,377 @@
|
|||||||
|
--- a/postprocess.py
|
||||||
|
+++ b/postprocess.py
|
||||||
|
@@ -10,6 +10,7 @@
|
||||||
|
import cv2
|
||||||
|
|
||||||
|
from . import config, state, visual_control
|
||||||
|
+from .zoom_controller import ZoomFrame, controller_for_track, telemetry_tick
|
||||||
|
from . import motion_detector
|
||||||
|
from .utils import (
|
||||||
|
clipf,
|
||||||
|
@@ -30,6 +31,7 @@
|
||||||
|
_zoom_command_lock,
|
||||||
|
zoom_step_optics_delta,
|
||||||
|
_zoom_speed_to_int,
|
||||||
|
+ stop_predictive_zoom_async,
|
||||||
|
)
|
||||||
|
from .geom import ang_diff_signed, sector_contains
|
||||||
|
from .patrol import (
|
||||||
|
@@ -4597,6 +4599,7 @@
|
||||||
|
optics_observed_now: float | None = None,
|
||||||
|
stop_trace: list[str] | None = None,
|
||||||
|
continuation_trace: list[tuple[int, int, float, float, float, float, float]] | None = None,
|
||||||
|
+ predictive=None,
|
||||||
|
) -> float:
|
||||||
|
"""Break continuous zoom-in into short feedback-controlled steps."""
|
||||||
|
pulse_until = float(st.get("zoom_step_until", 0.0) or 0.0)
|
||||||
|
@@ -4706,18 +4709,23 @@
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
|
return 0.0
|
||||||
|
if pulse_until <= 0.0:
|
||||||
|
- if (
|
||||||
|
+ observed = now if optics_observed_now is None else optics_observed_now
|
||||||
|
+ early_repeat = bool(predictive and predictive.repeat_after_stop(st, observed))
|
||||||
|
+ if not early_repeat and (
|
||||||
|
float(now) < cooldown_until
|
||||||
|
or float(now) < float(st.get("zoom_recenter_until", 0.0) or 0.0)
|
||||||
|
):
|
||||||
|
return 0.0
|
||||||
|
- if (
|
||||||
|
+ if early_repeat:
|
||||||
|
+ # The original transaction is already committed. Consume its single
|
||||||
|
+ # credit under the transport lock, before publishing a new request.
|
||||||
|
+ predictive.confirmed_stop = None
|
||||||
|
+ st["zoom_feedback_required_after"] = 0.0
|
||||||
|
+ elif (
|
||||||
|
int(st.get("zoom_in_pulse_count", 0) or 0) > 0
|
||||||
|
or float(st.get("zoom_feedback_required_after", 0.0) or 0.0) > 0.0
|
||||||
|
):
|
||||||
|
- feedback_ready, feedback_reason = _zoom_optics_feedback_state(
|
||||||
|
- st, now if optics_observed_now is None else optics_observed_now,
|
||||||
|
- )
|
||||||
|
+ feedback_ready, feedback_reason = _zoom_optics_feedback_state(st, observed)
|
||||||
|
if not feedback_ready:
|
||||||
|
st["zoom_followup_reason"] = str(feedback_reason)
|
||||||
|
return 0.0
|
||||||
|
@@ -8778,6 +8786,74 @@
|
||||||
|
react_margin = clipf(react_margin_base + react_margin_gain * vel, react_margin_base, react_margin_max)
|
||||||
|
near_react_edge = min_margin < react_margin
|
||||||
|
|
||||||
|
+ predictive = None
|
||||||
|
+ predictive_frame = None
|
||||||
|
+ predictive_decision = None
|
||||||
|
+ if cfg_ptz.get("predictive_zoom") is not None:
|
||||||
|
+ with _zoom_command_lock(cam_idx):
|
||||||
|
+ predictive = controller_for_track(st, cfg_ptz)
|
||||||
|
+ if predictive is not None:
|
||||||
|
+ decision_wall = time.time()
|
||||||
|
+ sample_is_current = bool(
|
||||||
|
+ visual_sample is not None
|
||||||
|
+ and visual_control.current(
|
||||||
|
+ cam_idx, visual_sample, decision_wall,
|
||||||
|
+ max_age=predictive.cfg.frame_age_s,
|
||||||
|
+ )
|
||||||
|
+ )
|
||||||
|
+ predictive_frame = ZoomFrame(
|
||||||
|
+ at=now, seq=int(source_seq or 0),
|
||||||
|
+ offset=(measured_dx, measured_dy),
|
||||||
|
+ bbox_frac=(w_frac, h_frac), bbox_px=(x2 - x1, y2 - y1),
|
||||||
|
+ angles=(los_pan_angle_deg, los_tilt_angle_deg),
|
||||||
|
+ rates=(los_pan_rate_deg_s, los_tilt_rate_deg_s),
|
||||||
|
+ aspect=h / w,
|
||||||
|
+ tracker_score=(
|
||||||
|
+ float(st.get("visual_tracker_score", 0.0) or 0.0)
|
||||||
|
+ if current_track_source == "visual" else None
|
||||||
|
+ ),
|
||||||
|
+ detector_at=(last_visual_zoom_validation if normal_zoom_quality_ok
|
||||||
|
+ and last_visual_zoom_validation == last_visual_control_validation else 0.0),
|
||||||
|
+ detector_conf=float(st.get("visual_tracker_last_detector_conf", 0.0) or 0.0),
|
||||||
|
+ geometry_ok=bool(
|
||||||
|
+ sample_is_current and not st.get("visual_tracker_mismatch_frames")
|
||||||
|
+ and _zoom_revalidation_ready(st)
|
||||||
|
+ ),
|
||||||
|
+ los_valid=bool(
|
||||||
|
+ st.get("aim_los_rate_valid")
|
||||||
|
+ or predictive.request is not None
|
||||||
|
+ or predictive.repeat_after_stop(st, decision_wall)
|
||||||
|
+ or (st.get("zoom_step_pending") and predictive.history)
|
||||||
|
+ ),
|
||||||
|
+ )
|
||||||
|
+ skip_wait = predictive.repeat_after_stop(st, decision_wall)
|
||||||
|
+ same_pending = bool(
|
||||||
|
+ st.get("zoom_step_pending")
|
||||||
|
+ and st.get("predictive_zoom_request") == st.get("zoom_step_pending_id")
|
||||||
|
+ and not st.get("zoom_step_cancel_requested")
|
||||||
|
+ and not st.get("zoom_step_discard_on_finalize")
|
||||||
|
+ )
|
||||||
|
+ predictive_decision = predictive.decide(
|
||||||
|
+ predictive_frame, decision_wall,
|
||||||
|
+ first=pulse_count == 0 and predictive.first_ack_at is None,
|
||||||
|
+ cooldown=not skip_wait and decision_wall < max(
|
||||||
|
+ float(st.get("zoom_step_cooldown_until", 0.0) or 0.0),
|
||||||
|
+ float(st.get("zoom_recenter_until", 0.0) or 0.0),
|
||||||
|
+ ),
|
||||||
|
+ transport_clear=bool(
|
||||||
|
+ same_pending or skip_wait or (pulse_count == 0
|
||||||
|
+ and not st.get("zoom_feedback_required_after")
|
||||||
|
+ and not st.get("zoom_step_feedback_pending"))
|
||||||
|
+ or _zoom_optics_feedback_state(st, decision_wall)[0]
|
||||||
|
+ ) and not (
|
||||||
|
+ st.get("zoom_stop_obligation_active")
|
||||||
|
+ or st.get("lens_move_stop_required")
|
||||||
|
+ or st.get("zoom_step_cancel_requested")
|
||||||
|
+ or st.get("zoom_no_effect_blocked")
|
||||||
|
+ or (st.get("zoom_step_pending") and not same_pending)
|
||||||
|
+ ),
|
||||||
|
+ )
|
||||||
|
+
|
||||||
|
zoom_quality_ok = bool(
|
||||||
|
normal_zoom_quality_ok
|
||||||
|
or probe_allowed
|
||||||
|
@@ -8819,6 +8895,21 @@
|
||||||
|
pan_rate_deg_s=float(los_pan_rate_deg_s),
|
||||||
|
tilt_rate_deg_s=float(los_tilt_rate_deg_s),
|
||||||
|
)
|
||||||
|
+ predictive_entry = bool(
|
||||||
|
+ predictive_decision and predictive_decision.window
|
||||||
|
+ and normal_zoom_quality_ok and not bounded_identification_request
|
||||||
|
+ and not st.get("zoom_probe_active", False)
|
||||||
|
+ and not _zoom_identify_matches_current_track(st)
|
||||||
|
+ and not st.get("zoom_stop_obligation_active")
|
||||||
|
+ and not st.get("zoom_step_cancel_requested")
|
||||||
|
+ )
|
||||||
|
+ predictive_continuing = bool(
|
||||||
|
+ predictive_decision and same_pending and not predictive_decision.stop
|
||||||
|
+ and (predictive_decision.window or predictive_decision.reason == "pulse_active")
|
||||||
|
+ and normal_zoom_quality_ok and not bounded_identification_request
|
||||||
|
+ )
|
||||||
|
+ if (predictive_entry and (skip_wait or same_pending)) or predictive_continuing:
|
||||||
|
+ followup_ready = True
|
||||||
|
angular_rejection = {} if pulse_active else None
|
||||||
|
zoom_angular_safe = followup_ready and _zoom_angular_motion_safe(
|
||||||
|
pan_error_deg=float(los_pan_angle_deg),
|
||||||
|
@@ -8832,6 +8923,9 @@
|
||||||
|
)
|
||||||
|
if approach_margin is not None and followup_ready:
|
||||||
|
zoom_angular_safe = True
|
||||||
|
+ if (predictive_entry or predictive_continuing) and followup_ready:
|
||||||
|
+ zoom_angular_safe = True
|
||||||
|
+ zoom_safe, zoom_safe_scale = True, 1.0
|
||||||
|
st["zoom_safe_pred_margin"] = float(zoom_pred_margin)
|
||||||
|
st["zoom_safe_center_limit"] = float(zoom_center_max)
|
||||||
|
st["zoom_quality_ok"] = bool(zoom_quality_ok)
|
||||||
|
@@ -8952,6 +9046,7 @@
|
||||||
|
or bounded_identification_request
|
||||||
|
)
|
||||||
|
zoom_rearm_ready = _zoom_revalidation_ready(st)
|
||||||
|
+ stable_ok = stable_ok or predictive_entry or predictive_continuing
|
||||||
|
can_zoom_in = (
|
||||||
|
zoom_safe
|
||||||
|
and zoom_angular_safe
|
||||||
|
@@ -9099,6 +9194,14 @@
|
||||||
|
zoom_zero_reason = "deadband"
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
|
||||||
|
+ predictive_drive = bool(
|
||||||
|
+ (predictive_entry or predictive_continuing) and can_zoom_in and raw_zoom_needed
|
||||||
|
+ and prev_z >= 0.0 and not want_out
|
||||||
|
+ and not normal_size_hold and not edge_recovery_active
|
||||||
|
+ and float(getattr(config, "ZOOM_STEP_MAX_IN_CMD", 0.12)) >= 0.10
|
||||||
|
+ )
|
||||||
|
+ if predictive_drive:
|
||||||
|
+ zoom_cmd = 0.10
|
||||||
|
zoom_after_size_minimum = zoom_cmd
|
||||||
|
cmd_mag_est = max(
|
||||||
|
abs(float(pan_speed) + float(pan_rate_ff)),
|
||||||
|
@@ -9151,7 +9254,7 @@
|
||||||
|
center_err=float(center_err),
|
||||||
|
moving_out=bool(moving_out),
|
||||||
|
recent_zoom=bool(recent_zoom_steering),
|
||||||
|
- approach_margin=approach_margin,
|
||||||
|
+ approach_margin=(predictive_decision.margin if predictive_drive else approach_margin),
|
||||||
|
)
|
||||||
|
if before_recenter > 0.0 and zoom_cmd <= 0.0:
|
||||||
|
zoom_zero_reason = "recenter"
|
||||||
|
@@ -9272,6 +9375,25 @@
|
||||||
|
proposed_zoom_cmd = max(zoom_cmd, min(pre_ramp_zoom_cmd, pulse_cap, .12))
|
||||||
|
if _zoom_native_response_available(st, _zoom_speed_to_int(proposed_zoom_cmd), hfov_deg, shared_wide_hfov):
|
||||||
|
zoom_cmd = proposed_zoom_cmd
|
||||||
|
+ # A separately checked predictive window supplies the normal native-10
|
||||||
|
+ # shape. Preserve the original ticket and timing on subsequent frames.
|
||||||
|
+ predictive_active = bool(
|
||||||
|
+ predictive_continuing and predictive_drive and can_zoom_in and zoom_cmd > 0.0
|
||||||
|
+ and pulse_family == "normal" and st.get("zoom_step_pending")
|
||||||
|
+ and predictive.owns(st)
|
||||||
|
+ and st.get("zoom_step_pending_id") == decision_request
|
||||||
|
+ and st.get("predictive_zoom_request") == decision_request
|
||||||
|
+ and 0 <= zoom_gate_now - now <= predictive.cfg.frame_age_s
|
||||||
|
+ )
|
||||||
|
+ predictive_start = bool(
|
||||||
|
+ predictive_entry and predictive_drive and pulse_family == "normal"
|
||||||
|
+ and zoom_cmd > 0.0 and not st.get("zoom_step_pending") and predictive.owns(st)
|
||||||
|
+ and not st.get("zoom_stop_obligation_active") and not st.get("lens_move_stop_required")
|
||||||
|
+ and 0 <= zoom_gate_now - now <= predictive.cfg.frame_age_s
|
||||||
|
+ and 0 <= zoom_gate_now - predictive_frame.detector_at <= predictive.cfg.detector_age_s
|
||||||
|
+ and predictive.optics.fresh(zoom_gate_now)
|
||||||
|
+ and (not skip_wait or predictive.repeat_after_stop(st, zoom_gate_now))
|
||||||
|
+ )
|
||||||
|
before_shape = zoom_cmd
|
||||||
|
zoom_cmd, useful_reason = _shape_useful_zoom_pulse(
|
||||||
|
zoom_cmd,
|
||||||
|
@@ -9299,6 +9421,21 @@
|
||||||
|
requested_native=timing_native,
|
||||||
|
rejection=response_rejection,
|
||||||
|
)
|
||||||
|
+ if predictive_start or (predictive_active and not near_edge and not edge_recovery_active
|
||||||
|
+ and zoom_rearm_ready and not normal_size_hold and not want_out):
|
||||||
|
+ zoom_cmd = 0.10
|
||||||
|
+ useful_reason = "useful"
|
||||||
|
+ st["zoom_useful_pulse_reason"] = useful_reason
|
||||||
|
+ response_timing = predictive_decision.window if predictive_start else (
|
||||||
|
+ float(st["zoom_step_pending_pulse_sec"]),
|
||||||
|
+ float(st["zoom_step_pending_hard_sec"]),
|
||||||
|
+ )
|
||||||
|
+ if predictive_decision and (
|
||||||
|
+ predictive_decision.stop or (predictive_decision.reason == "size_reached"
|
||||||
|
+ and pulse_family == "normal")
|
||||||
|
+ ):
|
||||||
|
+ zoom_cmd = min(zoom_cmd, 0.0)
|
||||||
|
+ zoom_zero_reason = predictive_decision.reason
|
||||||
|
if useful_reason == "useful" and response_timing == (0.0, 0.0):
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
st["zoom_useful_pulse_reason"] = "wait_response_framing"
|
||||||
|
@@ -9321,7 +9458,10 @@
|
||||||
|
optics_observed_now=zoom_gate_now,
|
||||||
|
stop_trace=gate_stop,
|
||||||
|
continuation_trace=continuation_trace,
|
||||||
|
- )
|
||||||
|
+ predictive=predictive if predictive_start else None,
|
||||||
|
+ )
|
||||||
|
+ if predictive_start and zoom_cmd > 0.0 and st["zoom_step_request_id"] > request_id_before_gate:
|
||||||
|
+ st["predictive_zoom_request"] = st["zoom_step_pending_id"]
|
||||||
|
if gate_stop:
|
||||||
|
zoom_zero_reason = gate_stop[-1]
|
||||||
|
decision_generation = st.get("ptz_generation")
|
||||||
|
@@ -9380,6 +9520,12 @@
|
||||||
|
|
||||||
|
adj_pan, adj_tilt = _shape_tracking_cmd(st, now, adj_pan, adj_tilt, center_err)
|
||||||
|
pan_feedback_cmd, tilt_feedback_cmd = float(adj_pan), float(adj_tilt)
|
||||||
|
+ if predictive_active and predictive.request is not None and zoom_cmd > 0.0:
|
||||||
|
+ pan_optical, tilt_optical = predictive_decision.ff_deg_s
|
||||||
|
+ pan_ref = max(1.0, float(cfg_ptz.get("ptz_pan_max_speed_deg_s", getattr(config, "AIM_PAN_SPEED_DEG_S", 160.0))))
|
||||||
|
+ tilt_ref = max(1.0, float(cfg_ptz.get("ptz_tilt_max_speed_deg_s", getattr(config, "AIM_TILT_SPEED_DEG_S", 120.0))))
|
||||||
|
+ pan_rate_ff += pan_optical / pan_ref
|
||||||
|
+ tilt_rate_ff += tilt_optical / tilt_ref
|
||||||
|
adj_pan, adj_tilt = _merge_gimbal_rate_feedforward(
|
||||||
|
st,
|
||||||
|
now,
|
||||||
|
@@ -9844,6 +9990,14 @@
|
||||||
|
("brake", final_guard_active),
|
||||||
|
) if blocked)
|
||||||
|
zoom_decision = (source_seq, decision_request, zoom_zero_reason, "+".join(blockers) or "-")
|
||||||
|
+ if predictive_decision is not None:
|
||||||
|
+ with _zoom_command_lock(cam_idx):
|
||||||
|
+ telemetry_tick(
|
||||||
|
+ config, cam_idx, predictive, predictive_frame, predictive_decision,
|
||||||
|
+ zoom_cmd, zoom_zero_reason, time.time(),
|
||||||
|
+ )
|
||||||
|
+ if predictive_decision.stop and predictive.request is not None:
|
||||||
|
+ stop_predictive_zoom_async(cam_idx, predictive, predictive_decision.reason)
|
||||||
|
dispatch_kwargs = {"force": force_track_ptz}
|
||||||
|
if zoom_decision is not None:
|
||||||
|
dispatch_kwargs["zoom_decision"] = zoom_decision
|
||||||
|
--- a/ptz_io.py
|
||||||
|
+++ b/ptz_io.py
|
||||||
|
@@ -14,6 +14,7 @@
|
||||||
|
from requests.adapters import HTTPAdapter
|
||||||
|
|
||||||
|
from . import config, state
|
||||||
|
+from .zoom_controller import transport_accepted, transport_confirmed, transport_stopped
|
||||||
|
from .utils import clipf, hfov_ptz_from_abs_zoom, hfov_ptz_from_zoom_ratio, quantf
|
||||||
|
from .geom import sector_contains, ang_diff_signed, normalize360
|
||||||
|
|
||||||
|
@@ -582,6 +583,10 @@
|
||||||
|
st["zoom_last_motion_at"] = float(now)
|
||||||
|
st["zoom_followup_reason"] = "physical_pulse"
|
||||||
|
st["zoom_step_last_delivery_result"] = "physical_started"
|
||||||
|
+ transport_accepted(
|
||||||
|
+ config, cam_idx, st, request_id, native_cmd, deadline_origin, now,
|
||||||
|
+ deadline_origin + hard_sec,
|
||||||
|
+ )
|
||||||
|
logger.info(
|
||||||
|
"[ZOOM DELIVERY] cam=%s request=%s kind=%s physical start seq=%s pulse=%.3fs hard=%.3fs",
|
||||||
|
cam_idx,
|
||||||
|
@@ -744,6 +749,8 @@
|
||||||
|
float(st.get("zoom_recenter_until", 0.0) or 0.0),
|
||||||
|
float(now) + float(getattr(config, "ZOOM_STEP_RECENTER_SEC", 0.14)),
|
||||||
|
)
|
||||||
|
+ if reason == "status_poll":
|
||||||
|
+ transport_confirmed(config, st, request_id, now)
|
||||||
|
logger.info(
|
||||||
|
"[ZOOM DELIVERY] cam=%s request=%s optics confirmed source=%s zstep=%s",
|
||||||
|
cam_idx,
|
||||||
|
@@ -922,6 +929,12 @@
|
||||||
|
+ max(0.0, float(getattr(config, "ZOOM_STEP_RETRY_COOLDOWN_SEC", 0.12))),
|
||||||
|
)
|
||||||
|
|
||||||
|
+ transport_stopped(
|
||||||
|
+ config, cam_idx, st, request_id, now, reason=reason,
|
||||||
|
+ confirmed=confirmed and not discard,
|
||||||
|
+ clean=bool(not discard and kind == "normal" and delivered + 1e-6 >= full_window
|
||||||
|
+ and stop_axes is not None and stop_axes[2] == 0),
|
||||||
|
+ )
|
||||||
|
st["zoom_step_last_delivered_sec"] = float(delivered)
|
||||||
|
st["zoom_step_pending"] = False
|
||||||
|
st["zoom_step_pending_id"] = 0
|
||||||
|
@@ -2119,6 +2132,35 @@
|
||||||
|
if zoom_decision is not None:
|
||||||
|
return cmd_source, cmd_generation, move_seq, zoom_i
|
||||||
|
return None
|
||||||
|
+
|
||||||
|
+
|
||||||
|
+def stop_predictive_zoom_async(cam_idx, controller, reason):
|
||||||
|
+ """Order an early lens STOP independently of the ordinary MOVE queue."""
|
||||||
|
+ with _zoom_command_lock(cam_idx):
|
||||||
|
+ st = state.ptz_states.get(cam_idx, {})
|
||||||
|
+ request = controller.request
|
||||||
|
+ if (not controller.owns(st) or request is None
|
||||||
|
+ or st.get("zoom_step_physical_request_id") != request
|
||||||
|
+ or st.get("predictive_zoom_early_stop") == request):
|
||||||
|
+ return
|
||||||
|
+ st["predictive_zoom_early_stop"] = request
|
||||||
|
+ st["zoom_step_cancel_requested"] = True
|
||||||
|
+
|
||||||
|
+ def stop_if_current():
|
||||||
|
+ with _zoom_command_lock(cam_idx):
|
||||||
|
+ current = state.ptz_states.get(cam_idx, {})
|
||||||
|
+ if (controller.owns(current)
|
||||||
|
+ and current.get("zoom_step_physical_request_id") == request):
|
||||||
|
+ _deliver_priority_lens_stop_locked(
|
||||||
|
+ cam_idx, current, reason=f"predictive:{reason}",
|
||||||
|
+ guard_inflight_after_put=_generic_put_has_lens_motion(current),
|
||||||
|
+ )
|
||||||
|
+
|
||||||
|
+ try:
|
||||||
|
+ threading.Thread(target=stop_if_current, name="ptz-predictive-stop", daemon=True).start()
|
||||||
|
+ except RuntimeError:
|
||||||
|
+ # The scheduled watchdog remains the independent hard STOP.
|
||||||
|
+ logger.exception("Unable to start early lens STOP cam=%s", cam_idx)
|
||||||
|
|
||||||
|
|
||||||
|
def stop_ptz(cam_idx: int, *, source: str = "stop", generation: Optional[int] = None) -> None:
|
||||||
|
--- a/status.py
|
||||||
|
+++ b/status.py
|
||||||
|
@@ -170,6 +170,13 @@
|
||||||
|
if isinstance(hfov_deg, (int, float)) and float(hfov_deg) > 0.0:
|
||||||
|
st["hfov_deg"] = float(hfov_deg)
|
||||||
|
st["zoom_status_at"] = zoom_observed_at
|
||||||
|
+ if config.CAMERA_CONFIG.get(int(cam_id), {}).get("predictive_zoom") is not None:
|
||||||
|
+ previous = st.get("predictive_zoom_hfov", (0.0, 0.0))
|
||||||
|
+ if zoom_observed_at > previous[0]:
|
||||||
|
+ st["predictive_zoom_hfov"] = (zoom_observed_at, float(hfov_deg))
|
||||||
|
+ controller = st.get("predictive_zoom_controller")
|
||||||
|
+ if controller is not None and controller.owns(st):
|
||||||
|
+ controller.optics.observe(zoom_observed_at, float(hfov_deg), float(now))
|
||||||
|
if isinstance(zoom_raw, (int, float)):
|
||||||
|
st["zoom_position_raw"] = float(zoom_raw)
|
||||||
|
st["zoom_position_tag"] = str(zoom_tag or "")
|
||||||
@ -0,0 +1,172 @@
|
|||||||
|
import math
|
||||||
|
from pathlib import Path
|
||||||
|
import tempfile
|
||||||
|
import unittest
|
||||||
|
|
||||||
|
from zoom_controller import EpisodeTelemetryLogger, OpticalStateEstimator, ZoomConfig, ZoomController, ZoomFrame
|
||||||
|
|
||||||
|
|
||||||
|
def frame(at, seq, *, offset=(0.13, -0.03), pixels=(20.0, 16.0),
|
||||||
|
detector_at=None, score=0.8, geometry=True):
|
||||||
|
return ZoomFrame(
|
||||||
|
at=at, seq=seq, offset=offset, bbox_frac=(pixels[0] / 1280, pixels[1] / 720),
|
||||||
|
bbox_px=pixels, angles=(0.0, 0.0), rates=(0.0, 0.0), aspect=720 / 1280,
|
||||||
|
tracker_score=score, detector_at=at if detector_at is None else detector_at,
|
||||||
|
detector_conf=0.71, geometry_ok=geometry, los_valid=True,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def tick(controller, sample, now=None, **kw):
|
||||||
|
flags = {"first": controller.first_ack_at is None, "cooldown": False, "transport_clear": True}
|
||||||
|
flags.update(kw)
|
||||||
|
return controller.decide(sample, sample.at if now is None else now, **flags)
|
||||||
|
|
||||||
|
|
||||||
|
class PredictiveZoomTests(unittest.TestCase):
|
||||||
|
def setUp(self):
|
||||||
|
self.cfg = ZoomConfig(nominal_gain=0.65, upper_gain=1.0)
|
||||||
|
self.c = ZoomController(self.cfg, (4, 100.0))
|
||||||
|
self.c.optics.observe(99.99, 59.0, 100.0)
|
||||||
|
|
||||||
|
def test_short_3_6_second_flight_with_delayed_yolo_and_status(self):
|
||||||
|
c = self.c
|
||||||
|
focal = math.tan(math.radians(59 / 2))
|
||||||
|
duration = 3.6
|
||||||
|
active = None
|
||||||
|
pulses, stops = [], []
|
||||||
|
actual_status = 99.99
|
||||||
|
between_without_poll = 0
|
||||||
|
last_stop = None
|
||||||
|
visible = 0
|
||||||
|
for k in range(181):
|
||||||
|
t = k * 0.02
|
||||||
|
now = 100.0 + t
|
||||||
|
if active is not None:
|
||||||
|
focal *= math.exp(-self.cfg.log_rate * 0.02)
|
||||||
|
actual = math.degrees(2 * math.atan(focal))
|
||||||
|
# One status response every 250 ms, no forced request after STOP.
|
||||||
|
if k % 13 == 8:
|
||||||
|
c.optics.observe(now, actual, now)
|
||||||
|
actual_status = now
|
||||||
|
if active and now >= active[1]:
|
||||||
|
pulse, _, started, status_at_start = active
|
||||||
|
confirmed = actual_status > status_at_start
|
||||||
|
c.stopped(pulse, now, confirmed=confirmed, clean=True)
|
||||||
|
stops.append(now)
|
||||||
|
active = None
|
||||||
|
last_stop = now
|
||||||
|
if k % 4 != 0:
|
||||||
|
continue
|
||||||
|
# Same aircraft, steady closing LOS and native-10 synthetic plant.
|
||||||
|
x = 0.129 - min(0.069, t * 0.12)
|
||||||
|
optical_scale = math.tan(math.radians(59 / 2)) / focal
|
||||||
|
px = (20 * optical_scale, 16 * optical_scale)
|
||||||
|
self.assertLess(abs(x) + px[0] / 2560, 0.5)
|
||||||
|
visible += 1
|
||||||
|
detector = 100.0 + math.floor((t + 1e-9) / 0.52) * 0.52
|
||||||
|
can_repeat = last_stop is None or c.can_reuse_feedback(now, last_stop) or actual_status > last_stop
|
||||||
|
decision = tick(c, frame(now, k + 1, offset=(x, -0.025), pixels=px,
|
||||||
|
detector_at=detector),
|
||||||
|
transport_clear=active is None and can_repeat)
|
||||||
|
if decision.window:
|
||||||
|
if last_stop is not None and actual_status <= last_stop:
|
||||||
|
between_without_poll += 1
|
||||||
|
self.assertIsNone(active)
|
||||||
|
pulse = len(pulses) + 1
|
||||||
|
nominal, hard = decision.window
|
||||||
|
c.accepted(pulse, now, now, now + hard)
|
||||||
|
active = pulse, now + nominal, now, actual_status
|
||||||
|
pulses.append(t)
|
||||||
|
else:
|
||||||
|
if decision.stop:
|
||||||
|
self.assertEqual(decision.reason, "size_reached")
|
||||||
|
c.stopped(active[0], now, clean=False, confirmed=False)
|
||||||
|
last_stop = now
|
||||||
|
stops.append(now)
|
||||||
|
active = None
|
||||||
|
self.assertEqual(visible, 46)
|
||||||
|
self.assertLess(pulses[0], 0.25)
|
||||||
|
self.assertGreaterEqual(len(pulses), 4)
|
||||||
|
self.assertGreaterEqual(between_without_poll, 2)
|
||||||
|
self.assertGreaterEqual(len(stops), 3)
|
||||||
|
self.assertLess(actual, 42.0)
|
||||||
|
|
||||||
|
def test_wide_entry_without_next_detector_and_narrow_entry_is_stricter(self):
|
||||||
|
for k in range(3):
|
||||||
|
self.assertEqual(tick(self.c, frame(100 + .08 * k, k + 1, detector_at=99.96)).reason,
|
||||||
|
"fast_start" if k == 2 else "low_tracker_score")
|
||||||
|
other = ZoomController(self.cfg, (4, 100))
|
||||||
|
other.optics.observe(99.99, 28.0, 100.0)
|
||||||
|
for k in range(3):
|
||||||
|
d = tick(other, frame(100 + .08 * k, k + 1, detector_at=99.96))
|
||||||
|
self.assertEqual(d.reason, "not_centered")
|
||||||
|
|
||||||
|
def test_reject_outward_low_score_and_expired_detector(self):
|
||||||
|
for k in range(3):
|
||||||
|
d = tick(self.c, frame(100 + .08 * k, k + 1, offset=(.075 + .003 * k, -.02)))
|
||||||
|
self.assertEqual(d.reason, "not_centered")
|
||||||
|
self.assertEqual(tick(self.c, frame(100.20, 4, score=.2)).reason, "low_tracker_score")
|
||||||
|
self.assertEqual(tick(self.c, frame(100.28, 5, detector_at=99.0)).reason, "waiting_yolo")
|
||||||
|
|
||||||
|
def test_positive_ff_and_edge_stop_preserve_request_deadline(self):
|
||||||
|
self.c.accepted(4, 100.0, 100.01, 100.4)
|
||||||
|
active = self.c.optics.active
|
||||||
|
d = tick(self.c, frame(100.05, 1, offset=(.08, -.05)))
|
||||||
|
self.assertGreater(d.ff_deg_s[0], 0)
|
||||||
|
self.assertLess(d.ff_deg_s[1], 0)
|
||||||
|
d = tick(self.c, frame(100.12, 2, offset=(.32, -.05)))
|
||||||
|
self.assertTrue(d.stop)
|
||||||
|
self.assertEqual(d.reason, "edge_margin_low")
|
||||||
|
self.assertEqual(d.ff_deg_s, (0.0, 0.0))
|
||||||
|
self.assertEqual(self.c.optics.active, active)
|
||||||
|
|
||||||
|
def test_edge_acceleration_can_stop_before_margin_crosses(self):
|
||||||
|
c = ZoomController(ZoomConfig(.28, .45, edge_accel=.1, edge_watch_margin=.35), (4, 100))
|
||||||
|
c.optics.observe(99.99, 59, 100)
|
||||||
|
c.accepted(2, 100, 100.01, 100.4)
|
||||||
|
for seq, off in enumerate((.145, .145, .153), 1):
|
||||||
|
decision = tick(c, frame(100 + seq * .06, seq, offset=(off, -.02)))
|
||||||
|
self.assertGreater(decision.margin, c.cfg.edge_margin)
|
||||||
|
self.assertEqual(decision.reason, "edge_acceleration")
|
||||||
|
self.assertTrue(decision.stop)
|
||||||
|
|
||||||
|
def test_causal_status_and_failed_or_ambiguous_stop_cannot_rearm(self):
|
||||||
|
c = self.c
|
||||||
|
c.accepted(4, 100.0, 100.01, 100.4)
|
||||||
|
before = c.optics.estimate(100.1)
|
||||||
|
c.optics.observe(100.18, 55, 100.2)
|
||||||
|
c.optics.observe(100.08, 57, 100.21)
|
||||||
|
self.assertEqual(c.optics.estimate(100.1), before)
|
||||||
|
self.assertEqual(c.optics.status_at, 100.18)
|
||||||
|
self.assertFalse(c.can_reuse_feedback(100.35, 100.34))
|
||||||
|
c.stopped(4, 100.34, confirmed=True, clean=False)
|
||||||
|
self.assertFalse(c.can_reuse_feedback(100.35, 100.34))
|
||||||
|
|
||||||
|
def test_fov_curves_and_watchdog_bounds(self):
|
||||||
|
self.assertEqual(self.cfg.window(59), (.34, .40))
|
||||||
|
self.assertEqual(self.cfg.window(10), (.12, .18))
|
||||||
|
self.assertGreater(self.cfg.window(21)[0], self.cfg.window(13)[0])
|
||||||
|
for invalid in (dict(wide_pulse_s=.5), dict(native=20), dict(frame_age_s=.26),
|
||||||
|
dict(upper_gain=.4), dict(nominal_gain=float("nan"))):
|
||||||
|
args = {"nominal_gain": .65, "upper_gain": 1.0}
|
||||||
|
args.update(invalid)
|
||||||
|
with self.assertRaises(ValueError):
|
||||||
|
ZoomConfig(**args)
|
||||||
|
|
||||||
|
def test_telemetry_writes_first_and_ticks_separately(self):
|
||||||
|
import json
|
||||||
|
with tempfile.TemporaryDirectory() as directory:
|
||||||
|
logger = EpisodeTelemetryLogger(directory)
|
||||||
|
logger.submit(8, (4, 100.0), "first_zoom", 100.2, t_to_first_zoom_ms=200)
|
||||||
|
logger.submit(8, (4, 100.0), "tick", 100.25, FOV_actual=59.0,
|
||||||
|
FOV_estimated=57.0, bbox_px=[20, 16], detector_conf=.71)
|
||||||
|
logger.queue.join()
|
||||||
|
path, = Path(directory).glob("*.jsonl")
|
||||||
|
first, second = map(json.loads, path.read_text().splitlines())
|
||||||
|
self.assertEqual(first["t_to_first_zoom_ms"], 200)
|
||||||
|
self.assertEqual(second["elapsed_ms"], 250)
|
||||||
|
self.assertEqual(second["FOV_estimated"], 57)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
@ -0,0 +1,156 @@
|
|||||||
|
"""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
|
||||||
@ -0,0 +1,12 @@
|
|||||||
|
{
|
||||||
|
"requires": "PR #5",
|
||||||
|
"files": {
|
||||||
|
"ptz_tracker_modular/postprocess.py": {
|
||||||
|
"before": "376f705fb3be06ab04afc1ebb718cb71a2c27a67987023b099f5d921148b64ad",
|
||||||
|
"after": "d85439504ebf56fc39ee8a883c44b1bfc6db721df938aedc85d6c6484cb97776"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"unchanged": {
|
||||||
|
"ptz_tracker_modular/ptz_io.py": "13d31539193b1a773a5d1db2187cc2a0c8db67d0aacaad89082face64df07499"
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,55 @@
|
|||||||
|
--- a/ptz_tracker_modular/postprocess.py
|
||||||
|
+++ b/ptz_tracker_modular/postprocess.py
|
||||||
|
@@ -4577,6 +4577,7 @@
|
||||||
|
pulse_timing: Tuple[float, float] | None = None,
|
||||||
|
optics_observed_now: float | None = None,
|
||||||
|
stop_trace: list[str] | None = None,
|
||||||
|
+ continuation_trace: list[tuple[int, int, float, float, float, float, float]] | None = None,
|
||||||
|
) -> float:
|
||||||
|
"""Break continuous zoom-in into short feedback-controlled steps."""
|
||||||
|
pulse_until = float(st.get("zoom_step_until", 0.0) or 0.0)
|
||||||
|
@@ -4650,6 +4651,12 @@
|
||||||
|
):
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
|
return _reject_zoom_step("pending_native_floor", stop_trace)
|
||||||
|
+ if same_native and continuation_trace is not None:
|
||||||
|
+ continuation_trace.append((
|
||||||
|
+ st["ptz_generation"], native, float(zoom_cmd), useful_cmd, pulse_until,
|
||||||
|
+ float(st.get("zoom_step_pending_pulse_sec", 0.0) or 0.0),
|
||||||
|
+ float(st.get("zoom_step_pending_hard_sec", 0.0) or 0.0),
|
||||||
|
+ ))
|
||||||
|
zoom_cmd = useful_cmd
|
||||||
|
physical_started = float(st.get("zoom_step_physical_started_at", 0.0) or 0.0)
|
||||||
|
if physical_started > 0.0:
|
||||||
|
@@ -9232,6 +9239,7 @@
|
||||||
|
st["zoom_useful_pulse_reason"] = "wait_response_framing"
|
||||||
|
zoom_zero_reason = "response_framing"
|
||||||
|
gate_stop = [] if decision_request else None
|
||||||
|
+ continuation_trace = [] if decision_request else None
|
||||||
|
zoom_cmd = _gate_zoom_in_pulse(
|
||||||
|
st,
|
||||||
|
# Keep new-request expiry tied to the frame that authorized
|
||||||
|
@@ -9247,6 +9255,7 @@
|
||||||
|
pulse_timing=response_timing,
|
||||||
|
optics_observed_now=zoom_gate_now,
|
||||||
|
stop_trace=gate_stop,
|
||||||
|
+ continuation_trace=continuation_trace,
|
||||||
|
)
|
||||||
|
if gate_stop:
|
||||||
|
zoom_zero_reason = gate_stop[-1]
|
||||||
|
@@ -9788,6 +9797,15 @@
|
||||||
|
cam_idx, prepared_fps, visual_only, max(0., time.time()-now)*1000.,
|
||||||
|
st.get('control_updates', 0), st.get('control_visual_updates', 0))
|
||||||
|
ingest_detection(alarm_eligible)
|
||||||
|
+ if continuation_trace:
|
||||||
|
+ generation, native, proposed, held, until, pulse_sec, hard_sec = continuation_trace[0]
|
||||||
|
+ logger.info(
|
||||||
|
+ "[ZOOM CONTINUE] cam=%s frame=%s request=%s gen=%s reason=same_native "
|
||||||
|
+ "native=%s proposed=%.12g held=%.12g nominal_until=%.6f "
|
||||||
|
+ "pulse=%.3fs hard=%.3fs dispatch_zoom=%.12g",
|
||||||
|
+ cam_idx, source_seq, decision_request, generation, native, proposed,
|
||||||
|
+ held, until, pulse_sec, hard_sec, zoom_cmd,
|
||||||
|
+ )
|
||||||
|
return
|
||||||
|
|
||||||
|
# =========================
|
||||||
@ -0,0 +1,12 @@
|
|||||||
|
{
|
||||||
|
"requires": "PR #6",
|
||||||
|
"files": {
|
||||||
|
"ptz_tracker_modular/postprocess.py": {
|
||||||
|
"before": "d85439504ebf56fc39ee8a883c44b1bfc6db721df938aedc85d6c6484cb97776",
|
||||||
|
"after": "776b5b337e5f898e69770fec517c4459560f4cc6adeb951af40ac8f0b2178534"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"unchanged": {
|
||||||
|
"ptz_tracker_modular/ptz_io.py": "13d31539193b1a773a5d1db2187cc2a0c8db67d0aacaad89082face64df07499"
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,314 @@
|
|||||||
|
--- a/ptz_tracker_modular/postprocess.py
|
||||||
|
+++ b/ptz_tracker_modular/postprocess.py
|
||||||
|
@@ -2,6 +2,7 @@
|
||||||
|
import time
|
||||||
|
import math
|
||||||
|
import logging
|
||||||
|
+import json
|
||||||
|
from typing import Any, List, Tuple
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
@@ -454,6 +455,7 @@
|
||||||
|
hfov_deg: float,
|
||||||
|
vfov_deg: float,
|
||||||
|
max_error_deg: float | None = None,
|
||||||
|
+ rejection: dict | None = None,
|
||||||
|
) -> bool:
|
||||||
|
"""Allow a lens pulse only when angular steering reserve is available."""
|
||||||
|
max_error = max(
|
||||||
|
@@ -486,7 +488,7 @@
|
||||||
|
float(tilt_error_deg) * float(tilt_rate_deg_s) > 0.0
|
||||||
|
and abs(float(tilt_rate_deg_s)) > max_outward
|
||||||
|
)
|
||||||
|
- return bool(
|
||||||
|
+ allowed = bool(
|
||||||
|
not pan_escaping
|
||||||
|
and not tilt_escaping
|
||||||
|
and abs(float(pan_error_deg)) <= pan_limit
|
||||||
|
@@ -494,6 +496,23 @@
|
||||||
|
and abs(predicted_pan) <= pan_limit
|
||||||
|
and abs(predicted_tilt) <= tilt_limit
|
||||||
|
)
|
||||||
|
+ if not allowed and rejection is not None:
|
||||||
|
+ rejection.update(
|
||||||
|
+ failed=[name for name, failed in (
|
||||||
|
+ ("pan_outward_rate", pan_escaping),
|
||||||
|
+ ("tilt_outward_rate", tilt_escaping),
|
||||||
|
+ ("pan_error", not abs(float(pan_error_deg)) <= pan_limit),
|
||||||
|
+ ("tilt_error", not abs(float(tilt_error_deg)) <= tilt_limit),
|
||||||
|
+ ("predicted_pan", not abs(predicted_pan) <= pan_limit),
|
||||||
|
+ ("predicted_tilt", not abs(predicted_tilt) <= tilt_limit),
|
||||||
|
+ ) if failed],
|
||||||
|
+ pan_error_deg=pan_error_deg, tilt_error_deg=tilt_error_deg,
|
||||||
|
+ pan_rate_deg_s=pan_rate_deg_s, tilt_rate_deg_s=tilt_rate_deg_s,
|
||||||
|
+ predicted_pan_deg=predicted_pan, predicted_tilt_deg=predicted_tilt,
|
||||||
|
+ pan_limit_deg=pan_limit, tilt_limit_deg=tilt_limit,
|
||||||
|
+ outward_rate_limit_deg_s=max_outward, prediction_s=horizon,
|
||||||
|
+ )
|
||||||
|
+ return allowed
|
||||||
|
|
||||||
|
|
||||||
|
def _zoom_probe_used_for_current_track(st: dict) -> bool:
|
||||||
|
@@ -4877,12 +4896,21 @@
|
||||||
|
return min(cap, max(command, minimum)), "useful"
|
||||||
|
|
||||||
|
|
||||||
|
+def _zoom_response_fallback(
|
||||||
|
+ timing: Tuple[float, float], rejection: dict | None, failed: str, **values,
|
||||||
|
+) -> Tuple[float, float]:
|
||||||
|
+ if rejection is not None and timing == (0.0, 0.0):
|
||||||
|
+ rejection.update(check=failed, **values)
|
||||||
|
+ return timing
|
||||||
|
+
|
||||||
|
+
|
||||||
|
def _select_zoom_response_timing(
|
||||||
|
st: dict, *, useful: bool, hfov_deg: float, wide_hfov_deg: float,
|
||||||
|
center_err: float, margin: float, image_rate: float,
|
||||||
|
approach_margin: float | None = None,
|
||||||
|
fast_approach: bool = False,
|
||||||
|
requested_native: int | None = None,
|
||||||
|
+ rejection: dict | None = None,
|
||||||
|
) -> Tuple[float, float]:
|
||||||
|
"""Explore at wide angle; reuse optically proven timing after narrowing.
|
||||||
|
|
||||||
|
@@ -4897,10 +4925,13 @@
|
||||||
|
"""
|
||||||
|
if requested_native is not None:
|
||||||
|
if st.get("zoom_no_effect_blocked", False):
|
||||||
|
- return 0.0, 0.0
|
||||||
|
+ return _zoom_response_fallback((0.0, 0.0), rejection, "no_effect_limit")
|
||||||
|
native = int(requested_native)
|
||||||
|
if not _zoom_native_response_available(st, native, hfov_deg, wide_hfov_deg):
|
||||||
|
- return 0.0, 0.0
|
||||||
|
+ return _zoom_response_fallback(
|
||||||
|
+ (0.0, 0.0), rejection, "native_profile",
|
||||||
|
+ native=native, hfov_deg=hfov_deg, wide_hfov_deg=wide_hfov_deg,
|
||||||
|
+ )
|
||||||
|
proof_native = int(st.get("zoom_response_native_cmd", 0) or 0)
|
||||||
|
retry_native = int(st.get("zoom_response_retry_native_cmd", 0) or 0)
|
||||||
|
legacy_proof10 = native == 10 and proof_native == 0
|
||||||
|
@@ -4923,9 +4954,9 @@
|
||||||
|
try:
|
||||||
|
learned = float(st.get("zoom_response_effective_sec", 0.0) or 0.0)
|
||||||
|
if not math.isfinite(learned):
|
||||||
|
- return 0.0, 0.0
|
||||||
|
+ return _zoom_response_fallback((0.0, 0.0), rejection, "invalid_learned_duration")
|
||||||
|
except (TypeError, ValueError, OverflowError):
|
||||||
|
- return 0.0, 0.0
|
||||||
|
+ return _zoom_response_fallback((0.0, 0.0), rejection, "invalid_learned_duration")
|
||||||
|
fallback = (0.0, 0.0) if learned > base else (base, hard)
|
||||||
|
try:
|
||||||
|
hfov, wide, error, edge, rate = map(float, (hfov_deg, wide_hfov_deg, center_err, margin, image_rate))
|
||||||
|
@@ -4936,14 +4967,20 @@
|
||||||
|
video_lag = float(getattr(config, "AIM_GIMBAL_FF_VIDEO_LATENCY_SEC", 0.45))
|
||||||
|
stop_timeout = float(getattr(config, "PTZ_LENS_STOP_DIRECT_TIMEOUT_SEC", 0.75))
|
||||||
|
if not all(math.isfinite(v) for v in (base, hard, hfov, wide, error, edge, rate, extra, max_pulse, max_hard, ratio, learned, video_lag, stop_timeout)):
|
||||||
|
- return fallback
|
||||||
|
+ return _zoom_response_fallback(fallback, rejection, "invalid_timing_inputs")
|
||||||
|
max_pulse, max_hard, ratio = min(0.34, max_pulse), min(0.40, max_hard), max(0.85, ratio)
|
||||||
|
video_lag, stop_timeout = max(0.0, video_lag), max(0.0, stop_timeout)
|
||||||
|
approach = approach_margin is not None and math.isfinite(approach_margin) and .16 <= approach_margin <= .5
|
||||||
|
+ center_limit = .12 if approach else .065
|
||||||
|
if not (0.0 < hfov <= wide < 180.0
|
||||||
|
- and 0.0 <= error <= (.12 if approach else .065)
|
||||||
|
+ and 0.0 <= error <= center_limit
|
||||||
|
and edge >= 0.30 and 0.0 <= rate <= 0.04):
|
||||||
|
- return fallback
|
||||||
|
+ return _zoom_response_fallback(
|
||||||
|
+ fallback, rejection, "framing",
|
||||||
|
+ hfov_deg=hfov, wide_hfov_deg=wide, center_error=error, center_limit=center_limit,
|
||||||
|
+ margin=edge, margin_min=.30, image_rate=rate, image_rate_max=.04,
|
||||||
|
+ approach_margin=approach_margin,
|
||||||
|
+ )
|
||||||
|
attempts = min(2, max(0, int(st.get("zoom_no_effect_count", 0) or 0)))
|
||||||
|
if hfov >= wide * ratio:
|
||||||
|
pulse = min(max_pulse, max(base + attempts * max(0.0, extra), learned))
|
||||||
|
@@ -4951,7 +4988,13 @@
|
||||||
|
if not (base < learned <= 0.34 and (
|
||||||
|
approach or (error <= 0.04 and edge >= 0.40 and rate <= 0.02)
|
||||||
|
)):
|
||||||
|
- return fallback
|
||||||
|
+ return _zoom_response_fallback(
|
||||||
|
+ fallback, rejection, "narrow_fov",
|
||||||
|
+ hfov_deg=hfov, wide_cutoff_deg=wide * ratio, learned_s=learned,
|
||||||
|
+ base_s=base, learned_max_s=.34, approach=approach,
|
||||||
|
+ approach_margin=approach_margin, center_error=error, center_limit=.04,
|
||||||
|
+ margin=edge, margin_min=.40, image_rate=rate, image_rate_max=.02,
|
||||||
|
+ )
|
||||||
|
# A nominal duration learned at wide FOV may become ineffective
|
||||||
|
# after narrowing (or may have benefited from STOP transport lag).
|
||||||
|
# Repeating it until the no-effect latch fires is not adaptation.
|
||||||
|
@@ -4988,16 +5031,24 @@
|
||||||
|
# increase either configured hard ceiling or the compiled 400ms limit.
|
||||||
|
deadline = min(max_hard, max(hard, pulse + 0.06))
|
||||||
|
if pulse <= base or deadline < pulse or pulse + 1e-9 < learned:
|
||||||
|
- return fallback
|
||||||
|
+ return _zoom_response_fallback(
|
||||||
|
+ fallback, rejection, "duration",
|
||||||
|
+ pulse_s=pulse, base_s=base, hard_s=deadline, learned_s=learned,
|
||||||
|
+ )
|
||||||
|
# Stress the projection with 2x apparent offset/box/rate and include
|
||||||
|
# video lag + STOP network timeout. This is a conservative software
|
||||||
|
# envelope, not a measured bound on this particular lens's zoom rate.
|
||||||
|
# The ordinary enlarged-bbox predictor is also independently checked.
|
||||||
|
- if 2.0 * edge - 0.5 - 2.0 * rate * (deadline + video_lag + stop_timeout) < 0.10:
|
||||||
|
- return fallback
|
||||||
|
+ projected_margin = 2.0 * edge - 0.5 - 2.0 * rate * (deadline + video_lag + stop_timeout)
|
||||||
|
+ if projected_margin < 0.10:
|
||||||
|
+ return _zoom_response_fallback(
|
||||||
|
+ fallback, rejection, "projected_margin",
|
||||||
|
+ projected_margin=projected_margin, margin_min=.10, margin=edge,
|
||||||
|
+ image_rate=rate, hard_s=deadline, video_lag_s=video_lag, stop_timeout_s=stop_timeout,
|
||||||
|
+ )
|
||||||
|
return pulse, deadline
|
||||||
|
except (TypeError, ValueError, OverflowError):
|
||||||
|
- return fallback
|
||||||
|
+ return _zoom_response_fallback(fallback, rejection, "invalid_timing_inputs")
|
||||||
|
|
||||||
|
|
||||||
|
def _apply_zoom_in_minimum(
|
||||||
|
@@ -8516,7 +8567,9 @@
|
||||||
|
tilt_speed = 0.0
|
||||||
|
# === zoom logic (V3): target-size + alpha-beta filter + hysteresis ===
|
||||||
|
state_zoom = int(st.get("zoom_state", 0) or 0)
|
||||||
|
- can_switch = (now - float(st.get("zoom_last_change", 0.0) or 0.0)) >= float(getattr(config, "Z_MIN_SWITCH_INTERVAL", 0.50))
|
||||||
|
+ switch_age = now - float(st.get("zoom_last_change", 0.0) or 0.0)
|
||||||
|
+ switch_interval = float(getattr(config, "Z_MIN_SWITCH_INTERVAL", 0.50))
|
||||||
|
+ can_switch = switch_age >= switch_interval
|
||||||
|
|
||||||
|
gate_dyn = max(0.05, _Z_CENTER_GATE_IN + _Z_CENTER_GATE_SCALE * (1.0 - clipf(w_smooth, 0.0, 1.0)))
|
||||||
|
center_good = measured_center_err < gate_dyn
|
||||||
|
@@ -8766,6 +8819,7 @@
|
||||||
|
pan_rate_deg_s=float(los_pan_rate_deg_s),
|
||||||
|
tilt_rate_deg_s=float(los_tilt_rate_deg_s),
|
||||||
|
)
|
||||||
|
+ angular_rejection = {} if pulse_active else None
|
||||||
|
zoom_angular_safe = followup_ready and _zoom_angular_motion_safe(
|
||||||
|
pan_error_deg=float(los_pan_angle_deg),
|
||||||
|
tilt_error_deg=float(los_tilt_angle_deg),
|
||||||
|
@@ -8774,6 +8828,7 @@
|
||||||
|
hfov_deg=float(hfov_deg),
|
||||||
|
vfov_deg=float(vfov_deg),
|
||||||
|
max_error_deg=float(angular_max),
|
||||||
|
+ rejection=angular_rejection,
|
||||||
|
)
|
||||||
|
if approach_margin is not None and followup_ready:
|
||||||
|
zoom_angular_safe = True
|
||||||
|
@@ -8961,6 +9016,8 @@
|
||||||
|
elif can_switch and int(st.get("zoom_v3_neutral_votes", 0) or 0) >= confirm_frames:
|
||||||
|
next_state = 0
|
||||||
|
|
||||||
|
+ size_votes = (st.get("zoom_v3_in_votes", 0), st.get("zoom_v3_out_votes", 0),
|
||||||
|
+ st.get("zoom_v3_neutral_votes", 0))
|
||||||
|
if next_state != state_zoom:
|
||||||
|
st["zoom_state"] = next_state
|
||||||
|
st["zoom_last_change"] = now
|
||||||
|
@@ -8968,19 +9025,21 @@
|
||||||
|
st["zoom_int"] = 0.0
|
||||||
|
|
||||||
|
err_size = z_target - size_ctrl
|
||||||
|
- if abs(err_size) < float(getattr(config, "Z_DEADBAND", 0.010)):
|
||||||
|
+ size_deadband = float(getattr(config, "Z_DEADBAND", 0.010))
|
||||||
|
+ if abs(err_size) < size_deadband:
|
||||||
|
err_size = 0.0
|
||||||
|
st["zoom_int"] = clipf(float(st.get("zoom_int", 0.0) or 0.0) + err_size * 0.04, -_Z_INT_CLAMP, _Z_INT_CLAMP)
|
||||||
|
zoom_pi = _Z_P * err_size + _Z_I * st["zoom_int"]
|
||||||
|
zoom_ff = _Z_FF_GAIN * (-float(size_rate))
|
||||||
|
- if size_err_abs <= float(getattr(config, "ZOOM_V3_BRAKE_ERR", 0.030)):
|
||||||
|
+ brake_err = float(getattr(config, "ZOOM_V3_BRAKE_ERR", 0.030))
|
||||||
|
+ if size_err_abs <= brake_err:
|
||||||
|
zoom_ff = 0.0
|
||||||
|
zoom_cmd = clipf(zoom_pi + zoom_ff, _Z_SPEED_LIMIT_OUT, _Z_SPEED_LIMIT_IN)
|
||||||
|
zoom_zero_reason = "size_controller"
|
||||||
|
if not out_edge_crit:
|
||||||
|
- brake_err = float(getattr(config, "ZOOM_V3_BRAKE_ERR", 0.030))
|
||||||
|
brake_k = clipf(abs(err_size) / max(1e-6, brake_err), 0.0, 1.0)
|
||||||
|
zoom_cmd *= brake_k
|
||||||
|
+ zoom_before_size_state = zoom_cmd
|
||||||
|
|
||||||
|
if st.get("zoom_lock", False) and not bounded_identification_request:
|
||||||
|
zoom_cmd = min(zoom_cmd, -0.12) if out_edge_effective else 0.0
|
||||||
|
@@ -9005,6 +9064,7 @@
|
||||||
|
if zoom_cmd < 0.0:
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
|
||||||
|
+ zoom_after_size_state = zoom_cmd
|
||||||
|
prev_z = float(st.get("zoom_prev_cmd", 0.0) or 0.0)
|
||||||
|
max_step = float(getattr(config, "ZOOM_V3_CMD_MAX_STEP", 0.04))
|
||||||
|
positive_slew_limit = prev_z + max_step
|
||||||
|
@@ -9018,6 +9078,7 @@
|
||||||
|
and approach_margin is not None and .16 <= approach_margin <= .5):
|
||||||
|
positive_slew_limit = max(positive_slew_limit, min(.12, float(getattr(config, "ZOOM_STEP_MAX_IN_CMD", .12))))
|
||||||
|
zoom_cmd = clipf(zoom_cmd, prev_z - max_step, positive_slew_limit)
|
||||||
|
+ zoom_after_size_slew = zoom_cmd
|
||||||
|
if (prev_z * zoom_cmd) < 0.0 and abs(err_size) < (lock_err_thr * 2.0):
|
||||||
|
sign_cd = float(getattr(config, "ZOOM_V3_SIGN_COOLDOWN_SEC", 0.80))
|
||||||
|
last_flip = float(st.get("zoom_v3_last_sign_flip_t", 0.0) or 0.0)
|
||||||
|
@@ -9038,6 +9099,7 @@
|
||||||
|
zoom_zero_reason = "deadband"
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
|
||||||
|
+ zoom_after_size_minimum = zoom_cmd
|
||||||
|
cmd_mag_est = max(
|
||||||
|
abs(float(pan_speed) + float(pan_rate_ff)),
|
||||||
|
abs(float(tilt_speed) + float(tilt_rate_ff)),
|
||||||
|
@@ -9225,6 +9287,8 @@
|
||||||
|
st["zoom_useful_pulse_reason"] = useful_reason
|
||||||
|
if before_shape > 0.0 and zoom_cmd <= 0.0:
|
||||||
|
zoom_zero_reason = useful_reason
|
||||||
|
+ response_rejection = {} if decision_request and useful_reason == "useful" else None
|
||||||
|
+ timing_native = _zoom_native_timing_request(st, zoom_cmd)
|
||||||
|
response_timing = _select_zoom_response_timing(
|
||||||
|
st, useful=useful_reason == "useful",
|
||||||
|
hfov_deg=float(hfov_deg), wide_hfov_deg=float(shared_wide_hfov),
|
||||||
|
@@ -9232,7 +9296,8 @@
|
||||||
|
margin=float(edge_risk_margin), image_rate=max(float(vel), float(fast_drift)),
|
||||||
|
approach_margin=approach_margin,
|
||||||
|
fast_approach=bool(fast_approach and normal_zoom_quality_ok and pulse_family == "normal"),
|
||||||
|
- requested_native=_zoom_native_timing_request(st, zoom_cmd),
|
||||||
|
+ requested_native=timing_native,
|
||||||
|
+ rejection=response_rejection,
|
||||||
|
)
|
||||||
|
if useful_reason == "useful" and response_timing == (0.0, 0.0):
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
@@ -9259,6 +9324,7 @@
|
||||||
|
)
|
||||||
|
if gate_stop:
|
||||||
|
zoom_zero_reason = gate_stop[-1]
|
||||||
|
+ decision_generation = st.get("ptz_generation")
|
||||||
|
if (
|
||||||
|
probe_start_candidate
|
||||||
|
and zoom_cmd > 0.0
|
||||||
|
@@ -9797,6 +9863,32 @@
|
||||||
|
cam_idx, prepared_fps, visual_only, max(0., time.time()-now)*1000.,
|
||||||
|
st.get('control_updates', 0), st.get('control_visual_updates', 0))
|
||||||
|
ingest_detection(alarm_eligible)
|
||||||
|
+ if zoom_decision is not None and zoom_zero_reason in ("response_framing", "size_controller"):
|
||||||
|
+ if zoom_zero_reason == "response_framing":
|
||||||
|
+ detail = {"native": timing_native, **(response_rejection or {})}
|
||||||
|
+ else:
|
||||||
|
+ detail = dict(
|
||||||
|
+ size=size_ctrl, size_target=z_target, zoom_in_below=z_band_min - _Z_SIGN_HYST,
|
||||||
|
+ size_error=err_size, size_deadband=size_deadband, brake_error=brake_err,
|
||||||
|
+ pi=zoom_pi, feed_forward=zoom_ff, previous_state=state_zoom,
|
||||||
|
+ next_state=next_state, can_switch=can_switch, want_in=want_in, want_out=want_out,
|
||||||
|
+ in_votes=size_votes[0], out_votes=size_votes[1], neutral_votes=size_votes[2],
|
||||||
|
+ confirm_frames=confirm_frames, switch_age_s=switch_age, switch_interval_s=switch_interval,
|
||||||
|
+ can_zoom_in=can_zoom_in, followup_ready=followup_ready, angular_safe=zoom_angular_safe,
|
||||||
|
+ angular=angular_rejection,
|
||||||
|
+ before_state=zoom_before_size_state, after_state=zoom_after_size_state,
|
||||||
|
+ previous_zoom=prev_z, slew_min=prev_z - max_step, slew_max=positive_slew_limit,
|
||||||
|
+ after_slew=zoom_after_size_slew, command_min=_Z_MIN_CMD,
|
||||||
|
+ after_minimum=zoom_after_size_minimum, before_recenter=before_recenter,
|
||||||
|
+ before_ramp=pre_ramp_zoom_cmd, before_shape=before_shape,
|
||||||
|
+ center_error=center_err, center_priority_error=center_prio_err,
|
||||||
|
+ margin=min_margin, center_priority_margin=center_prio_margin,
|
||||||
|
+ )
|
||||||
|
+ logger.info(
|
||||||
|
+ "[ZOOM THRESHOLD] cam=%s frame=%s request=%s gen=%s reason=%s detail=%s",
|
||||||
|
+ cam_idx, source_seq, decision_request, decision_generation, zoom_zero_reason,
|
||||||
|
+ json.dumps(detail, separators=(",", ":"), default=str),
|
||||||
|
+ )
|
||||||
|
if continuation_trace:
|
||||||
|
generation, native, proposed, held, until, pulse_sec, hard_sec = continuation_trace[0]
|
||||||
|
logger.info(
|
||||||
@ -0,0 +1,13 @@
|
|||||||
|
{
|
||||||
|
"requires": "PTZ stop attribution PR #3",
|
||||||
|
"files": {
|
||||||
|
"ptz_tracker_modular/postprocess.py": {
|
||||||
|
"before": "5326c9d3093b7c863310b9c0a7a85010a1a83ff014631a054ac9a16cc31c8fc5",
|
||||||
|
"after": "8eb5f6beb79141ef1f1ce9dbad3577006821202557a87c7195e770bbba7b4ba3"
|
||||||
|
},
|
||||||
|
"ptz_tracker_modular/ptz_io.py": {
|
||||||
|
"before": "3c3f10eaebc2a1c0f67725d6a487bad9e1537b1bb277705fc503c2526c779600",
|
||||||
|
"after": "13d31539193b1a773a5d1db2187cc2a0c8db67d0aacaad89082face64df07499"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,223 @@
|
|||||||
|
"""Reconstruct logged stop boundaries through the installed gate and worker, offline."""
|
||||||
|
from contextlib import ExitStack
|
||||||
|
import ast
|
||||||
|
import hashlib
|
||||||
|
import json
|
||||||
|
import logging
|
||||||
|
import math
|
||||||
|
from pathlib import Path
|
||||||
|
import socket
|
||||||
|
import sys
|
||||||
|
from types import ModuleType, SimpleNamespace
|
||||||
|
import unittest
|
||||||
|
from unittest.mock import patch
|
||||||
|
import importlib.util
|
||||||
|
|
||||||
|
|
||||||
|
WORK = Path(__file__).resolve().parent
|
||||||
|
PP = Path(sys.argv[5])
|
||||||
|
SOURCE, PTZ, INPUT, PRIOR = map(Path,sys.argv[1:5])
|
||||||
|
ROOT = Path(sys.argv[8])
|
||||||
|
BASE = ROOT/'analysis_outputs/visual_probe_20261019'
|
||||||
|
PKG='ptz_tracker_modular'
|
||||||
|
TRACE=[]
|
||||||
|
DETAIL=[]
|
||||||
|
PINS = {PP: sys.argv[6], PTZ: sys.argv[7]}
|
||||||
|
|
||||||
|
def sha(path):
|
||||||
|
return hashlib.sha256(path.read_bytes()).hexdigest()
|
||||||
|
|
||||||
|
def load(name,path):
|
||||||
|
spec=importlib.util.spec_from_file_location(name,path)
|
||||||
|
module=importlib.util.module_from_spec(spec)
|
||||||
|
sys.modules[name]=module
|
||||||
|
spec.loader.exec_module(module)
|
||||||
|
return module
|
||||||
|
|
||||||
|
def deny(*args,**kwargs):
|
||||||
|
raise AssertionError('No real network, CUDA, camera RPC, or model access in replay')
|
||||||
|
|
||||||
|
def as_native(value):
|
||||||
|
return math.nextafter(value/100,math.copysign(math.inf,value)) if value else 0.
|
||||||
|
|
||||||
|
def xml_sent(fixture):
|
||||||
|
return [tuple(transport.xml_axis(xml,axis) for axis in ('pan','tilt','zoom')) for xml in fixture.sent]
|
||||||
|
|
||||||
|
def captured():
|
||||||
|
report=json.loads(INPUT.read_text(encoding='utf-8'))
|
||||||
|
assert report['stable'] is True
|
||||||
|
assert report['container']['started_at']=='2026-11-09T06:24:10.287783596Z'
|
||||||
|
for camera, episodes in report['episodes'].items():
|
||||||
|
for episode in episodes:
|
||||||
|
assert episode['short_count']==len(episode['short_examples'])
|
||||||
|
for sample in episode['short_examples']:
|
||||||
|
yield camera,episode,sample
|
||||||
|
|
||||||
|
def sec(value):
|
||||||
|
return float(value.removesuffix('s'))
|
||||||
|
|
||||||
|
class StopBoundary(unittest.TestCase):
|
||||||
|
def fixture(self, cam, kind, native, pulse):
|
||||||
|
fixture=transport.UsefulZoomTransportTests()
|
||||||
|
fixture.setUp()
|
||||||
|
self.addCleanup(fixture.doCleanups)
|
||||||
|
fixture.cam=cam
|
||||||
|
fixture.stack.enter_context(patch.dict(state.ptz_states,{cam:fixture.st}))
|
||||||
|
# Seed each authorized pulse independently. The log gives accounting
|
||||||
|
# duration/minimum and speed, but lacks the original hard-stop deadline.
|
||||||
|
command=as_native(native)
|
||||||
|
allowed=pp._gate_zoom_in_pulse(fixture.st,fixture.wall,command,True,
|
||||||
|
pulse_kind=kind,pulse_floor=command,pulse_timing=(pulse,.4))
|
||||||
|
self.assertGreater(allowed,0)
|
||||||
|
fixture._enqueue(allowed)
|
||||||
|
fixture._flush()
|
||||||
|
self.assertEqual(xml_sent(fixture)[-1][2],native)
|
||||||
|
self.assertTrue(fixture.st['zoom_step_pending'])
|
||||||
|
return fixture
|
||||||
|
|
||||||
|
def test_all_observed_short_deliveries_replay_at_worker(self):
|
||||||
|
for cam,e,row in captured():
|
||||||
|
with self.subTest(camera=cam,request=row['request']):
|
||||||
|
internal={'19':8,'21':10}[cam]
|
||||||
|
pulse=round(sec(row['minimum'])/.7,3)
|
||||||
|
f=self.fixture(internal,row['kind'],int(row['native']),pulse)
|
||||||
|
f._advance(sec(row['duration']))
|
||||||
|
pan,tilt,zoom=row['requested']
|
||||||
|
self.assertEqual(zoom,0)
|
||||||
|
self.assertNotEqual((pan,tilt),(0,0))
|
||||||
|
with self.assertLogs('PTZTracker.PTZ',level='INFO') as logs:
|
||||||
|
# These are the recorded native values already past quantization.
|
||||||
|
seq=int(row['seq'])
|
||||||
|
f.st['ptz_move_seq']=seq
|
||||||
|
queued=ptz_io.MoveTuple(ptz_io.PTZCmd.MOVE,internal,pan,tilt,0,
|
||||||
|
source='track',generation=f.st['ptz_generation'],preset_floor_checked=True,
|
||||||
|
seq=seq,safety_stop=True)
|
||||||
|
state.ptz_cmd_q.put_nowait(queued)
|
||||||
|
self.assertEqual((queued.pan_i,queued.tilt_i,queued.zoom_i),tuple(row['requested']))
|
||||||
|
f._flush()
|
||||||
|
last=xml_sent(f)[-1]
|
||||||
|
self.assertEqual(last,tuple(row['effective']))
|
||||||
|
self.assertEqual(f.st['zoom_step_last_delivery_result'],'short')
|
||||||
|
self.assertEqual(f.st['zoom_in_pulse_count'],0)
|
||||||
|
self.assertAlmostEqual(f.st['zoom_step_last_delivered_sec'],sec(row['duration']))
|
||||||
|
record=next(x for x in logs.output if 'result=short' in x)
|
||||||
|
self.assertIn('stop_effective=(0,0,0)',record)
|
||||||
|
TRACE.append(dict(camera=cam,episode=e['started_at'],complete=e['complete'],
|
||||||
|
source_request=row['request'],kind=row['kind'],native=int(row['native']),
|
||||||
|
logged_s=sec(row['duration']),minimum_s=sec(row['minimum']),requested=row['requested'],
|
||||||
|
replay_effective=last,replay_result=f.st['zoom_step_last_delivery_result'],
|
||||||
|
controller_trigger_recovered=False))
|
||||||
|
|
||||||
|
def test_positive_revalidation_keeps_original_owned_pulse_deadline(self):
|
||||||
|
for cam,native in ((8,10),(10,11)):
|
||||||
|
with self.subTest(cam=cam,native=native):
|
||||||
|
f=self.fixture(cam,'normal',native,.34)
|
||||||
|
hard_deadline=f.st['zoom_step_stop_started_mono']+f.st['zoom_step_stop_timer'].delay
|
||||||
|
origin=f.st['zoom_step_put_started_mono']
|
||||||
|
deadline=f.st['zoom_step_until']
|
||||||
|
request=f.st['zoom_step_physical_request_id']
|
||||||
|
for _ in range(3):
|
||||||
|
f._advance(.045)
|
||||||
|
command=pp._gate_zoom_in_pulse(f.st,f.wall,.12,True,pulse_floor=.12,pulse_timing=(.34,.4))
|
||||||
|
self.assertEqual(ptz_io._zoom_speed_to_int(command),native)
|
||||||
|
f._enqueue(command)
|
||||||
|
f._flush()
|
||||||
|
self.assertEqual(f.st['zoom_step_put_started_mono'],origin)
|
||||||
|
self.assertEqual(f.st['zoom_step_until'],deadline)
|
||||||
|
self.assertEqual(f.st['zoom_step_physical_request_id'],request)
|
||||||
|
self.assertAlmostEqual(f.st['zoom_step_stop_started_mono']+
|
||||||
|
f.st['zoom_step_stop_timer'].delay,hard_deadline,places=6)
|
||||||
|
self.assertLessEqual(hard_deadline-origin,.400001)
|
||||||
|
f._advance(hard_deadline-f.mono)
|
||||||
|
f.st['zoom_step_stop_timer'].fire()
|
||||||
|
self.assertEqual(xml_sent(f)[-1],(0,0,0))
|
||||||
|
|
||||||
|
def test_identical_zero_when_only_vote_fails_or_safety_fails(self):
|
||||||
|
tree=ast.parse((PP).read_bytes())
|
||||||
|
main=next(n for n in tree.body if getattr(n,'name','')=='postprocess_control')
|
||||||
|
expr=next(n.value for n in ast.walk(main) if isinstance(n,ast.Assign)
|
||||||
|
and any(isinstance(target,ast.Name) and target.id=='can_zoom_in' for target in n.targets)
|
||||||
|
and 'zoom_angular_safe' in ast.unparse(n.value))
|
||||||
|
compiled=compile(ast.Expression(expr),'<server can_zoom_in>','eval')
|
||||||
|
for label,changes in (
|
||||||
|
('synthetic_stable_history_only',{'stable_ok':False}),
|
||||||
|
('synthetic_edge_veto',{'near_edge':True}),
|
||||||
|
('synthetic_angular_veto',{'zoom_angular_safe':False}),
|
||||||
|
('synthetic_quality_veto',{'zoom_safe':False}),
|
||||||
|
):
|
||||||
|
with self.subTest(label=label):
|
||||||
|
f=self.fixture(8,'normal',10,.34)
|
||||||
|
f._advance(.110)
|
||||||
|
env=dict(zoom_safe=True,zoom_angular_safe=True,stable_ok=True,
|
||||||
|
zoom_rearm_ready=True,near_edge=False,st={},bounded_identification_request=False,
|
||||||
|
fast_drift=.02,config=config,now=f.wall)
|
||||||
|
can=eval(compiled,{},{**env,**changes})
|
||||||
|
self.assertFalse(can)
|
||||||
|
actual=pp._gate_zoom_in_pulse(f.st,f.wall,.1,can,
|
||||||
|
pulse_floor=.1,pulse_timing=(.34,.4))
|
||||||
|
self.assertEqual(actual,0.)
|
||||||
|
f._enqueue(actual)
|
||||||
|
f._flush()
|
||||||
|
self.assertEqual(xml_sent(f)[-1],(0,0,0))
|
||||||
|
self.assertEqual(f.st['zoom_step_last_delivery_result'],'short')
|
||||||
|
DETAIL.append(dict(label=label,zoom=actual,axes=xml_sent(f)[-1],status='short'))
|
||||||
|
|
||||||
|
def main():
|
||||||
|
import torch
|
||||||
|
import numpy
|
||||||
|
global config,state,ptz_io,pp,transport
|
||||||
|
assert all(sha(path)==expected for path,expected in PINS.items())
|
||||||
|
before=load('prior_replay_fixture',PRIOR)
|
||||||
|
from test_frame_decision import build_cases
|
||||||
|
from test_native_floor import build_floor_cases
|
||||||
|
logging.getLogger('PTZTracker').setLevel(logging.ERROR)
|
||||||
|
with ExitStack() as stack:
|
||||||
|
for owner,name in ((socket.socket,'connect'),(socket.socket,'connect_ex'),
|
||||||
|
(socket,'create_connection'),(torch,'load'),(torch.cuda,'_lazy_init')):
|
||||||
|
stack.enter_context(patch.object(owner,name,deny))
|
||||||
|
stack.enter_context(patch.object(torch.cuda,'is_available',return_value=False))
|
||||||
|
package=ModuleType(PKG)
|
||||||
|
package.__path__=[str(BASE/'geometry_candidate/ptz_tracker_modular'),str(ROOT)]
|
||||||
|
sys.modules[PKG]=package
|
||||||
|
model=ModuleType(PKG+'.model')
|
||||||
|
model.model_shared,model.yolo_forward=object(),deny
|
||||||
|
sys.modules[model.__name__]=model
|
||||||
|
load(PKG+'.visual_control_probe', SOURCE/'visual_control_probe.py')
|
||||||
|
control=load(PKG+'.visual_control',SOURCE/'visual_control.py')
|
||||||
|
ptz_io=load(PKG+'.ptz_io',PTZ)
|
||||||
|
pp=load(PKG+'.postprocess',PP)
|
||||||
|
from ptz_tracker_modular import config,state,visual_tracker
|
||||||
|
values=json.loads((BASE/'zoom_continuation_candidate/runtime_policy_snapshot.json').read_text())['values']
|
||||||
|
for key,value in values.items():
|
||||||
|
stack.enter_context(patch.object(config,key,value,create=True))
|
||||||
|
transport=load('test_zoom_useful_transport',ROOT/'tests/test_zoom_useful_transport.py')
|
||||||
|
before.np,before.torch,before.config,before.state=numpy,torch,config,state
|
||||||
|
before.ptz_io,before.pp,before.tracker,before.control,before.transport=ptz_io,pp,visual_tracker,control,transport
|
||||||
|
suite=unittest.defaultTestLoader.loadTestsFromTestCase(StopBoundary)
|
||||||
|
for name in ('test_geometry_hold_short_delivery_has_exact_synthetic_stop_caller',
|
||||||
|
'test_started_controller_pulse_keeps_hard_stop_after_owner_change',
|
||||||
|
'test_joint_steering_update_cannot_extend_original_started_pulse',
|
||||||
|
'test_visual_age_over_250ms_cannot_move_or_advance_control',
|
||||||
|
'test_detector_age_over_650ms_cannot_refresh_evidence',
|
||||||
|
'test_old_owner_sample_cannot_refresh_or_stop_new_owner',
|
||||||
|
'test_reacquire_does_not_clear_no_effect_limit'):
|
||||||
|
suite.addTest(before.Replay(name))
|
||||||
|
candidate = "zoom_decision" in __import__("inspect").signature(ptz_io.move_ptz).parameters
|
||||||
|
if candidate:
|
||||||
|
suite.addTests(build_cases(before.Replay, pp, ptz_io))
|
||||||
|
suite.addTests(build_floor_cases(StopBoundary, before.Replay, pp, ptz_io, config,
|
||||||
|
Path(sys.argv[10]), sys.argv[11] == "fixed",
|
||||||
|
threshold_diagnostics="--thresholds" in sys.argv[12:]))
|
||||||
|
result=unittest.TextTestRunner(verbosity=2).run(suite)
|
||||||
|
result_file=Path(sys.argv[9])
|
||||||
|
result_file.write_text(json.dumps(dict(passed=result.wasSuccessful(),tests=result.testsRun,
|
||||||
|
observed_expected=len(list(captured())),observed_matched=len(TRACE),telemetry_sha256=sha(INPUT),
|
||||||
|
tested_source_sha256={path.name:pin for path,pin in PINS.items()},observed_rows=TRACE,synthetic=DETAIL,
|
||||||
|
shared_controller_rows={key: rows for key, rows in before.TRACE.items()
|
||||||
|
if not key.startswith(("test_frame_decision", "test_center_history", "test_dropped_move"))},
|
||||||
|
exact_observed_controller_replay=False,real_ptz_or_nn=False,
|
||||||
|
conclusion='The same short-delivery output is compatible with a synthetic admission-only condition and mandatory safety stops. The observed controller trigger and exact deadlines are missing.'),indent=2)+'\n',encoding='utf-8')
|
||||||
|
return not result.wasSuccessful()
|
||||||
|
|
||||||
|
if __name__=='__main__':
|
||||||
|
raise SystemExit(main())
|
||||||
@ -0,0 +1,406 @@
|
|||||||
|
--- a/ptz_tracker_modular/postprocess.py
|
||||||
|
+++ b/ptz_tracker_modular/postprocess.py
|
||||||
|
@@ -4357,6 +4357,7 @@
|
||||||
|
max_image_rate: float,
|
||||||
|
max_outward_rate: float,
|
||||||
|
err_growth_tol: float,
|
||||||
|
+ settled_sample: list[bool] | None = None,
|
||||||
|
) -> bool:
|
||||||
|
"""Return True only after a tight, non-diverging image-space hold.
|
||||||
|
|
||||||
|
@@ -4381,6 +4382,8 @@
|
||||||
|
and outward_rate <= max(0.0, float(max_outward_rate))
|
||||||
|
and non_diverging
|
||||||
|
)
|
||||||
|
+ if settled_sample is not None:
|
||||||
|
+ settled_sample.append(bool(settled))
|
||||||
|
previous_frames = int(st.get(frames_key, 0) or 0)
|
||||||
|
if settled:
|
||||||
|
frames = previous_frames + 1
|
||||||
|
@@ -4411,6 +4414,7 @@
|
||||||
|
vx: float,
|
||||||
|
vy: float,
|
||||||
|
center_gate: float | None = None,
|
||||||
|
+ settled_sample: list[bool] | None = None,
|
||||||
|
) -> bool:
|
||||||
|
return _update_center_lock_state(
|
||||||
|
st,
|
||||||
|
@@ -4436,6 +4440,7 @@
|
||||||
|
max_image_rate=float(getattr(config, "ZOOM_CENTER_LOCK_MAX_IMAGE_RATE", 0.28)),
|
||||||
|
max_outward_rate=float(getattr(config, "ZOOM_CENTER_LOCK_MAX_OUTWARD_RATE", 0.08)),
|
||||||
|
err_growth_tol=float(getattr(config, "ZOOM_CENTER_LOCK_ERR_GROWTH_TOL", 0.018)),
|
||||||
|
+ settled_sample=settled_sample,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
@@ -4553,6 +4558,12 @@
|
||||||
|
st["acquire_zoom_prev_err"] = None
|
||||||
|
|
||||||
|
|
||||||
|
+def _reject_zoom_step(reason: str, trace: list[str] | None) -> float:
|
||||||
|
+ if trace is not None:
|
||||||
|
+ trace.append(reason)
|
||||||
|
+ return 0.0
|
||||||
|
+
|
||||||
|
+
|
||||||
|
def _gate_zoom_in_pulse(
|
||||||
|
st: dict,
|
||||||
|
now: float,
|
||||||
|
@@ -4565,6 +4576,7 @@
|
||||||
|
pulse_floor: float = 0.0,
|
||||||
|
pulse_timing: Tuple[float, float] | None = None,
|
||||||
|
optics_observed_now: float | None = None,
|
||||||
|
+ stop_trace: list[str] | None = None,
|
||||||
|
) -> float:
|
||||||
|
"""Break continuous zoom-in into short feedback-controlled steps."""
|
||||||
|
pulse_until = float(st.get("zoom_step_until", 0.0) or 0.0)
|
||||||
|
@@ -4581,15 +4593,15 @@
|
||||||
|
return float(zoom_cmd if can_zoom_in else 0.0)
|
||||||
|
if bool(st.get("zoom_no_effect_blocked", False)):
|
||||||
|
st["zoom_followup_reason"] = "no_effect_limit"
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("no_effect_limit", stop_trace)
|
||||||
|
if not can_zoom_in:
|
||||||
|
if pulse_until > 0.0 or bool(st.get("zoom_step_pending", False)):
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("permission", stop_trace)
|
||||||
|
|
||||||
|
if bool(st.get("zoom_step_pending", False)):
|
||||||
|
if bool(st.get("zoom_step_cancel_requested", False)):
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("cancel_requested", stop_trace)
|
||||||
|
if pulse_timing is not None:
|
||||||
|
try:
|
||||||
|
authorized = tuple(map(float, pulse_timing))
|
||||||
|
@@ -4602,7 +4614,7 @@
|
||||||
|
timing_ok = False
|
||||||
|
if not timing_ok:
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("pending_timing", stop_trace)
|
||||||
|
useful_cmd = float(st.get("zoom_step_pending_useful_cmd", 0.0) or 0.0)
|
||||||
|
if useful_cmd > 0.0:
|
||||||
|
# A useful-pulse caller revalidates its entire framing envelope on
|
||||||
|
@@ -4614,7 +4626,7 @@
|
||||||
|
or float(getattr(config, "ZOOM_STEP_MAX_IN_CMD", 0.12)) < useful_cmd
|
||||||
|
):
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("pending_native_floor", stop_trace)
|
||||||
|
zoom_cmd = useful_cmd
|
||||||
|
physical_started = float(st.get("zoom_step_physical_started_at", 0.0) or 0.0)
|
||||||
|
if physical_started > 0.0:
|
||||||
|
@@ -4624,7 +4636,7 @@
|
||||||
|
float(getattr(config, "ZOOM_STEP_MAX_IN_CMD", 0.18)),
|
||||||
|
)
|
||||||
|
_finish_zoom_step(st, now, stable_key=stable_key)
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("pulse_window_ended", stop_trace)
|
||||||
|
expires_at = float(st.get("zoom_step_pending_expires_at", 0.0) or 0.0)
|
||||||
|
if expires_at > 0.0 and float(now) >= expires_at:
|
||||||
|
_clear_pending_zoom_request(
|
||||||
|
@@ -4633,7 +4645,7 @@
|
||||||
|
reason="delivery_timeout",
|
||||||
|
retry_cooldown=True,
|
||||||
|
)
|
||||||
|
- return 0.0
|
||||||
|
+ return _reject_zoom_step("delivery_timeout", stop_trace)
|
||||||
|
# Keep authorizing the same request until the worker either delivers it
|
||||||
|
# or a newer safety command cancels it. No counters are consumed here.
|
||||||
|
return min(
|
||||||
|
@@ -8614,6 +8626,7 @@
|
||||||
|
)
|
||||||
|
if approach_margin is not None:
|
||||||
|
lock_gate = max(lock_gate, .12)
|
||||||
|
+ center_sample = []
|
||||||
|
center_locked_for_zoom = _update_zoom_center_lock(
|
||||||
|
st,
|
||||||
|
now,
|
||||||
|
@@ -8625,6 +8638,7 @@
|
||||||
|
vx=float(zoom_vx),
|
||||||
|
vy=float(zoom_vy),
|
||||||
|
center_gate=lock_gate,
|
||||||
|
+ settled_sample=center_sample,
|
||||||
|
)
|
||||||
|
|
||||||
|
use_zoom_v3 = bool(getattr(config, "ZOOM_V3_ENABLE", True))
|
||||||
|
@@ -8867,6 +8881,9 @@
|
||||||
|
and now >= float(st.get("focus_settle_until", 0.0) or 0.0)
|
||||||
|
)
|
||||||
|
|
||||||
|
+ center_settled = center_sample[0] if center_sample else None
|
||||||
|
+ track_stable = int(st.get("stable_frames", 0) or 0) >= min_stable
|
||||||
|
+
|
||||||
|
# A safe probe is an explicit bounded identification request, not merely
|
||||||
|
# permission for the ordinary size controller. Without this request a
|
||||||
|
# tiny distant aircraft could pass every probe gate yet never zoom because
|
||||||
|
@@ -8929,6 +8946,7 @@
|
||||||
|
if size_err_abs <= float(getattr(config, "ZOOM_V3_BRAKE_ERR", 0.030)):
|
||||||
|
zoom_ff = 0.0
|
||||||
|
zoom_cmd = clipf(zoom_pi + zoom_ff, _Z_SPEED_LIMIT_OUT, _Z_SPEED_LIMIT_IN)
|
||||||
|
+ zoom_zero_reason = "size_controller"
|
||||||
|
if not out_edge_crit:
|
||||||
|
brake_err = float(getattr(config, "ZOOM_V3_BRAKE_ERR", 0.030))
|
||||||
|
brake_k = clipf(abs(err_size) / max(1e-6, brake_err), 0.0, 1.0)
|
||||||
|
@@ -8936,6 +8954,7 @@
|
||||||
|
|
||||||
|
if st.get("zoom_lock", False) and not bounded_identification_request:
|
||||||
|
zoom_cmd = min(zoom_cmd, -0.12) if out_edge_effective else 0.0
|
||||||
|
+ zoom_zero_reason = "zoom_lock"
|
||||||
|
st["zoom_int"] *= 0.90
|
||||||
|
else:
|
||||||
|
if st["zoom_state"] > 0:
|
||||||
|
@@ -8947,6 +8966,7 @@
|
||||||
|
if normal_size_hold and not out_edge_effective:
|
||||||
|
st["zoom_state"] = 0
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
+ zoom_zero_reason = "size_hold"
|
||||||
|
st["zoom_int"] *= 0.70
|
||||||
|
st["zoom_size_rate"] = float(st.get("zoom_size_rate", 0.0) or 0.0) * 0.6
|
||||||
|
if cruise_active and (not approaching) and (not out_edge_effective) and (not near_react_edge):
|
||||||
|
@@ -8973,6 +8993,7 @@
|
||||||
|
last_flip = float(st.get("zoom_v3_last_sign_flip_t", 0.0) or 0.0)
|
||||||
|
if (now - last_flip) < sign_cd:
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
+ zoom_zero_reason = "sign_cooldown"
|
||||||
|
else:
|
||||||
|
st["zoom_v3_last_sign_flip_t"] = now
|
||||||
|
|
||||||
|
@@ -8983,6 +9004,8 @@
|
||||||
|
elif z_state < 0:
|
||||||
|
zoom_cmd = -_Z_MIN_CMD
|
||||||
|
else:
|
||||||
|
+ if zoom_cmd != 0.0:
|
||||||
|
+ zoom_zero_reason = "deadband"
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
|
||||||
|
cmd_mag_est = max(
|
||||||
|
@@ -8993,10 +9016,14 @@
|
||||||
|
gate_v = float(getattr(config, "Z_VELOCITY_GATE", 0.45))
|
||||||
|
over_v = max(0.0, cmd_mag_est - gate_v)
|
||||||
|
zoom_cmd *= clipf(1.0 - over_v / max(1e-6, gate_v * 1.2), 0.0, 1.0)
|
||||||
|
+ if zoom_cmd == 0.0:
|
||||||
|
+ zoom_zero_reason = "steering_speed"
|
||||||
|
err_gate = float(getattr(config, "Z_ERR_GATE", 0.18))
|
||||||
|
if (max(abs(sm_dx), abs(sm_dy)) > err_gate) and (zoom_cmd > 0.0):
|
||||||
|
over_e = max(0.0, max(abs(sm_dx), abs(sm_dy)) - err_gate)
|
||||||
|
zoom_cmd *= clipf(1.0 - over_e / max(1e-6, err_gate * 1.5), 0.0, 1.0)
|
||||||
|
+ if zoom_cmd == 0.0:
|
||||||
|
+ zoom_zero_reason = "center_error"
|
||||||
|
# Center-first policy: when target is noticeably off-center, prioritize pan/tilt over zoom-in.
|
||||||
|
center_prio_err = float(getattr(config, "ZOOM_CENTER_PRIORITY_ERR", 0.11))
|
||||||
|
center_prio_margin = float(getattr(config, "ZOOM_CENTER_PRIORITY_MARGIN", 0.14))
|
||||||
|
@@ -9007,19 +9034,26 @@
|
||||||
|
zoom_cmd *= clipf(min_margin / max(1e-6, center_prio_margin), 0.0, 1.0)
|
||||||
|
if near_edge and zoom_cmd > 0.0:
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
+ zoom_zero_reason = "near_edge"
|
||||||
|
|
||||||
|
if zoom_cmd > 0.0:
|
||||||
|
vel_ref = float(getattr(config, "ZOOM_IN_SCALE_VEL_REF", 0.22))
|
||||||
|
vel_k = clipf(1.0 - vel / max(1e-6, vel_ref), float(getattr(config, "ZOOM_IN_SCALE_MIN", 0.20)), 1.0)
|
||||||
|
zoom_cmd *= min(zoom_safe_scale, vel_k)
|
||||||
|
-
|
||||||
|
+ if zoom_cmd == 0.0:
|
||||||
|
+ zoom_zero_reason = "framing_scale"
|
||||||
|
+
|
||||||
|
+ before_edge = zoom_cmd
|
||||||
|
zoom_cmd = _apply_predictive_edge_zoom_out(
|
||||||
|
zoom_cmd,
|
||||||
|
risk_margin=edge_risk_margin,
|
||||||
|
react_margin=react_margin,
|
||||||
|
moving_out=moving_out,
|
||||||
|
)
|
||||||
|
+ if before_edge > 0.0 and zoom_cmd <= 0.0:
|
||||||
|
+ zoom_zero_reason = "predictive_edge"
|
||||||
|
recent_zoom_steering = _recent_zoom_steering_active(st, now, zoom_cmd)
|
||||||
|
+ before_recenter = zoom_cmd
|
||||||
|
zoom_cmd = _apply_zoom_recenter_guard(
|
||||||
|
zoom_cmd,
|
||||||
|
center_err=float(center_err),
|
||||||
|
@@ -9027,6 +9061,8 @@
|
||||||
|
recent_zoom=bool(recent_zoom_steering),
|
||||||
|
approach_margin=approach_margin,
|
||||||
|
)
|
||||||
|
+ if before_recenter > 0.0 and zoom_cmd <= 0.0:
|
||||||
|
+ zoom_zero_reason = "recenter"
|
||||||
|
zoom_out_emergency = bool(
|
||||||
|
out_edge_effective
|
||||||
|
or float(min_margin) < float(getattr(config, "Z_SAFETY_EDGE", 0.05))
|
||||||
|
@@ -9114,6 +9150,8 @@
|
||||||
|
request_id_before_gate = int(st.get("zoom_step_request_id", 0) or 0)
|
||||||
|
with _zoom_command_lock(cam_idx):
|
||||||
|
zoom_gate_now = time.time()
|
||||||
|
+ decision_request = int(st.get("zoom_step_physical_request_id", 0) or
|
||||||
|
+ st.get("zoom_step_pending_id", 0) or 0)
|
||||||
|
pulse_family = str(st.get("zoom_step_pending_kind") or pulse_kind)
|
||||||
|
pulse_cap = float(getattr(config, "ZOOM_STEP_MAX_IN_CMD", 0.12))
|
||||||
|
if "probe" in pulse_family:
|
||||||
|
@@ -9142,6 +9180,7 @@
|
||||||
|
proposed_zoom_cmd = max(zoom_cmd, min(pre_ramp_zoom_cmd, pulse_cap, .12))
|
||||||
|
if _zoom_native_response_available(st, _zoom_speed_to_int(proposed_zoom_cmd), hfov_deg, shared_wide_hfov):
|
||||||
|
zoom_cmd = proposed_zoom_cmd
|
||||||
|
+ before_shape = zoom_cmd
|
||||||
|
zoom_cmd, useful_reason = _shape_useful_zoom_pulse(
|
||||||
|
zoom_cmd,
|
||||||
|
can_zoom_in=can_zoom_in,
|
||||||
|
@@ -9154,6 +9193,8 @@
|
||||||
|
approach_margin=approach_margin,
|
||||||
|
)
|
||||||
|
st["zoom_useful_pulse_reason"] = useful_reason
|
||||||
|
+ if before_shape > 0.0 and zoom_cmd <= 0.0:
|
||||||
|
+ zoom_zero_reason = useful_reason
|
||||||
|
response_timing = _select_zoom_response_timing(
|
||||||
|
st, useful=useful_reason == "useful",
|
||||||
|
hfov_deg=float(hfov_deg), wide_hfov_deg=float(shared_wide_hfov),
|
||||||
|
@@ -9166,6 +9207,8 @@
|
||||||
|
if useful_reason == "useful" and response_timing == (0.0, 0.0):
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
st["zoom_useful_pulse_reason"] = "wait_response_framing"
|
||||||
|
+ zoom_zero_reason = "response_framing"
|
||||||
|
+ gate_stop = [] if decision_request else None
|
||||||
|
zoom_cmd = _gate_zoom_in_pulse(
|
||||||
|
st,
|
||||||
|
# Keep new-request expiry tied to the frame that authorized
|
||||||
|
@@ -9180,7 +9223,10 @@
|
||||||
|
pulse_floor=(zoom_cmd if useful_reason == "useful" else 0.0),
|
||||||
|
pulse_timing=response_timing,
|
||||||
|
optics_observed_now=zoom_gate_now,
|
||||||
|
+ stop_trace=gate_stop,
|
||||||
|
)
|
||||||
|
+ if gate_stop:
|
||||||
|
+ zoom_zero_reason = gate_stop[-1]
|
||||||
|
if (
|
||||||
|
probe_start_candidate
|
||||||
|
and zoom_cmd > 0.0
|
||||||
|
@@ -9433,6 +9479,7 @@
|
||||||
|
or visual_control_coast != was_visual_control_coast
|
||||||
|
)
|
||||||
|
if visual_control_coast:
|
||||||
|
+ before_coast = zoom_cmd
|
||||||
|
adj_pan, adj_tilt, zoom_cmd = _bound_visual_coast_commands(
|
||||||
|
st,
|
||||||
|
adj_pan,
|
||||||
|
@@ -9463,7 +9510,11 @@
|
||||||
|
# Appearance continuity is sufficient for bounded steering only.
|
||||||
|
# It never authorizes an alarm without a current detector match.
|
||||||
|
alarm_eligible = False
|
||||||
|
+ if before_coast > 0.0 and zoom_cmd <= 0.0:
|
||||||
|
+ zoom_zero_reason = "visual_coast"
|
||||||
|
elif visual_control_stale:
|
||||||
|
+ if zoom_cmd > 0.0:
|
||||||
|
+ zoom_zero_reason = "visual_stale"
|
||||||
|
# Stale detector validation makes image-space steering unsafe, but a
|
||||||
|
# previously calculated edge-recovery zoom-out only widens the field
|
||||||
|
# of view. Preserve that bounded negative command while cancelling
|
||||||
|
@@ -9532,6 +9583,7 @@
|
||||||
|
# immediately by the forced command below.
|
||||||
|
if float(zoom_cmd) > 0.0:
|
||||||
|
zoom_cmd = 0.0
|
||||||
|
+ zoom_zero_reason = "final_brake"
|
||||||
|
st["zoom_prev_cmd"] = 0.0
|
||||||
|
st["stable_frames"] = 0
|
||||||
|
|
||||||
|
@@ -9673,7 +9725,33 @@
|
||||||
|
_arm_zoom_revalidation_locked(st, time.time(), 'visual_control_expired')
|
||||||
|
stop_ptz(cam_idx, source='stop', generation=int(st.get('ptz_generation', 0) or 0))
|
||||||
|
return
|
||||||
|
- _dispatch_owned_zoom_tracking(cam_idx, _PAN_SIGN * adj_pan, _TILT_SIGN * adj_tilt, zoom_cmd, force=force_track_ptz)
|
||||||
|
+ zoom_decision = None
|
||||||
|
+ if decision_request and zoom_cmd <= 0.0:
|
||||||
|
+ blockers = tuple(name for name, blocked in (
|
||||||
|
+ ("quality", not zoom_quality_ok),
|
||||||
|
+ ("framing", not zoom_safe),
|
||||||
|
+ ("followup", not followup_ready),
|
||||||
|
+ ("angle", not zoom_angular_safe),
|
||||||
|
+ ("center_sample_unknown", center_settled is None),
|
||||||
|
+ ("center_sample", center_settled is False),
|
||||||
|
+ ("center_history", center_settled is True and not center_locked_for_zoom),
|
||||||
|
+ ("track_history", not track_stable),
|
||||||
|
+ ("rearm", not zoom_rearm_ready),
|
||||||
|
+ ("edge", near_edge or edge_recovery_active),
|
||||||
|
+ ("lock", st.get("zoom_lock", False) and not bounded_identification_request),
|
||||||
|
+ ("drift", fast_drift > float(getattr(config, "ZOOM_IN_FAST_DRIFT_MAX", 0.45))),
|
||||||
|
+ ("focus", now < float(st.get("focus_settle_until", 0.0) or 0.0)),
|
||||||
|
+ ("coast", visual_control_coast),
|
||||||
|
+ ("stale", visual_control_stale),
|
||||||
|
+ ("brake", final_guard_active),
|
||||||
|
+ ) if blocked)
|
||||||
|
+ zoom_decision = (source_seq, decision_request, zoom_zero_reason, "+".join(blockers) or "-")
|
||||||
|
+ dispatch_kwargs = {"force": force_track_ptz}
|
||||||
|
+ if zoom_decision is not None:
|
||||||
|
+ dispatch_kwargs["zoom_decision"] = zoom_decision
|
||||||
|
+ _dispatch_owned_zoom_tracking(
|
||||||
|
+ cam_idx, _PAN_SIGN * adj_pan, _TILT_SIGN * adj_tilt, zoom_cmd, **dispatch_kwargs
|
||||||
|
+ )
|
||||||
|
if visual_control.enabled():
|
||||||
|
dispatch_at = time.monotonic()
|
||||||
|
samples = st.setdefault('control_dispatch_samples', [])
|
||||||
|
--- a/ptz_tracker_modular/ptz_io.py
|
||||||
|
+++ b/ptz_tracker_modular/ptz_io.py
|
||||||
|
@@ -1903,10 +1903,11 @@
|
||||||
|
source: Optional[str] = None,
|
||||||
|
generation: Optional[int] = None,
|
||||||
|
preset_floor_checked: bool = False,
|
||||||
|
+ zoom_decision: Optional[Tuple[Optional[int], int, str, str]] = None,
|
||||||
|
) -> None:
|
||||||
|
"""Serialize frame commands with the independent lens hard-stop timer."""
|
||||||
|
with _zoom_command_lock(cam_idx):
|
||||||
|
- _move_ptz_locked(
|
||||||
|
+ queued = _move_ptz_locked(
|
||||||
|
cam_idx,
|
||||||
|
pan,
|
||||||
|
tilt,
|
||||||
|
@@ -1915,6 +1916,15 @@
|
||||||
|
source=source,
|
||||||
|
generation=generation,
|
||||||
|
preset_floor_checked=preset_floor_checked,
|
||||||
|
+ zoom_decision=zoom_decision,
|
||||||
|
+ )
|
||||||
|
+ if zoom_decision is not None and queued is not None:
|
||||||
|
+ cmd_source, generation, seq, native_zoom = queued
|
||||||
|
+ frame, request, reason, blockers = zoom_decision
|
||||||
|
+ logger.info(
|
||||||
|
+ "[ZOOM DECISION] cam=%s frame=%s request=%s source=%s gen=%s seq=%s "
|
||||||
|
+ "queued_zoom=%s reason=%s blockers=%s",
|
||||||
|
+ cam_idx, frame, request, cmd_source, generation, seq, native_zoom, reason, blockers,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
@@ -1929,7 +1939,8 @@
|
||||||
|
generation: Optional[int] = None,
|
||||||
|
preset_floor_checked: bool = False,
|
||||||
|
hard_stop: bool = False,
|
||||||
|
-) -> None:
|
||||||
|
+ zoom_decision: Optional[Tuple[Optional[int], int, str, str]] = None,
|
||||||
|
+) -> Optional[Tuple[str, int, int, int]]:
|
||||||
|
"""
|
||||||
|
Отправка relative/continuous PTZ-команды.
|
||||||
|
|
||||||
|
@@ -2105,6 +2116,9 @@
|
||||||
|
# The MOVE is already queued. Report watchdog setup separately;
|
||||||
|
# pretending that the MOVE was dropped would corrupt dedupe state.
|
||||||
|
logger.error("[ZOOM WATCHDOG] setup failed cam=%s: %s", cam_idx, exc)
|
||||||
|
+ if zoom_decision is not None:
|
||||||
|
+ return cmd_source, cmd_generation, move_seq, zoom_i
|
||||||
|
+ return None
|
||||||
|
|
||||||
|
|
||||||
|
def stop_ptz(cam_idx: int, *, source: str = "stop", generation: Optional[int] = None) -> None:
|
||||||
|
@@ -2253,6 +2267,7 @@
|
||||||
|
force: bool = False,
|
||||||
|
source: Optional[str] = None,
|
||||||
|
generation: Optional[int] = None,
|
||||||
|
+ zoom_decision: Optional[Tuple[Optional[int], int, str, str]] = None,
|
||||||
|
) -> None:
|
||||||
|
"""
|
||||||
|
Обёртка над move_ptz.
|
||||||
|
@@ -2295,6 +2310,7 @@
|
||||||
|
source=source,
|
||||||
|
generation=generation,
|
||||||
|
preset_floor_checked=True,
|
||||||
|
+ zoom_decision=zoom_decision,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,71 @@
|
|||||||
|
"""Offline frame-to-queue/ACK tests built on the established fake PTZ worker."""
|
||||||
|
from unittest.mock import patch
|
||||||
|
|
||||||
|
|
||||||
|
def build_cases(replay_base, controller, transport):
|
||||||
|
class FrameDecision(replay_base):
|
||||||
|
def test_frame_decision_joins_protective_stop_ack(self):
|
||||||
|
self.start_pulse()
|
||||||
|
request = self.st["zoom_step_physical_request_id"]
|
||||||
|
with patch.object(controller, "_shape_useful_zoom_pulse",
|
||||||
|
return_value=(0.0, "stale_optics")) as shape:
|
||||||
|
with self.assertLogs("PTZTracker.PTZ", level="INFO") as logs:
|
||||||
|
row = self.tick(.035)
|
||||||
|
self.assertGreater(shape.call_args.args[0], 0.0)
|
||||||
|
decision = self.log_fields(logs, "[ZOOM DECISION]")
|
||||||
|
delivery = self.log_fields(logs, "[ZOOM DELIVERY]")
|
||||||
|
self.assertEqual(decision["frame"], str(row["seq"]))
|
||||||
|
self.assertEqual(decision["request"], str(request))
|
||||||
|
self.assertEqual(decision["reason"], "stale_optics")
|
||||||
|
self.assertEqual(decision["queued_zoom"], "0")
|
||||||
|
self.assertEqual(decision["source"], "track")
|
||||||
|
self.assertEqual(decision["gen"], delivery["stop_gen"])
|
||||||
|
self.assertEqual(decision["seq"], delivery["stop_seq"])
|
||||||
|
self.assertEqual(delivery["request"], str(request))
|
||||||
|
self.assertEqual(delivery["stop_effective"], "(0,0,0)")
|
||||||
|
self.assertEqual(row["sent"][-1], (0, 0, 0))
|
||||||
|
|
||||||
|
def test_center_history_is_distinct_from_current_sample(self):
|
||||||
|
for settled, expected in ((True, "center_history"), (False, "center_sample")):
|
||||||
|
with self.subTest(settled=settled):
|
||||||
|
self.start_pulse()
|
||||||
|
def unsettled(*args, settled_sample, **kwargs):
|
||||||
|
settled_sample.append(settled)
|
||||||
|
return False
|
||||||
|
with patch.object(controller, "_update_zoom_center_lock", side_effect=unsettled):
|
||||||
|
with self.assertLogs("PTZTracker.PTZ", level="INFO") as logs:
|
||||||
|
row = self.tick(.035)
|
||||||
|
decision = self.log_fields(logs, "[ZOOM DECISION]")
|
||||||
|
blockers = decision["blockers"].split("+")
|
||||||
|
self.assertEqual(decision["frame"], str(row["seq"]))
|
||||||
|
self.assertIn(expected, blockers)
|
||||||
|
self.assertNotIn("center_sample" if settled else "center_history", blockers)
|
||||||
|
self.assertEqual(row["sent"][-1], (0, 0, 0))
|
||||||
|
|
||||||
|
def test_dropped_move_does_not_emit_decision(self):
|
||||||
|
with patch.object(transport.state.ptz_cmd_q, "put_nowait", side_effect=RuntimeError("queue full")):
|
||||||
|
with self.assertLogs("PTZTracker.PTZ", level="INFO") as logs:
|
||||||
|
transport.move_ptz_bounded(self.cam, .1, .05, 0., force=True,
|
||||||
|
zoom_decision=(104, 7, "permission", "center_history"))
|
||||||
|
self.assertTrue(any("[PTZ QUEUE] drop" in entry for entry in logs.output))
|
||||||
|
self.assertFalse(any("[ZOOM DECISION]" in entry for entry in logs.output))
|
||||||
|
|
||||||
|
def start_pulse(self):
|
||||||
|
for _ in range(24):
|
||||||
|
row = self.tick(.1)
|
||||||
|
if any(axes[2] > 0 for axes in row["sent"]):
|
||||||
|
self.assertGreater(self.st["zoom_step_physical_request_id"], 0)
|
||||||
|
return
|
||||||
|
self.fail("No authorized zoom pulse in the offline fixture")
|
||||||
|
|
||||||
|
def log_fields(self, logs, tag):
|
||||||
|
entries = [entry for entry in logs.output if tag in entry]
|
||||||
|
self.assertEqual(len(entries), 1, logs.output)
|
||||||
|
return dict(part.split("=", 1) for part in entries[0].split(tag, 1)[1].split()
|
||||||
|
if "=" in part)
|
||||||
|
|
||||||
|
return [FrameDecision(name) for name in (
|
||||||
|
"test_frame_decision_joins_protective_stop_ack",
|
||||||
|
"test_center_history_is_distinct_from_current_sample",
|
||||||
|
"test_dropped_move_does_not_emit_decision",
|
||||||
|
)]
|
||||||
@ -0,0 +1,250 @@
|
|||||||
|
"""Replay the observed timing with synthetic intra-native demands."""
|
||||||
|
import json
|
||||||
|
from unittest.mock import patch
|
||||||
|
|
||||||
|
|
||||||
|
def build_floor_cases(boundary, controller_replay, pp, ptz_io, config, report_path, fixed,
|
||||||
|
*, threshold_diagnostics=False):
|
||||||
|
report = json.loads(report_path.read_bytes())
|
||||||
|
observed = [
|
||||||
|
(int(camera), decision)
|
||||||
|
for camera, episodes in report["episodes"].items()
|
||||||
|
for episode in episodes
|
||||||
|
for decision in episode["matched_decisions"]
|
||||||
|
if decision["reason"] == "pending_native_floor" and decision["result"] == "short"
|
||||||
|
]
|
||||||
|
|
||||||
|
class NativeFloor(boundary):
|
||||||
|
def seed(self, camera):
|
||||||
|
f = self.fixture(camera, "normal", 10, .34)
|
||||||
|
# The observed logs record native 10. This synthetic fraction has
|
||||||
|
# the same wire representation but a larger controller value.
|
||||||
|
f.st["zoom_step_pending_useful_cmd"] = .106
|
||||||
|
return f
|
||||||
|
|
||||||
|
def gate(self, f, command=.103, *, can=True, floor=None, timing=(.34, .40),
|
||||||
|
kind="normal", observed_now=None):
|
||||||
|
trace = []
|
||||||
|
value = pp._gate_zoom_in_pulse(
|
||||||
|
f.st, f.wall, command, can, pulse_kind=kind,
|
||||||
|
pulse_floor=command if floor is None else floor,
|
||||||
|
pulse_timing=timing,
|
||||||
|
optics_observed_now=f.wall if observed_now is None else observed_now,
|
||||||
|
stop_trace=trace,
|
||||||
|
)
|
||||||
|
return value, trace
|
||||||
|
|
||||||
|
def test_observed_native10_windows(self):
|
||||||
|
self.assertEqual(sorted(camera for camera, _ in observed), [19, 21])
|
||||||
|
for camera, row in observed:
|
||||||
|
with self.subTest(camera=camera, frame=row["frame"]):
|
||||||
|
self.assertEqual(row["native"], "10")
|
||||||
|
self.assertEqual(row["minimum"], "0.238s")
|
||||||
|
f = self.seed({19: 8, 21: 10}[camera])
|
||||||
|
timer = f.st["zoom_step_stop_timer"]
|
||||||
|
request = f.st["zoom_step_physical_request_id"]
|
||||||
|
deadline = f.st["zoom_step_until"]
|
||||||
|
hard = f.st["zoom_step_stop_started_mono"] + timer.delay
|
||||||
|
origin = f.st["zoom_step_put_started_mono"]
|
||||||
|
f._advance(float(row["duration"].removesuffix("s")))
|
||||||
|
shaped = f._shape(.103)
|
||||||
|
self.assertEqual(shaped, .103)
|
||||||
|
self.assertEqual(ptz_io._zoom_speed_to_int(shaped), 10)
|
||||||
|
self.assertEqual(ptz_io._zoom_speed_to_int(.106), 10)
|
||||||
|
with patch.object(config, "ZOOM_STEP_PULSE_SEC", .10):
|
||||||
|
self.assertEqual(pp._select_zoom_response_timing(
|
||||||
|
f.st, useful=False, hfov_deg=59., wide_hfov_deg=59.,
|
||||||
|
center_err=.02, margin=.45, image_rate=.01, requested_native=10
|
||||||
|
), (.10, .12))
|
||||||
|
timing = pp._select_zoom_response_timing(
|
||||||
|
f.st, useful=True, hfov_deg=59., wide_hfov_deg=59.,
|
||||||
|
center_err=.02, margin=.45, image_rate=.01, requested_native=10
|
||||||
|
)
|
||||||
|
self.assertEqual(timing, (.34, .40))
|
||||||
|
command, trace = self.gate(f, shaped, timing=timing)
|
||||||
|
self.assertEqual((command, trace), (.106, []) if fixed else (0., ["pending_native_floor"]))
|
||||||
|
pan, tilt, _ = row["requested"]
|
||||||
|
f._enqueue(command, pan=pan / 100, tilt=tilt / 100)
|
||||||
|
f._flush()
|
||||||
|
if not fixed:
|
||||||
|
self.assertEqual(f._zooms()[-1], 0)
|
||||||
|
self.assertEqual(f.st["zoom_step_last_delivery_result"], "short")
|
||||||
|
self.assertAlmostEqual(f.st["zoom_step_last_delivered_sec"],
|
||||||
|
float(row["duration"].removesuffix("s")))
|
||||||
|
continue
|
||||||
|
self.assertEqual(f._zooms()[-1], 10)
|
||||||
|
self.assertEqual(f.st["zoom_step_physical_request_id"], request)
|
||||||
|
self.assertEqual(f.st["zoom_step_until"], deadline)
|
||||||
|
self.assertEqual(f.st["zoom_step_put_started_mono"], origin)
|
||||||
|
active_timer = f.st["zoom_step_stop_timer"]
|
||||||
|
self.assertAlmostEqual(f.st["zoom_step_stop_started_mono"] + active_timer.delay, hard)
|
||||||
|
self.assertAlmostEqual(hard - origin, .40)
|
||||||
|
f._advance(hard - f.mono)
|
||||||
|
active_timer.fire()
|
||||||
|
self.assertEqual(f._zooms()[-1], 0)
|
||||||
|
self.assertEqual(f.st["zoom_step_physical_request_id"], 0)
|
||||||
|
self.assertNotEqual(f.st["zoom_step_last_delivery_result"], "short")
|
||||||
|
|
||||||
|
def test_stop_vetoes_keep_zero(self):
|
||||||
|
for name, state_change, gate_args, expected in (
|
||||||
|
("below_native10", {}, {"command": .0999999999}, "pending_native_floor"),
|
||||||
|
("floor_missing", {}, {"floor": 0.}, "pending_native_floor"),
|
||||||
|
("floor_invalid", {}, {"floor": float("nan")}, "pending_native_floor"),
|
||||||
|
("shorter_timing", {}, {"timing": (.10, .12)}, "pending_timing"),
|
||||||
|
("no_timing", {}, {"timing": None}, "pending_native_floor"),
|
||||||
|
("permission", {}, {"can": False}, "permission"),
|
||||||
|
("cancel", {"zoom_step_cancel_requested": True}, {}, "cancel_requested"),
|
||||||
|
("discard", {"zoom_step_discard_on_finalize": True}, {}, "pending_native_floor"),
|
||||||
|
("no_effect", {"zoom_no_effect_blocked": True}, {}, "no_effect_limit"),
|
||||||
|
("new_owner", {"ptz_generation": 5}, {}, "pending_native_floor"),
|
||||||
|
("new_track", {"track_started_at": 91.}, {}, "pending_native_floor"),
|
||||||
|
("new_request", {"zoom_step_physical_request_id": 7}, {}, "pending_native_floor"),
|
||||||
|
("no_delivery", {"zoom_step_physical_started_at": 0.}, {}, "pending_native_floor"),
|
||||||
|
("protective_stop", {"zoom_stop_obligation_active": True}, {}, "pending_native_floor"),
|
||||||
|
("watchdog_missing", {"zoom_step_stop_timer": None}, {}, "pending_native_floor"),
|
||||||
|
("watchdog_other_source", {"zoom_step_stop_source": "acquire"}, {}, "pending_native_floor"),
|
||||||
|
("probe", {"zoom_step_pending_kind": "probe"}, {"kind": "probe"}, "pending_native_floor"),
|
||||||
|
("reached_nominal_end", {}, {"observed_now": 101.}, "pending_native_floor"),
|
||||||
|
("real_zero", {}, {"command": 0.}, None),
|
||||||
|
):
|
||||||
|
with self.subTest(name=name):
|
||||||
|
f = self.seed(8)
|
||||||
|
f._advance(.05)
|
||||||
|
f.st.update(state_change)
|
||||||
|
value, trace = self.gate(f, **gate_args)
|
||||||
|
self.assertEqual(value, 0.)
|
||||||
|
self.assertEqual(trace, [expected] if expected else [])
|
||||||
|
f = self.seed(8)
|
||||||
|
f._advance(.05)
|
||||||
|
with patch.object(config, "ZOOM_STEP_MAX_IN_CMD", .104):
|
||||||
|
self.assertEqual(self.gate(f), (0., ["pending_native_floor"]))
|
||||||
|
|
||||||
|
class FrameFloor(controller_replay):
|
||||||
|
def test_track_frame_uses_native_continuation(self):
|
||||||
|
self.stack.enter_context(patch.object(config, "ZOOM_PROBE_ENABLE", False))
|
||||||
|
self.stack.enter_context(patch.object(config, "ZOOM_IDENTIFY_ENABLE", False))
|
||||||
|
shape = pp._shape_useful_zoom_pulse
|
||||||
|
def fraction(command, **kwargs):
|
||||||
|
demand = .103 if self.st.get("zoom_step_physical_request_id") else .106
|
||||||
|
return shape(demand if command > 0. else command, **kwargs)
|
||||||
|
with patch.object(pp, "_shape_useful_zoom_pulse", side_effect=fraction):
|
||||||
|
for _ in range(24):
|
||||||
|
row = self.tick(.1)
|
||||||
|
if any(axes[2] > 0 for axes in row["sent"]):
|
||||||
|
break
|
||||||
|
self.assertEqual(self.st["zoom_step_pending_useful_cmd"], .106)
|
||||||
|
deadline = self.st["zoom_step_until"]
|
||||||
|
with (patch.object(pp, "_gate_zoom_in_pulse", wraps=pp._gate_zoom_in_pulse) as gate,
|
||||||
|
patch.object(pp.logger, "info", wraps=pp.logger.info) as log):
|
||||||
|
row = self.tick(.06)
|
||||||
|
events = [call.args for call in log.call_args_list if "[ZOOM CONTINUE]" in call.args[0]]
|
||||||
|
self.assertEqual(len(events), int(fixed))
|
||||||
|
if events:
|
||||||
|
fmt, *values = events[0]
|
||||||
|
self.assertEqual(values[0:2], [self.cam, row["seq"]])
|
||||||
|
self.assertEqual(values[2], self.st["zoom_step_physical_request_id"])
|
||||||
|
self.assertEqual(values[3], self.st["ptz_generation"])
|
||||||
|
self.assertEqual(values[4:8], [10, .103, .106, deadline])
|
||||||
|
self.assertEqual(values[8:11], [.34, .40, .106])
|
||||||
|
self.assertIn("reason=same_native", fmt % tuple(values))
|
||||||
|
self.assertEqual(gate.call_args.args[2], .103)
|
||||||
|
if fixed:
|
||||||
|
self.assertEqual(self.st["zoom_step_until"], deadline)
|
||||||
|
self.assertEqual(self.fixture._zooms()[-1], 10)
|
||||||
|
else:
|
||||||
|
self.assertEqual(row["sent"][-1], (0, 0, 0))
|
||||||
|
self.assertEqual(self.st["zoom_step_last_delivery_result"], "short")
|
||||||
|
with patch.object(pp.logger, "info", wraps=pp.logger.info) as log:
|
||||||
|
self.tick(.05, detector=False, score=.1)
|
||||||
|
self.assertFalse(any("[ZOOM CONTINUE]" in call.args[0] for call in log.call_args_list))
|
||||||
|
|
||||||
|
class Thresholds(controller_replay):
|
||||||
|
def begin_normal_pulse(self):
|
||||||
|
self.stack.enter_context(patch.object(config, "ZOOM_PROBE_ENABLE", False))
|
||||||
|
self.stack.enter_context(patch.object(config, "ZOOM_IDENTIFY_ENABLE", False))
|
||||||
|
self.stack.enter_context(patch.dict(config.CAMERA_CONFIG[self.cam], {"zoom_fast_approach": False}))
|
||||||
|
for _ in range(24):
|
||||||
|
row = self.tick(.1)
|
||||||
|
if any(axes[2] > 0 for axes in row["sent"]):
|
||||||
|
return self.st["zoom_step_physical_request_id"]
|
||||||
|
self.fail("Normal pulse did not start")
|
||||||
|
|
||||||
|
def test_response_framing_reports_the_rejected_frame(self):
|
||||||
|
request = self.begin_normal_pulse()
|
||||||
|
select = pp._select_zoom_response_timing
|
||||||
|
|
||||||
|
def with_excess_rate(st, **values):
|
||||||
|
return select(st, **{**values, "image_rate": .041})
|
||||||
|
|
||||||
|
with (patch.object(config, "ZOOM_STEP_PULSE_SEC", .10),
|
||||||
|
patch.object(pp, "_select_zoom_response_timing", side_effect=with_excess_rate),
|
||||||
|
patch.object(pp.logger, "info", wraps=pp.logger.info) as log):
|
||||||
|
row = self.tick(.06)
|
||||||
|
events = [c.args for c in log.call_args_list if "[ZOOM THRESHOLD]" in c.args[0]]
|
||||||
|
self.assertEqual(len(events), 1, (row, log.call_args_list))
|
||||||
|
fmt, cam, frame, logged_request, generation, reason, raw = events[0]
|
||||||
|
self.assertEqual((cam, frame, logged_request, reason),
|
||||||
|
(self.cam, row["seq"], request, "response_framing"))
|
||||||
|
detail = json.loads(raw)
|
||||||
|
self.assertEqual(detail["check"], "framing")
|
||||||
|
self.assertEqual((detail["image_rate"], detail["image_rate_max"]), (.041, .04))
|
||||||
|
self.assertEqual(row["sent"][-1], (0, 0, 0))
|
||||||
|
|
||||||
|
with (patch.object(config, "ZOOM_STEP_PULSE_SEC", .10),
|
||||||
|
patch.object(config, "AIM_GIMBAL_FF_VIDEO_LATENCY_SEC", .45),
|
||||||
|
patch.object(config, "PTZ_LENS_STOP_DIRECT_TIMEOUT_SEC", .75)):
|
||||||
|
for change, check, observed, limit in (
|
||||||
|
({"hfov_deg": 40., "image_rate": .021}, "narrow_fov", "image_rate", "image_rate_max"),
|
||||||
|
({"margin": .35, "image_rate": .04}, "projected_margin", "projected_margin", "margin_min"),
|
||||||
|
):
|
||||||
|
trace = {}
|
||||||
|
inputs = dict(useful=True, hfov_deg=59., wide_hfov_deg=59.,
|
||||||
|
center_err=.01, margin=.45, image_rate=.01)
|
||||||
|
inputs.update(change)
|
||||||
|
state = {"zoom_response_effective_sec": .34}
|
||||||
|
self.assertEqual(select(state, **inputs), (0., 0.))
|
||||||
|
self.assertEqual(select(state, rejection=trace, **inputs), (0., 0.))
|
||||||
|
self.assertEqual(trace["check"], check)
|
||||||
|
if check == "narrow_fov":
|
||||||
|
self.assertGreater(trace[observed], trace[limit])
|
||||||
|
else:
|
||||||
|
self.assertLess(trace[observed], trace[limit])
|
||||||
|
|
||||||
|
def test_size_controller_reports_the_failed_angle_and_zero_stage(self):
|
||||||
|
request = self.begin_normal_pulse()
|
||||||
|
safe = pp._zoom_angular_motion_safe
|
||||||
|
|
||||||
|
def with_excess_pan(**values):
|
||||||
|
return safe(**{**values, "pan_error_deg": 9., "pan_rate_deg_s": 0.})
|
||||||
|
|
||||||
|
with (patch.object(pp, "_zoom_angular_motion_safe", side_effect=with_excess_pan),
|
||||||
|
patch.object(pp, "_zoom_approach_margin", return_value=None),
|
||||||
|
patch.object(config, "Z_DEADBAND", .99),
|
||||||
|
patch.object(config, "ZOOM_V3_CMD_MAX_STEP", .2),
|
||||||
|
patch.object(pp, "_Z_I", 0.),
|
||||||
|
patch.object(pp, "_Z_FF_GAIN", 0.),
|
||||||
|
patch.object(pp.logger, "info", wraps=pp.logger.info) as log):
|
||||||
|
row = self.tick(.06)
|
||||||
|
events = [c.args for c in log.call_args_list if "[ZOOM THRESHOLD]" in c.args[0]]
|
||||||
|
self.assertEqual(len(events), 1, (row, log.call_args_list))
|
||||||
|
fmt, cam, frame, logged_request, generation, reason, raw = events[0]
|
||||||
|
self.assertEqual((cam, frame, logged_request, reason),
|
||||||
|
(self.cam, row["seq"], request, "size_controller"))
|
||||||
|
detail = json.loads(raw)
|
||||||
|
self.assertEqual(detail["angular"]["pan_error_deg"], 9.)
|
||||||
|
self.assertIn("pan_error", detail["angular"]["failed"])
|
||||||
|
self.assertLess(detail["angular"]["pan_limit_deg"], 9.)
|
||||||
|
self.assertEqual((detail["size_error"], detail["after_minimum"]), (0., 0.))
|
||||||
|
self.assertEqual(row["sent"][-1], (0, 0, 0))
|
||||||
|
|
||||||
|
cases = [
|
||||||
|
NativeFloor("test_observed_native10_windows"),
|
||||||
|
NativeFloor("test_stop_vetoes_keep_zero"),
|
||||||
|
FrameFloor("test_track_frame_uses_native_continuation"),
|
||||||
|
]
|
||||||
|
if threshold_diagnostics:
|
||||||
|
cases += [
|
||||||
|
Thresholds("test_response_framing_reports_the_rejected_frame"),
|
||||||
|
Thresholds("test_size_controller_reports_the_failed_angle_and_zero_stage"),
|
||||||
|
]
|
||||||
|
return cases
|
||||||
@ -0,0 +1,9 @@
|
|||||||
|
{
|
||||||
|
"baseline_tests_passed": 10,
|
||||||
|
"candidate_tests_passed": 13,
|
||||||
|
"historical_worker_cases_matched": 19,
|
||||||
|
"shared_controller_frames_identical": 23,
|
||||||
|
"real_camera_or_model_access": false,
|
||||||
|
"patch_apply_and_reverse_byte_exact": true,
|
||||||
|
"historical_decision_reason_recovered": false
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue