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,52 @@
# PTZ17 · зум и контроль резкости
## Диагностика HOLD и повторного захвата
Событие `recovery_frame` в очереди JSONL PTZ17 связывает причину отказа или восстановления с поколением трека, номером кадра, временем наблюдения и размером изображения обработки. Координаты `xyxy` отсчитываются от левого верхнего угла. Для промежуточного OSTrack и привязанного к нему YOLO время наблюдения соответствует получению декодированного кадра. Для отдельного детекторного прохода оно соответствует входу в обработчик. Поле `input_kind` различает эти источники. Номера кадров OSTrack и управляющего прохода записываются отдельно.
Телеметрия содержит последнюю принятую рамку, опору сопоставления, рамку и оценку OSTrack, кандидатов YOLO с оценками и классами, результат сопоставления, выбранную рамку и результат переинициализации. Записываются счётчики голосов повторного захвата и разрешения зума. При геометрическом HOLD журнал различает отсутствие сопоставления, отбрасывание по площади относительно принятой рамки, ожидание подтверждения и отказ переинициализации. При позднем YOLO событие отмечает, что кадр использован для верификации или привёл к штатному STOP из-за конфликта.
Списки содержат до 12 рамок, которые дошли до соответствующих проверок контроллера. Общие количества и выбранная рамка записываются отдельно. Сырые результаты YOLO до фильтрации представлены счётчиком. Для событий, ожидающих подтверждения, `yolo_match` показывает возможное совпадение, а `yolo_selected` остаётся пустым. Писатель использует существующую ограниченную очередь. Переполнение увеличивает `dropped_before` у следующих событий.
Для офлайн-проверки `test_recovery_telemetry.py` укажите пути `PTZ17_TEST_RUNTIME`, `PTZ17_TEST_BASELINE` и `PTZ17_TEST_CANDIDATE`. Базовая версия для этих тестов — предыдущий коммит PR №14. Тесты сравнивают команды Pan/Tilt/Zoom, защитные STOP, вызовы тревог и состояние контроллера на одинаковых входах со смоделированными детекциями. Полевое время от HOLD до повторного разрешения зума остаётся измерить после сбора новых событий.
Локальный кандидат поверх установленного PR №13. Прямое и обратное применение патча проверены побайтно. SHA-256 базовой и кандидатной версий в `pins.json`.
На широком угле кандидат проверяет, может ли уже разрешённый первый обычный импульс native 10 начаться с длительностью до 340 мс и жёстким пределом 400 мс. Для этого нужны текущий кадр OSTrack, свежее подтверждение YOLO, свежая оптика, допустимая скорость в кадре и полная штатная проекция рамки. Повторное разрешение допускает только исходный запрос того же владельца. При запрете базового контроллера запрос остаётся нулевым. Функции модели, тревог и транспорт STOP сохранены.
При HFOV до 18° на PTZ17 оценка резкости проверяет область самой цели. Для решения о паузе подходят рамки с короткой стороной от 20 px. Штатный порог размера для автофокуса остаётся 24 px. Низкая резкость или неоцениваемый кадр удерживают текущее увеличение. Для выхода нужны два свежих резких кадра того же владельца с интервалом не более 250 мс. Один резкий отсчёт, дубликат и большой разрыв паузу не снимают. Пауза относится к новым положительным импульсам, поэтому Pan/Tilt и защитное расширение FOV сохраняют штатные пути.
При непрерывных 600 мс неоцениваемой резкости после остановки линзы, свежем подтверждении цели и устойчивом положении рамки кандидат может поставить один восстановительный запрос в штатную очередь автофокуса на владельца трека. Повторный запрос требует смены владельца и соблюдения штатного cooldown. ACK фокуса сам по себе зум не возобновляет.
Повторная проверка на пролёте 14:28 показала, что расширенная область низкоконтрастна и для размытого, и для различимого самолёта. Теперь при непригодной расширенной области проверяется ядро рамки с более строгим порогом. Для этого кандидата задан восьмикратный множитель относительно исходного порога дисперсии лапласиана. Множитель проверен на этой ограниченной выборке и остаётся параметром калибровки.
На записи пролёта 14:12:02 измерение рамки на PTS 95 возвращает `unassessable` и устанавливает паузу. На PTS 116 свежая резкая рамка снимает её. У трёх сохранённых кадров нет покадровой привязки к UTC. Замеры AIM разрежены. Первый записанный полный безопасный запас от края появился на +9,869 с, после первой полевой команды на +6,041 с. Ускорение первого оптического приближения на данном пролёте по доступным данным не подтверждено.
Проверки охватывают свежесть, владельца импульса, отказ при малом запасе от края, превышении угловой зоны и скорости, сохранение нулевого запроса, паузу по размытому кадру и снятие паузы по свежему резкому кадру. Реакция привода и время до распознаваемого кадра требуют дополнительных данных. Кандидат не установлен.
## Два дополнительных пролёта на PR №13
Время местное, UTC+7. Тайминги отсчитаны от входа в TRACK. Проекция берётся из разреженных строк AIM, поэтому её первое появление даёт только верхнюю границу времени появления в журнале.
| Начало TRACK | Первый физический старт | Первое подтверждение оптики | Первая записанная безопасная проекция | До 2× / 4× / 8× |
| --- | ---: | ---: | ---: | --- |
| 14:24:57,917 | +8,118 с | +17,020 с | +11,230 с | 28,163 / 47,218 / 76,182 с |
| 14:28:06,389 | +4,294 с | +16,985 с | +13,713 с | 45,665 / 70,481 / 97,097 с |
В первом пролёте два коротких импульса 100 и 220 мс не получили отдельного подтверждения оптики. Во втором исходный обычный импульс снят после PUT на фоне `image_motion`, два пробных импульса по 100 мс также остались без оптического подтверждения. Первое подтверждение получено на обычных запросах №3 и №5 соответственно. Первые записанные безопасные проекции в обоих случаях позже первого движения, поэтому изменение длительности из PR №14 ещё не подтверждает выигрыш на этих пролётах. Защитные остановки сохраняются.
На кадрах второго пролёта PTS 94 и 114 расширенная область вернула `None`. Энергия в ядре рамки составила 142 и 8994 соответственно. При пороге 280 первый кадр удерживает паузу, второй её снимает. Два различимых кадра из пролёта 14:24 проходят проверку. Сопоставление PTS с UTC на уровне отдельных кадров не выполнено. В окнах обоих пролётов журнал не показывает отправку тревоги по WebSocket.
## Воспроизводимый эталон первых 20 секунд
Для полевого сравнения PR №14 пишет `decision_frame` только для PTZ17 через существующую ограниченную асинхронную очередь. Событие связывает номер и время кадра с состоянием проверки, полем зрения, оценкой резкости, запросом зума, длительностью и итоговой командой. Ненулевые команды и идентификаторы проверяются по журналу доставки и замерам оптики. Для первого резкого кадра учитывается только измерение с текущего кадра и размер рамки от 20 px. Эталон предыдущей версии располагает лишь редкими строками оценки резкости и выборочными JPEG.
`replay_ptz17_reference.py` читает зафиксированные команды, завершения запросов и выборки свежего HFOV из `reference_fixture.json`. Запуск `python replay_ptz17_reference.py` восстанавливает `reference_replay.json`. В журнале время подтверждения и первое наблюдаемое изменение HFOV могут отличаться из-за округления меток и порядка записи. Время измеримого сужения определяется отдельно от подтверждения конкретного запроса.
| TRACK, UTC+7 | Первый старт → первое подтверждение | Первый подтверждённый запрос | Свежие замеры HFOV за 20 с |
| --- | ---: | --- | ---: |
| 14:12:02 | 4,512 с | №3, 340 мс | 257 |
| 14:24:57 | 8,902 с | №3, 340 мс | 259 |
| 14:28:06 | 12,691 с | №5, 220 мс | 253 |
Во всех трёх эпизодах поле зрения оставалось 59° до первого успешного запроса и затем сузилось до 54,12°. Это указывает на отсутствие измеримого сужения на ранних попытках. Из разреженных AIM нельзя восстановить разрешение более длинного первого импульса в момент решения или пересчитать физический контрфактический результат. Данные пригодны для сравнения по номеру запроса, времени первого оптического подтверждения и дальнейшим отметкам 2×/4×/8×. Для сравнения по времени до первого различимого резкого кадра нужна привязка PTS к UTC и покадровая проверка.

@ -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…
Cancel
Save