You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
484 lines
23 KiB
Diff
484 lines
23 KiB
Diff
--- a/postprocess.py
|
|
+++ b/postprocess.py
|
|
@@ -12,7 +12,7 @@
|
|
|
|
from . import config, state, visual_control
|
|
from .zoom_controller import (
|
|
- ZoomFrame, controller_for_track, expire_calibration, flush_zoom_blocks, record_zoom_blocks, telemetry_tick,
|
|
+ ZoomFrame, _episode_telemetry, controller_for_track, expire_calibration, flush_zoom_blocks, record_zoom_blocks, telemetry_tick,
|
|
)
|
|
from . import motion_detector
|
|
from .utils import (
|
|
@@ -690,6 +690,8 @@
|
|
def _focus_quality_score(
|
|
frame_bgr: np.ndarray,
|
|
bbox: Tuple[int, int, int, int] | list[int],
|
|
+ *,
|
|
+ roi_scale: float | None = None,
|
|
) -> float | None:
|
|
"""Return Laplacian focus energy from a bounded ROI around the target.
|
|
|
|
@@ -708,7 +710,7 @@
|
|
if not np.isfinite([x1, y1, x2, y2]).all() or x2 <= x1 or y2 <= y1:
|
|
return None
|
|
|
|
- scale = max(1.0, float(getattr(config, "AUTOFOCUS_ROI_SCALE", 2.5)))
|
|
+ scale = max(1.0, float(getattr(config, "AUTOFOCUS_ROI_SCALE", 2.5) if roi_scale is None else roi_scale))
|
|
cx = (x1 + x2) * 0.5
|
|
cy = (y1 + y2) * 0.5
|
|
roi_w = max(16.0, (x2 - x1) * scale)
|
|
@@ -741,6 +743,154 @@
|
|
return score if math.isfinite(score) else None
|
|
|
|
|
|
+@dataclass(frozen=True, slots=True)
|
|
+class _PTZ17ZoomTuning:
|
|
+ focus_max_hfov_deg: float = 18.0
|
|
+ focus_min_side_px: int = 20
|
|
+ focus_core_only_threshold_scale: float = 8.0
|
|
+ focus_unknown_retry_s: float = 0.60
|
|
+ focus_unknown_max_gap_s: float = 0.25
|
|
+ focus_recovery_samples: int = 2
|
|
+ frame_max_age_s: float = 0.25
|
|
+ detector_max_age_s: float = 0.65
|
|
+ first_pulse_s: float = 0.34
|
|
+ hard_stop_s: float = 0.40
|
|
+ startup_native: int = 10
|
|
+ projected_margin_min: float = 0.16
|
|
+ edge_margin_min: float = 0.30
|
|
+ center_max_norm: float = 0.12
|
|
+ image_rate_max_norm_s: float = 0.04
|
|
+
|
|
+
|
|
+_PTZ17_ZOOM = _PTZ17ZoomTuning()
|
|
+
|
|
+
|
|
+def _record_ptz17_decision(st: dict, at: float, **fields: Any) -> None:
|
|
+ """Publish decision metadata to the existing bounded asynchronous queue."""
|
|
+ generation, started_at = visual_control.owner(st)[1:3]
|
|
+ if started_at <= 0.0 or not math.isfinite(started_at):
|
|
+ return
|
|
+ values = {
|
|
+ key: None if isinstance(value, float) and not math.isfinite(value) else value
|
|
+ for key, value in fields.items()
|
|
+ }
|
|
+ _episode_telemetry(config, _PTZ17_CAM_IDX, (generation, started_at),
|
|
+ "decision_frame", at, **values)
|
|
+
|
|
+
|
|
+def _ptz17_target_focus_score(
|
|
+ frame_bgr: np.ndarray, bbox: tuple[int, int, int, int] | list[int],
|
|
+) -> float | None:
|
|
+ """Assess target detail when the wider crop has little contrast."""
|
|
+ core = _focus_quality_score(frame_bgr, bbox, roi_scale=1.0)
|
|
+ if core is None:
|
|
+ return None
|
|
+ expanded = _focus_quality_score(frame_bgr, bbox)
|
|
+ if expanded is not None:
|
|
+ return min(core, expanded)
|
|
+ threshold = max(0.0, float(getattr(config, "AUTOFOCUS_BLUR_THRESHOLD", 35.0)))
|
|
+ if core >= threshold * _PTZ17_ZOOM.focus_core_only_threshold_scale:
|
|
+ return core
|
|
+ return None
|
|
+
|
|
+
|
|
+def _ptz17_focus_hold(
|
|
+ st: dict, *, hfov_deg: float, side_px: int, frame_is_current: bool, captured_at: float,
|
|
+) -> str | None:
|
|
+ """Keep the lens at its current FOV while the settled target is blurry."""
|
|
+ owner = visual_control.owner(st)
|
|
+ if owner[2] <= 0.0 or not 0.0 < hfov_deg <= _PTZ17_ZOOM.focus_max_hfov_deg:
|
|
+ st.pop("ptz17_focus_hold", None)
|
|
+ st.pop("ptz17_focus_recovery", None)
|
|
+ return None
|
|
+ previous = st.get("ptz17_focus_hold")
|
|
+ reason = previous[1] if previous is not None and previous[0] == owner else None
|
|
+ if not frame_is_current or not math.isfinite(captured_at):
|
|
+ return reason
|
|
+ focus_state = st.get("focus_state")
|
|
+ if focus_state == "disabled":
|
|
+ reason = None
|
|
+ elif side_px >= _PTZ17_ZOOM.focus_min_side_px:
|
|
+ if focus_state == "sharp" and reason is not None:
|
|
+ recovery = st.get("ptz17_focus_recovery")
|
|
+ votes = 1
|
|
+ if recovery is not None and recovery[0] == owner:
|
|
+ gap_s = captured_at - recovery[1]
|
|
+ if gap_s <= 0.0:
|
|
+ return reason
|
|
+ if gap_s <= _PTZ17_ZOOM.focus_unknown_max_gap_s:
|
|
+ votes += recovery[2]
|
|
+ st["ptz17_focus_recovery"] = (owner, captured_at, votes)
|
|
+ if votes >= _PTZ17_ZOOM.focus_recovery_samples:
|
|
+ reason = None
|
|
+ elif focus_state in {
|
|
+ "blur_suspected", "blur_fast_suspected", "blur_cooldown", "blur_wait",
|
|
+ "unassessable", "requested", "settling",
|
|
+ }:
|
|
+ reason = str(focus_state)
|
|
+ if focus_state != "sharp" or side_px < _PTZ17_ZOOM.focus_min_side_px or reason is None:
|
|
+ st.pop("ptz17_focus_recovery", None)
|
|
+ if reason is not None:
|
|
+ st["ptz17_focus_hold"] = (owner, reason)
|
|
+ else:
|
|
+ st.pop("ptz17_focus_hold", None)
|
|
+ return reason
|
|
+
|
|
+
|
|
+def _ptz17_unassessable_retry_ready(st: dict, captured_at: float) -> bool:
|
|
+ """Authorize one recovery attempt per track owner after sustained low contrast."""
|
|
+ owner = visual_control.owner(st)
|
|
+ evidence = st.get("ptz17_focus_unknown")
|
|
+ if owner[2] <= 0.0 or not math.isfinite(captured_at):
|
|
+ return False
|
|
+ if evidence is None or evidence[0] != owner:
|
|
+ st["ptz17_focus_unknown"] = (owner, captured_at, captured_at)
|
|
+ return False
|
|
+ if st.get("ptz17_focus_unknown_attempt") == owner:
|
|
+ return False
|
|
+ gap_s = captured_at - evidence[2]
|
|
+ if gap_s <= 0.0:
|
|
+ return False
|
|
+ since = captured_at if gap_s > _PTZ17_ZOOM.focus_unknown_max_gap_s else evidence[1]
|
|
+ st["ptz17_focus_unknown"] = (owner, since, captured_at)
|
|
+ return captured_at - since >= _PTZ17_ZOOM.focus_unknown_retry_s
|
|
+
|
|
+
|
|
+def _ptz17_first_useful_timing(
|
|
+ st: dict, timing: tuple[float, float], *, native: int, normal_onset: bool,
|
|
+ frame_age_s: float, detector_age_s: float, hfov_deg: float, wide_hfov_deg: float,
|
|
+ approach_margin: float | None, edge_margin: float, center_error: float, image_rate: float,
|
|
+) -> tuple[float, float]:
|
|
+ """Select the longer measured-response candidate within existing deadlines."""
|
|
+ tuning = _PTZ17_ZOOM
|
|
+ if (
|
|
+ not normal_onset or timing[0] <= 0.0 or native != tuning.startup_native
|
|
+ or st.get("zoom_no_effect_blocked")
|
|
+ or st.get("zoom_stop_obligation_active") or st.get("lens_move_stop_required")
|
|
+ or not 0.0 <= frame_age_s <= tuning.frame_max_age_s
|
|
+ or not 0.0 <= detector_age_s <= tuning.detector_max_age_s
|
|
+ or not 0.0 < hfov_deg <= wide_hfov_deg < 180.0
|
|
+ or hfov_deg < wide_hfov_deg * max(.85, float(getattr(config, "ZOOM_RESPONSE_WIDE_RATIO", .85)))
|
|
+ or approach_margin is None or not tuning.projected_margin_min <= approach_margin <= .5
|
|
+ or not tuning.edge_margin_min <= edge_margin <= .5
|
|
+ or not 0.0 <= center_error <= tuning.center_max_norm
|
|
+ or not 0.0 <= image_rate <= tuning.image_rate_max_norm_s
|
|
+ ):
|
|
+ return timing
|
|
+ if st.get("zoom_step_pending"):
|
|
+ # Revalidate only the original request created by the PTZ17 profile.
|
|
+ # The existing pulse gate owns the pending timer and expiry.
|
|
+ marker = st.get("ptz17_first_timing_owner")
|
|
+ if marker == (visual_control.owner(st), st.get("zoom_step_pending_id")):
|
|
+ return (float(st["zoom_step_pending_pulse_sec"]), float(st["zoom_step_pending_hard_sec"]))
|
|
+ return timing
|
|
+ if int(st.get("zoom_step_request_id", 0) or 0) != 0:
|
|
+ return timing
|
|
+ pulse = min(tuning.first_pulse_s, float(getattr(config, "ZOOM_RESPONSE_MAX_PULSE_SEC", .34)))
|
|
+ hard = min(tuning.hard_stop_s, float(getattr(config, "ZOOM_RESPONSE_MAX_HARD_STOP_SEC", .40)))
|
|
+ return (pulse, hard) if timing[0] < pulse <= hard and timing[1] <= hard else timing
|
|
+
|
|
+
|
|
def _clear_focus_low_evidence(st: dict) -> None:
|
|
st["focus_quality_low_frames"] = 0
|
|
st["focus_quality_low_since"] = None
|
|
@@ -761,6 +911,7 @@
|
|
center_err: float,
|
|
hfov_deg: float,
|
|
validation_age: float,
|
|
+ allow_unassessable_retry: bool = False,
|
|
) -> bool:
|
|
"""Measure settled target detail and queue one bounded autofocus request."""
|
|
if not bool(getattr(config, "AUTOFOCUS_QUALITY_ENABLE", True)) or not bool(
|
|
@@ -833,14 +984,31 @@
|
|
_clear_focus_low_evidence(st)
|
|
st["focus_last_hfov_deg"] = float(hfov_deg)
|
|
|
|
- score = _focus_quality_score(frame_bgr, bbox)
|
|
+ score = (
|
|
+ _ptz17_target_focus_score(frame_bgr, bbox)
|
|
+ if cam_idx == _PTZ17_CAM_IDX and float(hfov_deg) <= _PTZ17_ZOOM.focus_max_hfov_deg
|
|
+ else _focus_quality_score(frame_bgr, bbox)
|
|
+ )
|
|
st["focus_quality_last_eval_at"] = float(now)
|
|
st["focus_quality_score"] = score
|
|
+ unknown_retry = False
|
|
if score is None:
|
|
st["focus_state"] = "unassessable"
|
|
_clear_focus_low_evidence(st)
|
|
- return False
|
|
-
|
|
+ unknown_retry = (
|
|
+ allow_unassessable_retry and cam_idx == _PTZ17_CAM_IDX
|
|
+ and 0.0 < hfov_deg <= _PTZ17_ZOOM.focus_max_hfov_deg
|
|
+ and 0.0 <= validation_age <= _PTZ17_ZOOM.detector_max_age_s
|
|
+ and _ptz17_unassessable_retry_ready(st, now)
|
|
+ )
|
|
+ if not unknown_retry:
|
|
+ return False
|
|
+ else:
|
|
+ st.pop("ptz17_focus_unknown", None)
|
|
+
|
|
+ if unknown_retry:
|
|
+ return _queue_focus_recovery(cam_idx, st, now, reason="unassessable")
|
|
+ assert score is not None
|
|
alpha = clipf(float(getattr(config, "AUTOFOCUS_SCORE_EMA_ALPHA", 0.35)), 0.01, 1.0)
|
|
previous_ema = st.get("focus_quality_ema")
|
|
ema = float(score) if not isinstance(previous_ema, (int, float)) else (
|
|
@@ -870,7 +1038,10 @@
|
|
if ema >= threshold:
|
|
# Keep the independent raw-drop evidence while the deliberately slow
|
|
# EMA still describes the previously sharp scene.
|
|
- st["focus_state"] = "blur_fast_suspected" if raw_drop else "sharp"
|
|
+ ptz17_instant_low = (
|
|
+ allow_unassessable_retry and cam_idx == _PTZ17_CAM_IDX and score < threshold
|
|
+ )
|
|
+ st["focus_state"] = "blur_fast_suspected" if raw_drop or ptz17_instant_low else "sharp"
|
|
st["focus_quality_low_frames"] = 0
|
|
st["focus_quality_low_since"] = None
|
|
else:
|
|
@@ -916,12 +1087,19 @@
|
|
if not confirmed_low:
|
|
return False
|
|
|
|
+ return _queue_focus_recovery(cam_idx, st, now, reason="quality", score=score, ema=ema)
|
|
+
|
|
+
|
|
+def _queue_focus_recovery(
|
|
+ cam_idx: int, st: dict, now: float, *, reason: str,
|
|
+ score: float | None = None, ema: float | None = None,
|
|
+) -> bool:
|
|
request_cd = max(0.5, float(getattr(config, "AUTOFOCUS_REQUEST_COOLDOWN_SEC", 15.0)))
|
|
last_request = float(st.get("focus_last_request_at", 0.0) or 0.0)
|
|
if last_request > 0.0 and (float(now) - last_request) < request_cd:
|
|
st["focus_state"] = "blur_cooldown"
|
|
return False
|
|
- if not bool(call_autofocus(cam_idx, reason="quality")):
|
|
+ if not bool(call_autofocus(cam_idx, reason=reason)):
|
|
if str(st.get("focus_state", "")) not in {
|
|
"unsupported",
|
|
"unsupported_backoff",
|
|
@@ -931,6 +1109,8 @@
|
|
st["focus_state"] = "blur_wait"
|
|
return False
|
|
|
|
+ if reason == "unassessable":
|
|
+ st["ptz17_focus_unknown_attempt"] = visual_control.owner(st)
|
|
st["focus_state"] = "requested"
|
|
st["focus_last_request_at"] = float(now)
|
|
st["focus_settle_until"] = float(now) + max(
|
|
@@ -938,12 +1118,11 @@
|
|
float(getattr(config, "AUTOFOCUS_SETTLE_HOLD_SEC", 0.80)),
|
|
)
|
|
_clear_focus_low_evidence(st)
|
|
- logger.warning(
|
|
- "[FOCUS/QUALITY] cam=%s autofocus requested score=%.1f ema=%.1f",
|
|
- cam_idx,
|
|
- float(score),
|
|
- float(ema),
|
|
- )
|
|
+ if score is not None and ema is not None:
|
|
+ logger.warning("[FOCUS/QUALITY] cam=%s autofocus requested score=%.1f ema=%.1f",
|
|
+ cam_idx, score, ema)
|
|
+ else:
|
|
+ logger.warning("[FOCUS/QUALITY] cam=%s autofocus requested reason=%s", cam_idx, reason)
|
|
return True
|
|
|
|
|
|
@@ -9537,6 +9716,50 @@
|
|
max(0.0, float(getattr(config, min_key, 0.10))),
|
|
)
|
|
zoom_cmd = min(max_effective, max(float(zoom_cmd), min_effective))
|
|
+ ptz17_focus_reason = None
|
|
+ ptz17_focus_checked = False
|
|
+ if (cam_idx == _PTZ17_CAM_IDX and float(hfov_deg) <= _PTZ17_ZOOM.focus_max_hfov_deg
|
|
+ and not pulse_active and not st.get("zoom_step_pending")):
|
|
+ # Check the settled image before authorizing a fresh pulse. The
|
|
+ # existing autofocus worker and controller keep their own limits.
|
|
+ focus_wall_now = time.time()
|
|
+ lens_settled = (
|
|
+ not st.get("lens_move_put_inflight") and not st.get("zoom_stop_obligation_active")
|
|
+ and not st.get("lens_move_stop_required")
|
|
+ and (st.get("last_ptz_physical_cmd") or (0.0, 0.0, 0.0))[2] == 0.0
|
|
+ )
|
|
+ if (lens_settled and zoom_cmd >= 0.0 and visual_only
|
|
+ and visual_control.current(cam_idx, visual_sample, focus_wall_now,
|
|
+ max_age=_PTZ17_ZOOM.frame_max_age_s)):
|
|
+ _maybe_request_autofocus(
|
|
+ cam_idx, st, frame_bgr, (x1, y1, x2, y2), now=float(now),
|
|
+ pan_cmd=float(pan_speed) + float(pan_rate_ff),
|
|
+ tilt_cmd=float(tilt_speed) + float(tilt_rate_ff),
|
|
+ zoom_cmd=0.0, center_err=float(center_err), hfov_deg=float(hfov_deg),
|
|
+ validation_age=float(visual_control_validation_age),
|
|
+ allow_unassessable_retry=True,
|
|
+ )
|
|
+ ptz17_focus_checked = True
|
|
+ # A small but measurable crop can veto another zoom step.
|
|
+ # The higher size threshold for requesting autofocus still applies.
|
|
+ if (st.get("focus_state") == "target_too_small"
|
|
+ and min(x2 - x1, y2 - y1) >= _PTZ17_ZOOM.focus_min_side_px
|
|
+ and 0.0 <= visual_control_validation_age <= _PTZ17_ZOOM.detector_max_age_s):
|
|
+ target_score = _ptz17_target_focus_score(frame_bgr, (x1, y1, x2, y2))
|
|
+ st["ptz17_small_focus_at"] = now
|
|
+ st["focus_quality_score"] = target_score
|
|
+ threshold = float(getattr(config, "AUTOFOCUS_BLUR_THRESHOLD", 35.0))
|
|
+ st["focus_state"] = (
|
|
+ "unassessable" if target_score is None else
|
|
+ "sharp" if target_score >= threshold else "blur_suspected"
|
|
+ )
|
|
+ ptz17_focus_reason = _ptz17_focus_hold(
|
|
+ st, hfov_deg=float(hfov_deg), side_px=min(x2 - x1, y2 - y1),
|
|
+ frame_is_current=ptz17_focus_checked, captured_at=float(now),
|
|
+ )
|
|
+ if ptz17_focus_reason is not None and zoom_cmd > 0.0:
|
|
+ zoom_cmd = 0.0
|
|
+ zoom_zero_reason = "focus_hold"
|
|
if probe_start_candidate and identify_start_candidate:
|
|
pulse_kind = "probe_identify"
|
|
elif probe_start_candidate:
|
|
@@ -9645,8 +9868,30 @@
|
|
zoom_cmd = 0.0
|
|
st["zoom_useful_pulse_reason"] = "wait_response_framing"
|
|
zoom_zero_reason = "response_framing"
|
|
+ ptz17_timing_changed = False
|
|
+ if cam_idx == _PTZ17_CAM_IDX:
|
|
+ original_response_timing = response_timing
|
|
+ response_timing = _ptz17_first_useful_timing(
|
|
+ st, response_timing, native=timing_native,
|
|
+ normal_onset=(zoom_cmd > 0.0 and useful_reason == "useful" and useful_optics_fresh
|
|
+ and pulse_family == "normal"
|
|
+ and fast_approach and normal_zoom_quality_ok
|
|
+ and current_track_source == "visual" and not predictive_start
|
|
+ and bool(visual_only and visual_control.current(
|
|
+ cam_idx, visual_sample, zoom_gate_now,
|
|
+ max_age=_PTZ17_ZOOM.frame_max_age_s,
|
|
+ ))),
|
|
+ frame_age_s=zoom_gate_now - now,
|
|
+ detector_age_s=zoom_gate_now - last_visual_zoom_validation,
|
|
+ hfov_deg=float(hfov_deg), wide_hfov_deg=float(shared_wide_hfov),
|
|
+ approach_margin=approach_margin, edge_margin=float(edge_risk_margin),
|
|
+ center_error=max(abs(float(measured_dx)), abs(float(measured_dy))),
|
|
+ image_rate=max(float(vel), float(fast_drift)),
|
|
+ )
|
|
+ ptz17_timing_changed = response_timing != original_response_timing
|
|
gate_stop = [] if decision_request else None
|
|
continuation_trace = [] if decision_request else None
|
|
+ ptz17_zoom_before_gate = float(zoom_cmd) if cam_idx == _PTZ17_CAM_IDX else None
|
|
zoom_cmd = _gate_zoom_in_pulse(
|
|
st,
|
|
# Keep new-request expiry tied to the frame that authorized
|
|
@@ -9667,9 +9912,15 @@
|
|
)
|
|
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 (ptz17_timing_changed and zoom_cmd > 0.0
|
|
+ and st["zoom_step_request_id"] > request_id_before_gate):
|
|
+ st["ptz17_first_timing_owner"] = (visual_control.owner(st), st["zoom_step_pending_id"])
|
|
if gate_stop:
|
|
zoom_zero_reason = gate_stop[-1]
|
|
decision_generation = st.get("ptz_generation")
|
|
+ ptz17_request_after_gate = (
|
|
+ int(st.get("zoom_step_pending_id", 0) or 0) if cam_idx == _PTZ17_CAM_IDX else 0
|
|
+ )
|
|
if (
|
|
probe_start_candidate
|
|
and zoom_cmd > 0.0
|
|
@@ -9693,23 +9944,24 @@
|
|
elif zoom_cmd < 0.0 and float(size_est) <= max(0.05, zoomed_size_thr * 0.75):
|
|
st["was_zoomed_in"] = False
|
|
|
|
- _maybe_request_autofocus(
|
|
- cam_idx,
|
|
- st,
|
|
- frame_bgr,
|
|
- (x1, y1, x2, y2),
|
|
- now=float(now),
|
|
- pan_cmd=float(pan_speed) + float(pan_rate_ff),
|
|
- tilt_cmd=float(tilt_speed) + float(tilt_rate_ff),
|
|
- zoom_cmd=float(zoom_cmd),
|
|
- center_err=float(center_err),
|
|
- hfov_deg=float(hfov_deg),
|
|
- validation_age=(
|
|
- float(visual_control_validation_age)
|
|
- if current_track_source == "visual"
|
|
- else 0.0
|
|
- ),
|
|
- )
|
|
+ if not ptz17_focus_checked:
|
|
+ _maybe_request_autofocus(
|
|
+ cam_idx,
|
|
+ st,
|
|
+ frame_bgr,
|
|
+ (x1, y1, x2, y2),
|
|
+ now=float(now),
|
|
+ pan_cmd=float(pan_speed) + float(pan_rate_ff),
|
|
+ tilt_cmd=float(tilt_speed) + float(tilt_rate_ff),
|
|
+ zoom_cmd=float(zoom_cmd),
|
|
+ center_err=float(center_err),
|
|
+ hfov_deg=float(hfov_deg),
|
|
+ validation_age=(
|
|
+ float(visual_control_validation_age)
|
|
+ if current_track_source == "visual"
|
|
+ else 0.0
|
|
+ ),
|
|
+ )
|
|
|
|
st["fallback_done"] = False
|
|
|
|
@@ -10191,7 +10443,7 @@
|
|
stop_ptz(cam_idx, source='stop', generation=int(st.get('ptz_generation', 0) or 0))
|
|
return
|
|
zoom_decision = None
|
|
- if decision_request and zoom_cmd <= 0.0:
|
|
+ if (decision_request or cam_idx == _PTZ17_CAM_IDX) and zoom_cmd <= 0.0:
|
|
blockers = tuple(name for name, blocked in (
|
|
("quality", not zoom_quality_ok),
|
|
("framing", not zoom_safe),
|
|
@@ -10210,7 +10462,36 @@
|
|
("stale", visual_control_stale),
|
|
("brake", final_guard_active),
|
|
) if blocked)
|
|
- zoom_decision = (source_seq, decision_request, zoom_zero_reason, "+".join(blockers) or "-")
|
|
+ if decision_request:
|
|
+ zoom_decision = (source_seq, decision_request, zoom_zero_reason, "+".join(blockers) or "-")
|
|
+ if (cam_idx == _PTZ17_CAM_IDX and st.get("mode") == "TRACK"
|
|
+ and st.get("tracking_active") and source_seq is not None
|
|
+ and int(source_seq) > 0):
|
|
+ _record_ptz17_decision(
|
|
+ st, time.time(), frame_seq=int(source_seq), frame_utc=float(now),
|
|
+ frame_age_at_gate_s=zoom_gate_now - now, source=current_track_source,
|
|
+ bbox_px=[int(x1), int(y1), int(x2), int(y2)],
|
|
+ detector_age_at_gate_s=zoom_gate_now - last_visual_zoom_validation,
|
|
+ detector_conf=float(st.get("visual_tracker_last_detector_conf", 0.0) or 0.0),
|
|
+ tracker_score=float(st.get("visual_tracker_score", 0.0) or 0.0),
|
|
+ hfov_deg=float(hfov_deg), optics_age_s=float(optics_age),
|
|
+ center_error_norm=max(abs(float(measured_dx)), abs(float(measured_dy))),
|
|
+ edge_margin_norm=float(edge_risk_margin), approach_margin_norm=approach_margin,
|
|
+ image_rate_norm_s=max(float(vel), float(fast_drift)),
|
|
+ zoom_requested=bool(raw_zoom_needed), zoom_before_gate=ptz17_zoom_before_gate,
|
|
+ zoom_command=float(zoom_cmd), proposed_native=int(timing_native),
|
|
+ reason=zoom_zero_reason if zoom_cmd <= 0.0 else "positive_command",
|
|
+ blockers=list(blockers) if zoom_cmd <= 0.0 else [],
|
|
+ pulse_kind=str(pulse_kind), nominal_s=float(response_timing[0]),
|
|
+ hard_limit_s=float(response_timing[1]), timing_profile_changed=ptz17_timing_changed,
|
|
+ request_before_gate=decision_request, request_after_gate=ptz17_request_after_gate,
|
|
+ request_created=bool(ptz17_request_after_gate > request_id_before_gate),
|
|
+ focus_state=st.get("focus_state"), focus_hold=ptz17_focus_reason,
|
|
+ focus_sample_current=bool(st.get("focus_quality_last_eval_at") == now or (
|
|
+ ptz17_focus_checked and st.get("ptz17_small_focus_at") == now
|
|
+ )),
|
|
+ focus_score=st.get("focus_quality_score"),
|
|
+ )
|
|
if predictive_decision is not None:
|
|
with _zoom_command_lock(cam_idx):
|
|
telemetry_tick(
|
|
@@ -10222,6 +10503,8 @@
|
|
if getattr(config, "PREDICTIVE_ZOOM_TELEMETRY_DIR", "logs/ptz_zoom"):
|
|
blocked = {}
|
|
if zoom_cmd <= 0.0 and raw_zoom_needed:
|
|
+ if ptz17_focus_reason is not None:
|
|
+ blocked["focus_hold"] = {"state": ptz17_focus_reason}
|
|
if not stable_ok:
|
|
blocked["centering"] = {"error": center_err, "limit": lock_gate, "stable_frames": st.get("stable_frames")}
|
|
if not zoom_safe:
|