WIP: PTZ17 focus-aware optical zoom
#14
Draft
YaroslavKartashov
wants to merge 5 commits from feature/ptz17-focus-aware-zoom into feature/ptz17-yolo-steering
@ -0,0 +1,6 @@
|
||||
{
|
||||
"base_sha256": "6cf484271ef3659028b0b4d43041addb05102f91d2758ab472d968a52d24e911",
|
||||
"candidate_sha256": "f04d8a8d7a4105fe6812afaed00655dc42cbf7e6fb014e01d9f5efb306db13ca",
|
||||
"patch_sha256": "555d329a1c437187e254330384ec1dab60dc3fb8ac859c710c9cef517ac59dd5",
|
||||
"installed": false
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,390 @@
|
||||
{
|
||||
"1412": {
|
||||
"start_utc": "2026-11-13T07:12:02.328+00:00",
|
||||
"status_samples": 257,
|
||||
"first_send_s": 6.041,
|
||||
"first_start_s": 6.115,
|
||||
"first_confirmed_request": 3,
|
||||
"first_optics_s": 10.627,
|
||||
"startup_to_optics_s": 4.512,
|
||||
"first_logged_projection_s": 9.869,
|
||||
"first_request_projection_at_decision": "unknown",
|
||||
"requests": [
|
||||
{
|
||||
"request": 1,
|
||||
"kind": "normal",
|
||||
"seq": 5714,
|
||||
"start_s": 6.115,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 6.231,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.191,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 2,
|
||||
"kind": "normal",
|
||||
"seq": 5724,
|
||||
"start_s": 7.766,
|
||||
"nominal_s": 0.22,
|
||||
"hard_limit_s": 0.28,
|
||||
"final": {
|
||||
"time_s": 8.086,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.402,
|
||||
"required_duration_s": 0.154,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 3,
|
||||
"kind": "normal",
|
||||
"seq": 5736,
|
||||
"start_s": 10.164,
|
||||
"nominal_s": 0.34,
|
||||
"hard_limit_s": 0.4,
|
||||
"final": {
|
||||
"time_s": 10.496,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.395,
|
||||
"required_duration_s": 0.238,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "physical_stop"
|
||||
},
|
||||
"explicit_confirmation_s": 10.627,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 10.481,
|
||||
"reason": "recenter",
|
||||
"blockers": "angle"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": {
|
||||
"time_s": 10.627,
|
||||
"hfov_deg": 54.12173440987275
|
||||
}
|
||||
},
|
||||
{
|
||||
"request": 4,
|
||||
"kind": "normal",
|
||||
"seq": 5757,
|
||||
"start_s": 14.109,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 14.182,
|
||||
"status": "discarded",
|
||||
"accounted_duration_s": 0.147,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:cancel_after_put"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 14.055,
|
||||
"reason": "recenter",
|
||||
"blockers": "followup+angle+center_sample"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 5,
|
||||
"kind": "normal",
|
||||
"seq": 5772,
|
||||
"start_s": 16.382,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 16.419,
|
||||
"status": "short",
|
||||
"accounted_duration_s": 0.055,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "physical_stop"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 16.399,
|
||||
"reason": "size_controller",
|
||||
"blockers": "angle"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 6,
|
||||
"kind": "normal",
|
||||
"seq": 5778,
|
||||
"start_s": 17.247,
|
||||
"nominal_s": 0.34,
|
||||
"hard_limit_s": 0.4,
|
||||
"final": {
|
||||
"time_s": 17.445,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.244,
|
||||
"required_duration_s": 0.238,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "physical_stop"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 17.401,
|
||||
"reason": "recenter",
|
||||
"blockers": "angle"
|
||||
},
|
||||
{
|
||||
"time_s": 17.444,
|
||||
"reason": "size_controller",
|
||||
"blockers": "followup+angle+center_history+track_history"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"1424": {
|
||||
"start_utc": "2026-11-13T07:24:57.917+00:00",
|
||||
"status_samples": 259,
|
||||
"first_send_s": 8.054,
|
||||
"first_start_s": 8.118,
|
||||
"first_confirmed_request": 3,
|
||||
"first_optics_s": 17.02,
|
||||
"startup_to_optics_s": 8.902,
|
||||
"first_logged_projection_s": 11.23,
|
||||
"first_request_projection_at_decision": "unknown",
|
||||
"requests": [
|
||||
{
|
||||
"request": 1,
|
||||
"kind": "normal",
|
||||
"seq": 7515,
|
||||
"start_s": 8.118,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 8.245,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.192,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 2,
|
||||
"kind": "normal",
|
||||
"seq": 7536,
|
||||
"start_s": 12.205,
|
||||
"nominal_s": 0.22,
|
||||
"hard_limit_s": 0.28,
|
||||
"final": {
|
||||
"time_s": 12.392,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.248,
|
||||
"required_duration_s": 0.154,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "physical_stop"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 12.379,
|
||||
"reason": "recenter",
|
||||
"blockers": "angle+center_sample"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 3,
|
||||
"kind": "normal",
|
||||
"seq": 7556,
|
||||
"start_s": 16.563,
|
||||
"nominal_s": 0.34,
|
||||
"hard_limit_s": 0.4,
|
||||
"final": {
|
||||
"time_s": 17.018,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.47,
|
||||
"required_duration_s": 0.238,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": 17.02,
|
||||
"decisions": [],
|
||||
"first_status_narrowing": {
|
||||
"time_s": 17.02,
|
||||
"hfov_deg": 54.12173440987275
|
||||
}
|
||||
},
|
||||
{
|
||||
"request": 4,
|
||||
"kind": "normal",
|
||||
"seq": 7572,
|
||||
"start_s": 19.593,
|
||||
"nominal_s": 0.34,
|
||||
"hard_limit_s": 0.4,
|
||||
"final": null,
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [],
|
||||
"first_status_narrowing": {
|
||||
"time_s": 19.901,
|
||||
"hfov_deg": 46.524147844879025
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"1428": {
|
||||
"start_utc": "2026-11-13T07:28:06.389+00:00",
|
||||
"status_samples": 253,
|
||||
"first_send_s": 4.227,
|
||||
"first_start_s": 4.294,
|
||||
"first_confirmed_request": 5,
|
||||
"first_optics_s": 16.985,
|
||||
"startup_to_optics_s": 12.691,
|
||||
"first_logged_projection_s": 13.713,
|
||||
"first_request_projection_at_decision": "unknown",
|
||||
"requests": [
|
||||
{
|
||||
"request": 1,
|
||||
"kind": "normal",
|
||||
"seq": 8125,
|
||||
"start_s": 4.294,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 4.399,
|
||||
"status": "discarded",
|
||||
"accounted_duration_s": 0.172,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:cancel_after_put"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 4.235,
|
||||
"reason": "image_motion",
|
||||
"blockers": "-"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 2,
|
||||
"kind": "probe",
|
||||
"seq": 8137,
|
||||
"start_s": 6.302,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 6.448,
|
||||
"status": "discarded",
|
||||
"accounted_duration_s": 0.208,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 3,
|
||||
"kind": "probe",
|
||||
"seq": 8157,
|
||||
"start_s": 10.195,
|
||||
"nominal_s": 0.1,
|
||||
"hard_limit_s": 0.12,
|
||||
"final": {
|
||||
"time_s": 10.365,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.208,
|
||||
"required_duration_s": 0.07,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 10.261,
|
||||
"reason": "size_controller",
|
||||
"blockers": "angle"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 4,
|
||||
"kind": "normal",
|
||||
"seq": 8178,
|
||||
"start_s": 14.181,
|
||||
"nominal_s": 0.22,
|
||||
"hard_limit_s": 0.28,
|
||||
"final": {
|
||||
"time_s": 14.273,
|
||||
"status": "discarded",
|
||||
"accounted_duration_s": 0.121,
|
||||
"required_duration_s": 0.154,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:cancel_after_put"
|
||||
},
|
||||
"explicit_confirmation_s": null,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 14.158,
|
||||
"reason": "recenter",
|
||||
"blockers": "angle+center_sample"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": null
|
||||
},
|
||||
{
|
||||
"request": 5,
|
||||
"kind": "normal",
|
||||
"seq": 8194,
|
||||
"start_s": 16.639,
|
||||
"nominal_s": 0.22,
|
||||
"hard_limit_s": 0.28,
|
||||
"final": {
|
||||
"time_s": 16.942,
|
||||
"status": "delivered_wait_optics",
|
||||
"accounted_duration_s": 0.314,
|
||||
"required_duration_s": 0.154,
|
||||
"optics_at_finalize": false,
|
||||
"reason": "priority_stop:watchdog"
|
||||
},
|
||||
"explicit_confirmation_s": 16.985,
|
||||
"decisions": [
|
||||
{
|
||||
"time_s": 16.894,
|
||||
"reason": "size_controller",
|
||||
"blockers": "angle"
|
||||
}
|
||||
],
|
||||
"first_status_narrowing": {
|
||||
"time_s": 16.986,
|
||||
"hfov_deg": 54.12173440987275
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,135 @@
|
||||
"""Replay recorded PTZ17 lens transactions and their fresh HFOV samples."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
from dataclasses import asdict, dataclass
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path
|
||||
import re
|
||||
from typing import Any
|
||||
|
||||
|
||||
WINDOW_S = 20.0
|
||||
MIN_HFOV_CHANGE_RATIO = 0.004
|
||||
MAX_STATUS_AGE_S = 0.65
|
||||
MIN_PROJECTION_MARGIN = 0.16
|
||||
EPISODES = ("1412", "1424", "1428")
|
||||
START = re.compile(r"request=(\d+) kind=(\w+) physical start seq=(\d+) pulse=([.\d]+)s hard=([.\d]+)s")
|
||||
RESULT = re.compile(r"request=(\d+) result=(\w+) duration=([.\d]+)s min=([.\d]+)s optics=(True|False) reason=(\S+)")
|
||||
DECISION = re.compile(r"request=(\d+).*?reason=(\S+) blockers=(\S+)")
|
||||
CONFIRMED = re.compile(r"request=(\d+) optics confirmed\b")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class LensSample:
|
||||
time_s: float
|
||||
hfov_deg: float
|
||||
|
||||
|
||||
def first_hfov_change(
|
||||
baseline: LensSample, samples: list[LensSample], *, from_s: float, until_s: float,
|
||||
) -> LensSample | None:
|
||||
"""Return the first fresh HFOV narrowing of at least 0.4 percent."""
|
||||
return next((
|
||||
sample for sample in samples
|
||||
if math.isfinite(sample.time_s) and math.isfinite(sample.hfov_deg)
|
||||
and 0.0 < sample.hfov_deg < 180.0
|
||||
and from_s <= sample.time_s < until_s and sample.time_s > baseline.time_s
|
||||
and (baseline.hfov_deg - sample.hfov_deg) / baseline.hfov_deg >= MIN_HFOV_CHANGE_RATIO
|
||||
), None)
|
||||
|
||||
|
||||
def make_fixture(path: Path) -> dict[str, Any]:
|
||||
report = json.loads(path.read_bytes())
|
||||
assert report["status"] == "checked"
|
||||
detail = report["detail"]
|
||||
assert detail["covers"]
|
||||
rows = detail["rows"]
|
||||
own_status = [value["early_status"] for value in detail["telemetry"].values() if value["early_status"]]
|
||||
assert len(own_status) == 1
|
||||
keys = ("[ZOOM DELIVERY]", "[ZOOM DECISION]")
|
||||
return {
|
||||
"start_utc": report["start"],
|
||||
"initial_send_s": detail["axis_commands"]["first"][0][0],
|
||||
"rows": {key: [row for row in rows.get(key, []) if 0.0 <= row[0] <= WINDOW_S] for key in keys},
|
||||
"status": own_status[0],
|
||||
"first_logged_projection_s": next(
|
||||
(t for t, row in rows.get("[AIM]", []) if 0.0 <= t <= WINDOW_S
|
||||
and float(row.get("approach_margin", -1.0)) >= MIN_PROJECTION_MARGIN), None,
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def replay(episode: dict[str, Any]) -> dict[str, Any]:
|
||||
samples = [LensSample(*row) for row in episode["status"]]
|
||||
assert all(math.isfinite(s.time_s) and 0.0 < s.hfov_deg < 180.0 for s in samples)
|
||||
assert samples and samples == sorted(samples, key=lambda sample: sample.time_s)
|
||||
requests: dict[int, dict[str, Any]] = {}
|
||||
for time_s, line in episode["rows"]["[ZOOM DELIVERY]"]:
|
||||
if match := START.search(line):
|
||||
request_id, kind, seq, pulse, hard = match.groups()
|
||||
assert int(request_id) not in requests
|
||||
requests[int(request_id)] = dict(
|
||||
request=int(request_id), kind=kind, seq=int(seq), start_s=time_s,
|
||||
nominal_s=float(pulse), hard_limit_s=float(hard), final=None,
|
||||
explicit_confirmation_s=None, decisions=[],
|
||||
)
|
||||
elif match := RESULT.search(line):
|
||||
request_id, status, duration, minimum, optics, reason = match.groups()
|
||||
request = requests[int(request_id)]
|
||||
assert request["final"] is None
|
||||
request["final"] = dict(
|
||||
time_s=time_s, status=status, accounted_duration_s=float(duration),
|
||||
required_duration_s=float(minimum), optics_at_finalize=optics == "True", reason=reason,
|
||||
)
|
||||
elif match := CONFIRMED.search(line):
|
||||
requests[int(match[1])]["explicit_confirmation_s"] = time_s
|
||||
for time_s, line in episode["rows"]["[ZOOM DECISION]"]:
|
||||
if (match := DECISION.search(line)) and int(match[1]) in requests:
|
||||
requests[int(match[1])]["decisions"].append(dict(time_s=time_s, reason=match[2], blockers=match[3]))
|
||||
|
||||
ordered = list(requests.values())
|
||||
for index, request in enumerate(ordered):
|
||||
start_s = request["start_s"]
|
||||
assert 0.0 < request["nominal_s"] <= request["hard_limit_s"] <= 0.4
|
||||
until_s = ordered[index + 1]["start_s"] if index + 1 < len(ordered) else math.nextafter(WINDOW_S, math.inf)
|
||||
baseline = next((s for s in reversed(samples) if s.time_s < start_s), None)
|
||||
measured = None
|
||||
if baseline is not None and start_s - baseline.time_s <= MAX_STATUS_AGE_S:
|
||||
measured = first_hfov_change(baseline, samples, from_s=start_s, until_s=until_s)
|
||||
request["first_status_narrowing"] = asdict(measured) if measured is not None else None
|
||||
final = request["final"]
|
||||
if final is not None and final["status"] == "confirmed" and request["explicit_confirmation_s"] is None:
|
||||
request["explicit_confirmation_s"] = final["time_s"]
|
||||
first_confirmed = next((row for row in ordered if row["explicit_confirmation_s"] is not None), None)
|
||||
first_s = ordered[0]["start_s"] if ordered else None
|
||||
confirm_s = first_confirmed["explicit_confirmation_s"] if first_confirmed else None
|
||||
return dict(
|
||||
start_utc=episode["start_utc"], status_samples=len(samples),
|
||||
first_send_s=episode["initial_send_s"], first_start_s=first_s,
|
||||
first_confirmed_request=first_confirmed["request"] if first_confirmed else None,
|
||||
first_optics_s=confirm_s,
|
||||
startup_to_optics_s=round(confirm_s - first_s, 3) if confirm_s is not None else None,
|
||||
first_logged_projection_s=episode["first_logged_projection_s"],
|
||||
first_request_projection_at_decision="unknown",
|
||||
requests=ordered,
|
||||
)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--session", type=Path, help="Build the fixture from the three bounded observer reports")
|
||||
parser.add_argument("--fixture", type=Path, default=Path(__file__).with_name("reference_fixture.json"))
|
||||
parser.add_argument("--output", type=Path, default=Path(__file__).with_name("reference_replay.json"))
|
||||
args = parser.parse_args()
|
||||
if args.session:
|
||||
fixture = {key: make_fixture(args.session / f"ref_{key}.json") for key in EPISODES}
|
||||
args.fixture.write_text(json.dumps(fixture, indent=2) + "\n", encoding="utf-8")
|
||||
fixture = json.loads(args.fixture.read_bytes())
|
||||
result = {key: replay(value) for key, value in fixture.items()}
|
||||
args.output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,782 @@
|
||||
--- 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 (
|
||||
@@ -46,6 +46,7 @@
|
||||
from .tracking_policy import should_allow_offsector_park, should_enforce_track_sector_limits
|
||||
from .bt_tracker import ByteTracker
|
||||
from .visual_tracker import (
|
||||
+ VisualTrackResult,
|
||||
bbox_center_distance_norm,
|
||||
bbox_iou,
|
||||
visual_tracker_manager,
|
||||
@@ -690,6 +691,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 +711,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 +744,221 @@
|
||||
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)
|
||||
+
|
||||
+
|
||||
+_PTZ17_RECOVERY_BOX_LIMIT = 12
|
||||
+_PTZ17_RECOVERY_REASON_LIMIT = 160
|
||||
+_DetectorBox = tuple[list[int], float, int]
|
||||
+
|
||||
+
|
||||
+def _recovery_box_px(box: tuple[int, ...] | list[int] | None) -> list[int] | None:
|
||||
+ """Snapshot xyxy pixels from the top left of the processing image, x right and y down."""
|
||||
+ if box is None or len(box) != 4:
|
||||
+ return None
|
||||
+ try:
|
||||
+ return [int(value) for value in box]
|
||||
+ except (TypeError, ValueError, OverflowError):
|
||||
+ return None
|
||||
+
|
||||
+
|
||||
+def _recovery_detector_box(candidate: _DetectorBox | None) -> dict[str, Any] | None:
|
||||
+ if candidate is None:
|
||||
+ return None
|
||||
+ box, score, class_id = candidate
|
||||
+ confidence = float(score)
|
||||
+ return dict(bbox_px=_recovery_box_px(box), confidence=confidence if math.isfinite(confidence) else None,
|
||||
+ class_id=int(class_id))
|
||||
+
|
||||
+
|
||||
+def _record_ptz17_recovery(
|
||||
+ cam_idx: int, st: dict, observation_utc: float, source_seq: int | None,
|
||||
+ frame_w: int, frame_h: int, visual_result: VisualTrackResult, *,
|
||||
+ input_kind: str, outcome: str, trusted_bbox: tuple[int, ...] | list[int] | None,
|
||||
+ reference_bbox: tuple[int, ...] | list[int] | None,
|
||||
+ validation_targets: list[_DetectorBox], reacquire_targets: list[_DetectorBox],
|
||||
+ raw_box_count: int, expected_track_class: int | None = None, detector_match: _DetectorBox | None = None,
|
||||
+ selected: _DetectorBox | None = None, seeded: VisualTrackResult | None = None,
|
||||
+) -> None:
|
||||
+ """Record already available inputs and the recovery outcome off the control thread."""
|
||||
+ if (cam_idx != _PTZ17_CAM_IDX or st.get("mode") != "TRACK" or not st.get("tracking_active")
|
||||
+ or not getattr(config, "PREDICTIVE_ZOOM_TELEMETRY_DIR", "logs/ptz_zoom")):
|
||||
+ return
|
||||
+ _, generation, started_at, rearm_epoch = visual_control.owner(st)
|
||||
+ if started_at <= 0.0 or not math.isfinite(started_at) or not math.isfinite(observation_utc):
|
||||
+ return
|
||||
+
|
||||
+ def tracker_fields(result: VisualTrackResult) -> dict[str, Any]:
|
||||
+ score = float(result.score)
|
||||
+ return dict(bbox_px=_recovery_box_px(result.bbox), ok=bool(result.ok),
|
||||
+ score=score if math.isfinite(score) else None, class_id=int(result.target_class),
|
||||
+ frame_seq=int(result.source_seq) if result.source_seq is not None else None,
|
||||
+ reason=str(result.reason)[:_PTZ17_RECOVERY_REASON_LIMIT])
|
||||
+
|
||||
+ _episode_telemetry(
|
||||
+ config, cam_idx, (generation, started_at), "recovery_frame", time.time(),
|
||||
+ observation_utc=observation_utc, frame_seq=int(source_seq) if source_seq is not None else None,
|
||||
+ frame_size_px=[frame_w, frame_h], input_kind=input_kind, outcome=outcome,
|
||||
+ expected_track_class=expected_track_class,
|
||||
+ trusted_bbox_px=_recovery_box_px(trusted_bbox), association_reference_bbox_px=_recovery_box_px(reference_bbox),
|
||||
+ ostrack=tracker_fields(visual_result), reinitialized_ostrack=tracker_fields(seeded) if seeded is not None else None,
|
||||
+ yolo_raw_count=raw_box_count,
|
||||
+ yolo_validation_count=len(validation_targets), yolo_reacquire_count=len(reacquire_targets),
|
||||
+ yolo_validation=[_recovery_detector_box(box) for box in validation_targets[:_PTZ17_RECOVERY_BOX_LIMIT]],
|
||||
+ yolo_reacquire=[_recovery_detector_box(box) for box in reacquire_targets[:_PTZ17_RECOVERY_BOX_LIMIT]],
|
||||
+ yolo_match=_recovery_detector_box(detector_match), yolo_selected=_recovery_detector_box(selected),
|
||||
+ reacquire_votes=int(st.get("visual_reacquire_votes", 0) or 0),
|
||||
+ reacquire_vote_frame_seq=int(st.get("visual_reacquire_source_seq", -1)),
|
||||
+ zoom_rearm_epoch=rearm_epoch, zoom_rearm_required=bool(st.get("zoom_rearm_required")),
|
||||
+ zoom_rearm_votes=int(st.get("zoom_rearm_votes", 0) or 0),
|
||||
+ )
|
||||
+
|
||||
+
|
||||
+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 +979,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 +1052,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 +1106,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 +1155,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 +1177,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 +1186,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
|
||||
|
||||
|
||||
@@ -6757,11 +7004,20 @@
|
||||
detector_targets: list[tuple[list[int], float, int]],
|
||||
validation_targets: list[tuple[list[int], float, int]], width: int, height: int,
|
||||
steering_targets: list[tuple[list[float], float, int]] | None = None,
|
||||
+ *, recovery_targets: list[_DetectorBox] | None = None, raw_box_count: int = 0,
|
||||
) -> None:
|
||||
"""Validate the same image without rewinding live control or loss recovery."""
|
||||
result = sample.result
|
||||
bbox = result.bbox
|
||||
if not result.ok or bbox is None:
|
||||
+ if recovery_targets is not None:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, float(sample.captured_at), sample.source_seq, width, height, result,
|
||||
+ input_kind="paired_detector", outcome="paired_tracker_unusable",
|
||||
+ trusted_bbox=st.get("last_bbox"), reference_bbox=bbox,
|
||||
+ validation_targets=validation_targets, reacquire_targets=recovery_targets,
|
||||
+ raw_box_count=raw_box_count,
|
||||
+ )
|
||||
return
|
||||
now = float(sample.captured_at)
|
||||
target_class = int(result.target_class)
|
||||
@@ -6783,6 +7039,14 @@
|
||||
visual_tracker_manager.reset(cam_idx, reason='paired detector identity mismatch')
|
||||
stop_ptz(cam_idx, source='stop', generation=int(st.get('ptz_generation', 0) or 0))
|
||||
alarms.ingest_detection(cam_idx, False)
|
||||
+ if recovery_targets is not None:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, sample.source_seq, width, height, result,
|
||||
+ input_kind="paired_detector", outcome="paired_identity_stop",
|
||||
+ trusted_bbox=st.get("last_bbox"), reference_bbox=bbox,
|
||||
+ validation_targets=candidates, reacquire_targets=recovery_targets,
|
||||
+ raw_box_count=raw_box_count, expected_track_class=target_class,
|
||||
+ )
|
||||
return
|
||||
st['visual_tracker_mismatch_frames'] = 0
|
||||
if matched is not None and now >= float(st.get('visual_tracker_last_detector_at', 0.) or 0.):
|
||||
@@ -6802,6 +7066,14 @@
|
||||
detector_conf=max(alarm_conf, identity_conf),
|
||||
alarm_eligible=alarm_eligible, cam_idx=cam_idx)
|
||||
alarms.ingest_detection(cam_idx, alarm_eligible)
|
||||
+ if recovery_targets is not None:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, sample.source_seq, width, height, result,
|
||||
+ input_kind="paired_detector", outcome="validation_only",
|
||||
+ trusted_bbox=st.get("last_bbox"), reference_bbox=bbox,
|
||||
+ validation_targets=candidates, reacquire_targets=recovery_targets,
|
||||
+ raw_box_count=raw_box_count, expected_track_class=target_class, detector_match=matched,
|
||||
+ )
|
||||
|
||||
|
||||
@visual_control.serialized_control
|
||||
@@ -7259,8 +7531,14 @@
|
||||
)
|
||||
|
||||
if evidence_only:
|
||||
- _consume_paired_detector_evidence(cam_idx, st, visual_sample, detector_targets,
|
||||
- validation_targets, w, h, steering_targets)
|
||||
+ trace_recovery = cam_idx == _PTZ17_CAM_IDX and (
|
||||
+ not visual_sample.result.ok or visual_sample.result.reason == "recovered"
|
||||
+ or st.get("loss_since") is not None or st.get("zoom_rearm_reason") == "geometry_reject"
|
||||
+ )
|
||||
+ _consume_paired_detector_evidence(
|
||||
+ cam_idx, st, visual_sample, detector_targets, validation_targets, w, h, steering_targets,
|
||||
+ recovery_targets=reacquire_targets if trace_recovery else None, raw_box_count=raw_box_count,
|
||||
+ )
|
||||
return
|
||||
|
||||
if bt_active:
|
||||
@@ -7580,6 +7858,7 @@
|
||||
# its own gate, but a bad backend result/config override must still
|
||||
# be unable to move the camera by following a remote cloud edge.
|
||||
previous_control_bbox = st.get("last_bbox")
|
||||
+ recovery_input_kind = "visual_control" if visual_only else "detector_control"
|
||||
gross_visual_jump = False
|
||||
visual_control_jump = 0.0
|
||||
visual_control_limit = float(
|
||||
@@ -7622,6 +7901,9 @@
|
||||
("center jump", "area ratio", "validated area ratio")
|
||||
)
|
||||
)
|
||||
+ geometry_match = validated_geometry_target = None
|
||||
+ seeded_geometry = None
|
||||
+ geometry_outcome = "geometry_no_box"
|
||||
if (gross_visual_jump or geometric_reject) and visual_result.bbox is not None:
|
||||
# A large motion is safe only when the *current* detector agrees
|
||||
# with that new location. A backend result that passed its own
|
||||
@@ -7643,6 +7925,8 @@
|
||||
),
|
||||
allow_target_class_compatibility=True,
|
||||
)
|
||||
+ geometry_match = validated_geometry_target
|
||||
+ geometry_outcome = "geometry_no_match"
|
||||
if (
|
||||
validated_geometry_target is not None
|
||||
and isinstance(previous_control_bbox, (tuple, list))
|
||||
@@ -7673,6 +7957,7 @@
|
||||
)
|
||||
):
|
||||
validated_geometry_target = None
|
||||
+ geometry_outcome = "geometry_trusted_area_rejected"
|
||||
if geometric_reject and validated_geometry_target is not None:
|
||||
validated_geometry_target = _confirm_loss_reacquire_candidate(
|
||||
st,
|
||||
@@ -7682,6 +7967,7 @@
|
||||
h,
|
||||
source_seq=source_seq,
|
||||
)
|
||||
+ geometry_outcome = "geometry_confirmation_pending"
|
||||
if validated_geometry_target is not None:
|
||||
preserved_track_class = (
|
||||
int(visual_result.target_class)
|
||||
@@ -7701,6 +7987,7 @@
|
||||
now=now,
|
||||
source_seq=source_seq,
|
||||
)
|
||||
+ geometry_outcome = "geometry_seed_failed"
|
||||
if seeded_geometry.ok and seeded_geometry.bbox is not None:
|
||||
logger.info(
|
||||
"[OSTRACK/IDENTITY] cam=%s detector validated geometry jump; reinitialized",
|
||||
@@ -7714,6 +8001,16 @@
|
||||
_arm_zoom_revalidation(
|
||||
st, now, "geometry_reinitialized", cam_idx=cam_idx
|
||||
)
|
||||
+ if cam_idx == _PTZ17_CAM_IDX:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, source_seq, w, h, visual_result,
|
||||
+ input_kind=recovery_input_kind, outcome="geometry_reinitialized",
|
||||
+ trusted_bbox=previous_control_bbox, reference_bbox=visual_result.bbox,
|
||||
+ validation_targets=validation_targets, reacquire_targets=reacquire_targets,
|
||||
+ raw_box_count=raw_box_count, detector_match=geometry_match,
|
||||
+ selected=validated_geometry_target, seeded=seeded_geometry,
|
||||
+ expected_track_class=expected_track_class,
|
||||
+ )
|
||||
visual_result = seeded_geometry
|
||||
reference_bbox = seeded_geometry.bbox
|
||||
gross_visual_jump = False
|
||||
@@ -7743,6 +8040,16 @@
|
||||
source="stop",
|
||||
generation=int(st.get("ptz_generation", 0) or 0),
|
||||
)
|
||||
+ if cam_idx == _PTZ17_CAM_IDX:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, source_seq, w, h, visual_result,
|
||||
+ input_kind=recovery_input_kind, outcome=geometry_outcome,
|
||||
+ trusted_bbox=previous_control_bbox, reference_bbox=visual_result.bbox,
|
||||
+ validation_targets=validation_targets, reacquire_targets=reacquire_targets,
|
||||
+ raw_box_count=raw_box_count,
|
||||
+ detector_match=geometry_match, selected=validated_geometry_target,
|
||||
+ seeded=seeded_geometry, expected_track_class=expected_track_class,
|
||||
+ )
|
||||
logger.warning(
|
||||
"[OSTRACK/IDENTITY] cam=%s HOLD rejected geometry reason=%s; awaiting recovery",
|
||||
cam_idx,
|
||||
@@ -7771,6 +8078,16 @@
|
||||
source="stop",
|
||||
generation=int(st.get("ptz_generation", 0) or 0),
|
||||
)
|
||||
+ if cam_idx == _PTZ17_CAM_IDX:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, source_seq, w, h, visual_result,
|
||||
+ input_kind=recovery_input_kind, outcome="control_jump_stop",
|
||||
+ trusted_bbox=previous_control_bbox, reference_bbox=visual_result.bbox,
|
||||
+ validation_targets=validation_targets, reacquire_targets=reacquire_targets,
|
||||
+ raw_box_count=raw_box_count, detector_match=geometry_match,
|
||||
+ selected=validated_geometry_target, seeded=seeded_geometry,
|
||||
+ expected_track_class=expected_track_class,
|
||||
+ )
|
||||
logger.warning(
|
||||
"[OSTRACK/IDENTITY] cam=%s STOP rejected geometry reason=%s",
|
||||
cam_idx,
|
||||
@@ -7782,6 +8099,7 @@
|
||||
|
||||
matched_validation = None
|
||||
matched_reacquire = None
|
||||
+ widened_candidate = None
|
||||
if reference_bbox is not None:
|
||||
matched_validation = _find_visual_validation_target(
|
||||
reference_bbox,
|
||||
@@ -8062,6 +8380,17 @@
|
||||
det_xyxy.append(tuple(visual_result.bbox))
|
||||
visual_track_label_index = len(det_labels)
|
||||
det_labels.append("target track")
|
||||
+ if cam_idx == _PTZ17_CAM_IDX and not geometry_reinitialized and (
|
||||
+ visual_result.reason == "recovered" or st.get("loss_since") is not None
|
||||
+ ):
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, source_seq, w, h, visual_result,
|
||||
+ input_kind=recovery_input_kind, outcome="visual_recovered",
|
||||
+ trusted_bbox=previous_control_bbox, reference_bbox=reference_bbox,
|
||||
+ validation_targets=validation_targets, reacquire_targets=reacquire_targets,
|
||||
+ raw_box_count=raw_box_count, detector_match=matched_validation,
|
||||
+ expected_track_class=expected_track_class,
|
||||
+ )
|
||||
else:
|
||||
ptz17_validation_timeout = bool(
|
||||
visual_only and _ptz17_validation_timeout_steering(
|
||||
@@ -8105,6 +8434,7 @@
|
||||
_arm_zoom_revalidation(
|
||||
st, now, "visual_reacquire", cam_idx=cam_idx
|
||||
)
|
||||
+ seeded = None
|
||||
if matched_reacquire is not None:
|
||||
preserved_track_class = (
|
||||
int(visual_result.target_class)
|
||||
@@ -8148,6 +8478,19 @@
|
||||
target_source = "none"
|
||||
st["visual_tracker_score"] = float(visual_result.score)
|
||||
st["visual_tracker_last_reason"] = visual_result.reason
|
||||
+ if cam_idx == _PTZ17_CAM_IDX:
|
||||
+ _record_ptz17_recovery(
|
||||
+ cam_idx, st, now, source_seq, w, h, visual_result,
|
||||
+ input_kind=recovery_input_kind,
|
||||
+ outcome=target_source if matched_reacquire is not None else
|
||||
+ "loss_confirmation_pending" if widened_candidate is not None else "loss_no_match",
|
||||
+ trusted_bbox=previous_control_bbox, reference_bbox=reference_bbox,
|
||||
+ validation_targets=validation_targets, reacquire_targets=reacquire_targets,
|
||||
+ raw_box_count=raw_box_count,
|
||||
+ detector_match=widened_candidate if widened_candidate is not None else matched_reacquire,
|
||||
+ selected=matched_reacquire, seeded=seeded,
|
||||
+ expected_track_class=expected_track_class,
|
||||
+ )
|
||||
elif best_target is not None:
|
||||
# ACQUIRE has already approved this target. Seed the appearance
|
||||
# tracker on the same frame before entering full TRACK.
|
||||
@@ -9537,6 +9880,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 +10032,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 +10076,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 +10108,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 +10607,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 +10626,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 +10667,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:
|
||||
@ -0,0 +1,231 @@
|
||||
"""Offline comparison of TRACK recovery with and without PTZ17 telemetry."""
|
||||
from contextlib import ExitStack
|
||||
import importlib.util
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
from pathlib import Path
|
||||
import sys
|
||||
from types import SimpleNamespace
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
import torch
|
||||
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
TRUSTED = (620, 350, 640, 364)
|
||||
REJECTED = (570, 325, 680, 382)
|
||||
GOOD = [622, 351, 643, 365]
|
||||
WRONG = [590, 335, 670, 372]
|
||||
MOVED = [760, 350, 780, 364]
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def versions():
|
||||
runtime = Path(os.environ["PTZ17_TEST_RUNTIME"])
|
||||
package = "_ptz17_recovery_runtime"
|
||||
paths = [runtime / "__init__.py", Path(os.environ["PTZ17_TEST_BASELINE"]),
|
||||
Path(os.environ["PTZ17_TEST_CANDIDATE"])]
|
||||
modules = []
|
||||
for name, path in zip((package, package + ".baseline", package + ".candidate"), paths, strict=True):
|
||||
spec = importlib.util.spec_from_file_location(
|
||||
name, path, submodule_search_locations=[str(runtime)] if name == package else None,
|
||||
)
|
||||
assert spec and spec.loader
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
sys.modules[name] = module
|
||||
spec.loader.exec_module(module)
|
||||
modules.append(module)
|
||||
return modules[1:]
|
||||
|
||||
|
||||
class Boxes:
|
||||
def __init__(self, observations):
|
||||
self.xyxy = torch.tensor([box for box, _, _ in observations], dtype=torch.float32)
|
||||
self.conf = torch.tensor([confidence for _, confidence, _ in observations])
|
||||
self.cls = torch.tensor([class_id for _, _, class_id in observations])
|
||||
|
||||
def __len__(self):
|
||||
return len(self.conf)
|
||||
|
||||
|
||||
def exercise(module, scenario, *, cam=6, enabled=True):
|
||||
st = module.state._default_ptz_state(cam)
|
||||
st.update(tracking_active=True, mode="TRACK", ptz_generation=31, track_started_at=90.0,
|
||||
last_seen=99.8, last_zoom_seen=99.8, last_bbox=TRUSTED, track_source="visual",
|
||||
hfov_deg=59.0, zoom_status_at=99.95, abs_zoom=1.0, identity_class=0,
|
||||
visual_tracker_last_detector_at=99.9, visual_tracker_last_zoom_detector_at=99.9,
|
||||
visual_tracker_last_detector_conf=0.80)
|
||||
result_type = module.visual_tracker_manager.update.__globals__["VisualTrackResult"]
|
||||
frame = np.zeros((720, 1280, 3), dtype=np.uint8)
|
||||
operations, telemetry = [], []
|
||||
|
||||
def emit(_config, _cam, owner, name, at, **fields):
|
||||
json.dumps(fields, allow_nan=False)
|
||||
if name == "recovery_frame":
|
||||
telemetry.append((owner, at, fields))
|
||||
|
||||
with ExitStack() as stack:
|
||||
stack.enter_context(patch.dict(module.state.ptz_states, {cam: st}))
|
||||
for key, value in {
|
||||
"PTZ_VISUAL_CONTROL_ENABLE": True, "PREDICTIVE_ZOOM_TELEMETRY_DIR": "offline" if enabled else "",
|
||||
"DETECT_CONF_BY_CLASS": {0: .65, 1: .65}, "DETECT_CONF": .65,
|
||||
"DRONE_ONLY": False, "MOTION_DETECT_ENABLE": False, "BT_ENABLE": True,
|
||||
"VISUAL_TRACKER_MATCH_CENTER_NORM": .10, "VISUAL_TRACKER_LOSS_REACQUIRE_CENTER_BASE": .15,
|
||||
"VISUAL_TRACKER_LOSS_REACQUIRE_CONFIRM_MAX_GAP_SEC": .65,
|
||||
}.items():
|
||||
stack.enter_context(patch.object(module.config, key, value, create=True))
|
||||
clock = stack.enter_context(patch.object(module.time, "time"))
|
||||
update = stack.enter_context(patch.object(module.visual_tracker_manager, "update"))
|
||||
for name in ("_publish_with_boxes", "notify_detected", "call_autofocus", "return_to_preset"):
|
||||
stack.enter_context(patch.object(module, name))
|
||||
for name in ("stop_ptz", "move_ptz_bounded"):
|
||||
stack.enter_context(patch.object(module, name, side_effect=lambda *a, key=name, **kw:
|
||||
operations.append((key, a, kw))))
|
||||
stack.enter_context(patch.object(module.alarms, "is_armed", return_value=False))
|
||||
stack.enter_context(patch.object(module.alarms, "ingest_detection", side_effect=lambda *a:
|
||||
operations.append(("alarm", a, {}))))
|
||||
stack.enter_context(patch.object(module.visual_tracker_manager, "record_detector_validation"))
|
||||
stack.enter_context(patch.object(module.visual_tracker_manager, "reset"))
|
||||
stack.enter_context(patch.object(module.visual_tracker_manager, "should_refresh", return_value=False))
|
||||
stack.enter_context(patch.object(module, "_episode_telemetry", side_effect=emit))
|
||||
zoom_module = sys.modules[module.record_zoom_blocks.__module__]
|
||||
stack.enter_context(patch.object(zoom_module, "_episode_telemetry", side_effect=emit))
|
||||
|
||||
def start(cam_idx, _image, box, *, target_class, detector_conf, now, source_seq):
|
||||
operations.append(("seed", (cam_idx, tuple(box), target_class, detector_conf, now, source_seq), {}))
|
||||
ok = scenario != "seed_failed"
|
||||
return result_type(ok, tuple(box) if ok else None, .8, target_class, detector_conf,
|
||||
0, "initialized" if ok else "no template", source_seq)
|
||||
|
||||
stack.enter_context(patch.object(module.visual_tracker_manager, "start", side_effect=start))
|
||||
|
||||
def frame_step(seq, at, tracker_box, reason, observations=(), *, paired=False, visual_only=False):
|
||||
ok = reason in ("tracked", "recovered")
|
||||
result = result_type(ok, tracker_box, .80 if ok else .29, 0, .80, 40, reason, seq)
|
||||
update.return_value = result
|
||||
clock.return_value = at
|
||||
sample = module.visual_control.VisualSample(module.visual_control.owner(st), seq, at - .010, result)
|
||||
module.postprocess_control(cam, frame, SimpleNamespace(boxes=Boxes(observations)), True, seq,
|
||||
visual_sample=sample if paired or visual_only else None,
|
||||
visual_only=visual_only)
|
||||
|
||||
if scenario == "hold_then_strict":
|
||||
frame_step(41, 100.0, REJECTED, "validated area ratio 11.34",
|
||||
[(GOOD, .50, 0), (WRONG, .95, 0)])
|
||||
frame_step(42, 100.2, REJECTED, "low score", [(GOOD, .51, 0)])
|
||||
elif scenario == "wide_two_frames":
|
||||
frame_step(41, 100.0, None, "low score", [(MOVED, .70, 0)])
|
||||
frame_step(42, 100.3, None, "low score", [(MOVED, .71, 0)])
|
||||
elif scenario == "seed_failed":
|
||||
frame_step(41, 100.0, None, "low score", [(GOOD, .81, 0)])
|
||||
elif scenario == "visual_recovers":
|
||||
frame_step(41, 100.0, REJECTED, "validated area ratio 11.34", visual_only=True)
|
||||
frame_step(42, 100.1, TRUSTED, "recovered", visual_only=True)
|
||||
elif scenario == "paired_hold":
|
||||
frame_step(41, 100.0, REJECTED, "validated area ratio 11.34", visual_only=True)
|
||||
frame_step(42, 100.1, TRUSTED, "tracked", [(GOOD, .81, 0)], paired=True)
|
||||
elif scenario == "geometry_two_frames":
|
||||
frame_step(41, 100.0, TRUSTED, "center jump", [(GOOD, .81, 0)])
|
||||
frame_step(42, 100.2, TRUSTED, "center jump", [(GOOD, .82, 0)])
|
||||
elif scenario == "ordinary_track":
|
||||
frame_step(41, 100.0, TRUSTED, "tracked", [(GOOD, .81, 0)])
|
||||
else:
|
||||
raise ValueError(scenario)
|
||||
state_evidence = {key: st.get(key) for key in (
|
||||
"track_source", "zoom_state", "zoom_rearm_epoch", "zoom_rearm_votes", "zoom_prev_cmd",
|
||||
"visual_reacquire_votes", "identity_state", "alarm_gate_eligible", "last_bbox",
|
||||
)}
|
||||
return operations, state_evidence, [fields for _, _, fields in telemetry]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("scenario,outcomes", [
|
||||
("hold_then_strict", ["geometry_trusted_area_rejected", "detector_reacquire"]),
|
||||
("wide_two_frames", ["loss_confirmation_pending", "detector_reacquire"]),
|
||||
("seed_failed", ["detector_fallback"]),
|
||||
("visual_recovers", ["geometry_no_match", "visual_recovered"]),
|
||||
("paired_hold", ["geometry_no_match", "validation_only"]),
|
||||
("geometry_two_frames", ["geometry_confirmation_pending", "geometry_reinitialized"]),
|
||||
("ordinary_track", []),
|
||||
])
|
||||
def test_command_and_alarm_parity(versions, scenario, outcomes):
|
||||
base, candidate = versions
|
||||
previous, previous_state, _ = exercise(base, scenario)
|
||||
actual, actual_state, rows = exercise(candidate, scenario)
|
||||
assert (actual, actual_state) == (previous, previous_state)
|
||||
assert [row["outcome"] for row in rows] == outcomes
|
||||
if scenario == "hold_then_strict":
|
||||
reject, recover = rows
|
||||
assert reject["trusted_bbox_px"] == list(TRUSTED)
|
||||
assert reject["association_reference_bbox_px"] == list(REJECTED)
|
||||
assert reject["ostrack"]["bbox_px"] == list(REJECTED)
|
||||
assert reject["yolo_match"]["bbox_px"] == WRONG and reject["yolo_selected"] is None
|
||||
assert {tuple(box["bbox_px"]) for box in reject["yolo_reacquire"]} == {tuple(WRONG), tuple(GOOD)}
|
||||
assert recover["yolo_selected"]["bbox_px"] == GOOD
|
||||
assert recover["reinitialized_ostrack"]["bbox_px"] == GOOD
|
||||
if scenario == "wide_two_frames":
|
||||
assert [row["reacquire_votes"] for row in rows] == [1, 2]
|
||||
assert rows[0]["yolo_selected"] is None
|
||||
assert rows[1]["yolo_selected"]["bbox_px"] == MOVED
|
||||
if scenario == "paired_hold":
|
||||
paired = rows[-1]
|
||||
assert paired["frame_seq"] == paired["ostrack"]["frame_seq"] == 42
|
||||
assert paired["observation_utc"] == pytest.approx(100.09)
|
||||
assert paired["input_kind"] == "paired_detector"
|
||||
assert paired["yolo_match"]["bbox_px"] == GOOD
|
||||
if scenario == "geometry_two_frames":
|
||||
assert [row["reacquire_votes"] for row in rows] == [1, 2]
|
||||
assert rows[-1]["ostrack"]["ok"] is False
|
||||
assert rows[-1]["reinitialized_ostrack"]["ok"] is True
|
||||
assert rows[-1]["reinitialized_ostrack"]["bbox_px"] == GOOD
|
||||
|
||||
|
||||
@pytest.mark.parametrize("cam,enabled", [(8, True), (6, False)])
|
||||
def test_scope_and_disable(versions, cam, enabled):
|
||||
assert exercise(versions[1], "hold_then_strict", cam=cam, enabled=enabled)[2] == []
|
||||
|
||||
|
||||
def test_bounds_and_finite_json(versions):
|
||||
module = versions[1]
|
||||
valid = module.visual_tracker_manager.update.__globals__["VisualTrackResult"]
|
||||
result = valid(False, (620, 350, 640, 364), math.nan, 0, .8, 40, "x" * 900, 17)
|
||||
candidates = [([k, 4, k + 20, 17], math.inf if k == 0 else .8, 0) for k in range(33)]
|
||||
selected = candidates[-1]
|
||||
state = dict(mode="TRACK", tracking_active=True, track_started_at=90.0, ptz_generation=7)
|
||||
sink = Mock()
|
||||
with patch.object(module, "_episode_telemetry", sink):
|
||||
module._record_ptz17_recovery(
|
||||
6, state, 100.0, 17, 1280, 720, result, input_kind="detector_control",
|
||||
outcome="geometry_hold", trusted_bbox=TRUSTED, reference_bbox=result.bbox,
|
||||
validation_targets=candidates, reacquire_targets=candidates, raw_box_count=33, selected=selected,
|
||||
)
|
||||
assert sink.call_args.args[1:4] == (6, (7, 90.0), "recovery_frame")
|
||||
row = sink.call_args.kwargs
|
||||
assert len(row["yolo_validation"]) == len(row["yolo_reacquire"]) == 12
|
||||
assert row["yolo_validation_count"] == row["yolo_reacquire_count"] == 33
|
||||
assert row["yolo_selected"]["bbox_px"] == selected[0]
|
||||
assert row["ostrack"]["score"] is None and row["yolo_validation"][0]["confidence"] is None
|
||||
assert len(row["ostrack"]["reason"]) == 160
|
||||
json.dumps(row, allow_nan=False)
|
||||
|
||||
|
||||
def test_full_queue_drops_telemetry_without_waiting(versions, tmp_path):
|
||||
module = versions[1]
|
||||
log_module = sys.modules[module.record_zoom_blocks.__module__]
|
||||
with patch.object(log_module, "Thread"):
|
||||
writer = log_module.EpisodeTelemetryLogger(tmp_path, capacity=1)
|
||||
result_type = module.visual_tracker_manager.update.__globals__["VisualTrackResult"]
|
||||
result = result_type(False, REJECTED, .29, 0, .8, 40, "area ratio 11.34", 17)
|
||||
state = dict(mode="TRACK", tracking_active=True, track_started_at=90.0, ptz_generation=7)
|
||||
with patch.object(module.config, "PREDICTIVE_ZOOM_TELEMETRY_DIR", str(tmp_path), create=True):
|
||||
with patch.dict(log_module._telemetry_loggers, {str(tmp_path): writer}):
|
||||
for _ in range(2):
|
||||
module._record_ptz17_recovery(
|
||||
6, state, 100.0, 17, 1280, 720, result, input_kind="visual_control",
|
||||
outcome="geometry_no_match", trusted_bbox=TRUSTED, reference_bbox=REJECTED,
|
||||
validation_targets=[], reacquire_targets=[], raw_box_count=0,
|
||||
)
|
||||
assert writer.queue.qsize() == 1
|
||||
assert writer.dropped == 1
|
||||
@ -0,0 +1,30 @@
|
||||
from pathlib import Path
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from replay_ptz17_reference import LensSample, first_hfov_change, replay
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key,start,request_id,confirmation,delay", [
|
||||
("1412", 6.115, 3, 10.627, 4.512),
|
||||
("1424", 8.118, 3, 17.020, 8.902),
|
||||
("1428", 4.294, 5, 16.985, 12.691),
|
||||
])
|
||||
def test_replays_observed_first_optics(
|
||||
key: str, start: float, request_id: int, confirmation: float, delay: float,
|
||||
) -> None:
|
||||
fixture = json.loads(Path(__file__).with_name("reference_fixture.json").read_bytes())
|
||||
result = replay(fixture[key])
|
||||
assert result["first_start_s"] == start
|
||||
assert result["first_confirmed_request"] == request_id
|
||||
assert result["first_optics_s"] == confirmation and result["startup_to_optics_s"] == delay
|
||||
assert all(row["first_status_narrowing"] is None for row in result["requests"][:request_id - 1])
|
||||
assert result["requests"][request_id - 1]["first_status_narrowing"]["hfov_deg"] == pytest.approx(54.122, abs=.001)
|
||||
|
||||
|
||||
def test_measurement_does_not_cross_request_boundary() -> None:
|
||||
assert first_hfov_change(
|
||||
LensSample(1., 59.), [LensSample(1.1, float("nan")), LensSample(1.2, 58.9), LensSample(1.3, 54.)],
|
||||
from_s=1.1, until_s=1.3,
|
||||
) is None
|
||||
Loading…
Reference in New Issue