Add offline PTZ calibration and latency stress checks

feature/ptz-offline-field-calibration
Ярослав Карташов 2 weeks ago
parent 5cc610a92a
commit eb19534b1b

@ -0,0 +1,28 @@
# Офлайн-калибровка native10 по JSONL PR №10
Передайте файлы JSONL или каталоги с выгрузкой эпизодов из `logs/ptz_zoom`. Утилита работает на Python 3.10+ со стандартной библиотекой. В команде укажите пути к данным и отдельному каталогу для отчёта.
```powershell
python integration/ptz_field_calibration/calibrate_tele_profile.py D:/telemetry/ptz_zoom --output-dir D:/telemetry/field_report
```
- `field_report.md` показывает сводку по эпизодам, первые подтверждённые PUT, минимальный фактический HFOV, блокировки и таблицу отклика.
- `field_report.json` содержит оценки по отдельным импульсам, причины исключения, распределения RTT и сводки по камере, native и исходному диапазону HFOV.
- `native10_calibrated.json` содержит коэффициенты с покрытием измерений. Следующий тестовый предел HFOV появляется при достаточном покрытии у текущего порога, с учётом худшей наблюдаемой скобки STOP и прогнозируемого запаса до края. Максимальный шаг за один анализ составляет 0,5°. Значение `production_enable` равно `false`.
Без `--profile` сравнение использует коэффициенты стенда PR №10 для PTZ19 и PTZ21. Чтобы сравнить с другим профилем, передайте JSON с объектом `cameras`, где ключи — внешние номера камер, а значения — параметры профиля напрямую или внутри `predictive_zoom` либо `replay_settings`. Окна свежести статуса доступны в `--help`.
Оценка скорости оптики использует разницу замеров ISAPI. Изменение от первого статуса после STOP до стабилизации показывает наблюдаемый минимум выбега. Изменение от последнего свежего статуса до STOP до стабилизации даёт верхнюю наблюдаемую оценку при монотонном движении. Интервалы между статусами ограничивают точность обеих оценок.
Для доли времени у центра и доставленных защитных расширений передайте `--observations` с отдельным JSONL независимых наблюдений. `cam`, `generation`, `track_start_utc` берутся из эпизода PR №10. Время — Unix UTC в секундах. Смещения центра нормированы по полной ширине и высоте кадра. Оценка доли использует сопоставленные кадры с отклонением не более 0,10 по каждой оси и свежим HFOV ниже 18°. Поле `measured_edge_margin` необязательно.
```jsonl
{"cam":8,"generation":3,"track_start_utc":1000.0,"event":"frame_observation","seq":76,"frame_utc":1004.0,"dx_norm":0.04,"dy_norm":-0.03,"measured_edge_margin":0.36,"source":"aligned_frame_annotation"}
{"cam":8,"generation":3,"track_start_utc":1000.0,"event":"safety_step_back_ack","command_seq":12,"utc":1004.1,"native":-5,"reason":"tele_step_back","source":"transport_ack"}
```
В исходном JSONL PR №10 есть прогноз запаса и выборочные измерения у блокировок. Доля времени у центра и число подтверждённых расширений остаются неизвестными при отсутствии соответствующих независимых наблюдений. Количество подтверждений из дополнительного файла относится к покрытым им событиям.
```powershell
python -m unittest discover -s integration/ptz_field_calibration -v
```

@ -0,0 +1,676 @@
"""Analyze Chameleon-C PR #10 episode JSONL offline (standard library only)."""
from __future__ import annotations
import argparse
from bisect import bisect_right
from collections import Counter, defaultdict
from dataclasses import dataclass
import json
import math
from pathlib import Path
from statistics import median
EVENTS = {"tick", "first_zoom", "stop", "native10_pulse_calibration", "zoom_block_summary"}
PULSE = "native10_pulse_calibration"
FULL_SWEEP_LOG_RATE = math.log(252 / 6) / 5.5
# Published PR8 replay coefficients carried by PR10. Keys are internal camera IDs.
BASELINE = {8: (0.44648, 0.95109), 10: (0.73468, 1.09732)}
BINS = ("gt_35", "18_to_35", "12_to_lt_18", "10_to_lt_12", "lt_10")
@dataclass(frozen=True)
class Limits:
max_before_age_s: float = .65
max_pre_stop_age_s: float = .18
max_first_post_stop_age_s: float = .25
max_status_gap_s: float = .35
max_tick_gap_s: float = .20
max_settle_s: float = 1.2
minimum_pulses: int = 3
minimum_tracks: int = 2
edge_buffer: float = .32
floor_step_deg: float = .5
field_floor_deg: float = 10.
def number(value):
if isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value):
return float(value)
return None
def val(row, key):
return number(row.get(key))
def fov(row, key):
value = val(row, key)
return value if value is not None and 0 < value < 180 else None
def focal(angle):
return -math.log(math.tan(math.radians(angle / 2)))
def angle(log_focal):
return math.degrees(2 * math.atan(math.exp(-log_focal)))
def band(hfov):
return next((label for lower, label in zip((35, 18, 12, 10), BINS)
if hfov >= lower and (lower != 35 or hfov > 35)), BINS[-1])
def percentile(values, q):
i = (len(values) - 1) * q
lo, hi = math.floor(i), math.ceil(i)
return values[lo] + (i - lo) * (values[hi] - values[lo])
def stats(values):
values = sorted(v for v in values if v is not None)
if not values:
return {"n": 0, "min": None, "p50": None, "p90": None, "p95": None, "max": None}
return {"n": len(values), "min": values[0], "p50": median(values),
"p90": percentile(values, .90), "p95": percentile(values, .95), "max": values[-1]}
def input_files(paths):
files = set()
for path in paths:
if path.is_dir():
files.update(p.resolve() for p in path.rglob("*.jsonl") if p.is_file())
elif path.is_file():
files.add(path.resolve())
else:
raise ValueError(f"Input does not exist: {path}")
if not files:
raise ValueError("No JSONL files found")
return sorted(files)
def load_episodes(files):
episodes = defaultdict(list)
ignored = duplicates = 0
seen = set()
for path in files:
with path.open(encoding="utf-8-sig") as stream:
for lineno, line in enumerate(stream, 1):
if not line.strip():
continue
try:
row = json.loads(line)
if not isinstance(row, dict):
raise ValueError("expected a JSON object")
if not isinstance(row.get("event"), str) or row["event"] not in EVENTS:
ignored += 1
continue
cam, gen, start, utc = (val(row, k) for k in
("cam", "generation", "track_start_utc", "utc"))
if (cam is None or gen is None or start is None or utc is None
or not cam.is_integer() or cam < 0 or not gen.is_integer()
or start <= 0 or utc < start):
raise ValueError("invalid PR10 event envelope")
if row["event"] in (PULSE, "stop") and type(row.get("request")) is not int:
raise ValueError("request must be an integer for pulse and stop rows")
if row["event"] == PULSE and type(row.get("native")) is not int:
raise ValueError("native must be an integer for pulse rows")
identity = json.dumps(row, sort_keys=True, allow_nan=False)
if identity in seen:
duplicates += 1
continue
seen.add(identity)
episodes[(int(cam), int(gen), start)].append(row)
except (TypeError, ValueError) as exc:
raise ValueError(f"{path}:{lineno}: {exc}") from exc
return episodes, {"files": [str(p) for p in files], "duplicate_rows": duplicates, "ignored_rows": ignored}
def status_samples(ticks):
samples = {}
for tick in ticks:
at, hfov = val(tick, "FOV_status_utc"), fov(tick, "FOV_actual")
if at is not None and hfov is not None and 0 < at <= tick["utc"]:
samples.setdefault(at, set()).add(hfov)
return samples
def analyze_pulse(row, stops, samples, limits):
before, at_stop, first, after = (fov(row, k) for k in
("HFOV_before", "HFOV_stop_sample", "HFOV_first_post_stop", "HFOV_after"))
start_status, put, ack, stop_sample, stop, stop_ack, first_post, after_at = (val(row, k) for k in
("before_at", "put_at", "ack_at", "stop_status_at", "stop_issued_at", "stop_ack_at",
"first_post_stop_at", "after_at"))
duration = val(row, "duration_s")
put_rtt, stop_rtt = val(row, "put_rtt_ms"), val(row, "stop_rtt_ms")
stop_reason = str(row.get("stop_reason") or "").lower()
finished = all(v is not None for v in (put, ack, stop, stop_ack, duration))
finished = bool(finished and put <= ack <= stop <= stop_ack and duration > 0)
reasons = []
if not finished:
reasons.append("missing_or_invalid_completion")
if finished and abs(duration - (stop_ack - put)) > .075:
reasons.append("duration_timestamp_mismatch")
if row.get("outcome") != "settled":
reasons.append("outcome_" + str(row.get("outcome", "unknown")))
if (row.get("clean_stop") is not True or any(s.get("clean") is False for s in stops)
or stop_reason not in {"physical_stop", "priority_stop:watchdog"}):
reasons.append("interrupted_or_unclean_stop")
if put_rtt is None or stop_rtt is None or min(put_rtt, stop_rtt) < 0:
reasons.append("invalid_rtt")
elif finished and (put_rtt / 1000 > ack - put + .05 or abs(stop_rtt / 1000 - (stop_ack - stop)) > .05):
reasons.append("rtt_timestamp_mismatch")
# The settled delta alone cannot separate commanded motion and lens tail.
timing = (start_status, put, ack, stop_sample, stop, stop_ack, first_post, after_at)
ordered = all(t is not None for t in timing) and (
0 < start_status <= put <= ack < stop_sample <= stop <= stop_ack <= first_post < after_at <= row["utc"]
)
if not ordered:
reasons.append("missing_or_unordered_status_brackets")
else:
if stop_sample - put < .04:
reasons.append("insufficient_in_pulse_interval")
if put - start_status > limits.max_before_age_s:
reasons.append("stale_before_status")
if stop - stop_sample > limits.max_pre_stop_age_s:
reasons.append("sparse_pre_stop_status")
if first_post - stop_ack > limits.max_first_post_stop_age_s:
reasons.append("late_post_stop_status")
if first_post - stop_sample > limits.max_status_gap_s:
reasons.append("sparse_status_across_stop")
if after_at - stop_ack > limits.max_settle_s:
reasons.append("settled_status_timeout")
times = [first_post, *(t for t in samples if first_post < t < after_at), after_at]
times.sort()
if max(b - a for a, b in zip(times, times[1:])) > limits.max_status_gap_s:
reasons.append("sparse_post_stop_status")
observations = ((start_status, before), (stop_sample, at_stop), (first_post, first), (after_at, after))
if any(h is not None and any(abs(observed - h) > .1 for observed in samples.get(t, ()))
for t, h in observations):
reasons.append("conflicting_status_samples")
if None in (before, at_stop, first, after):
reasons.append("missing_hfov_bracket")
elif not (after < before and at_stop < before and first <= at_stop + .1 and after <= first + .1):
reasons.append("no_narrowing_or_nonmonotone_hfov")
result = {"request": row.get("request"), "native": row.get("native"), "band": band(before) if before else "unknown",
"outcome": row.get("outcome"), "stop_reason": row.get("stop_reason"),
"completed": finished, "excluded": reasons,
"HFOV_before": before, "HFOV_after": after, "put_at": put, "ack_at": ack,
"stop_issued_at": stop, "stop_ack_at": stop_ack, "after_at": after_at,
"duration_s": duration, "put_rtt_ms": put_rtt, "stop_rtt_ms": stop_rtt,
"effective_log_rate_s": None, "effective_hfov_narrowing_deg_s": None,
"pre_stop_log_rate_s": None, "pre_stop_hfov_narrowing_deg_s": None,
"post_stop_tail_deg": None, "stop_bracket_narrowing_deg": None,
"stop_bracket_log_narrowing": None}
if reasons:
return result
rise = focal(at_stop) - focal(before)
result.update(
effective_log_rate_s=(focal(after) - focal(before)) / duration,
effective_hfov_narrowing_deg_s=(before - after) / duration,
pre_stop_log_rate_s=rise / (stop_sample - put),
pre_stop_hfov_narrowing_deg_s=(before - at_stop) / (stop_sample - put),
post_stop_tail_deg=max(0., first - after),
stop_bracket_narrowing_deg=max(0., at_stop - after),
stop_bracket_log_narrowing=max(0., focal(after) - focal(at_stop)),
)
return result
def mark_rate_outliers(pulses):
eligible = [p for p in pulses if not p["excluded"]]
if len(eligible) < 5:
return
rates = [p["effective_log_rate_s"] for p in eligible]
middle = median(rates)
mad = median(abs(x - middle) for x in rates)
threshold = max(.35 * middle, 5 * 1.4826 * mad)
for pulse in eligible:
if abs(pulse["effective_log_rate_s"] - middle) > threshold:
pulse["excluded"].append("rate_outlier")
def summaries(rows):
result, latest = {}, {}
for row in sorted(rows, key=lambda r: r["utc"]):
counts = row.get("zoom_block_reason")
if not isinstance(counts, dict):
continue
for key, value in counts.items():
if type(value) is int and value >= result.get(key, 0):
result[key] = value
values = row.get("last_values", {})
if isinstance(values, dict) and key in values:
latest[key] = values[key]
return result, latest
def episode_report(owner, rows, limits):
camera, generation, start = owner
by_event = defaultdict(list)
for row in rows:
by_event[row["event"]].append(row)
ticks = sorted(by_event["tick"], key=lambda row: row["utc"])
statuses = status_samples(ticks)
stops = defaultdict(list)
for row in by_event["stop"]:
stops[row.get("request")].append(row)
pulses = [analyze_pulse(row, stops[row.get("request")], statuses, limits) for row in by_event[PULSE]]
requests = Counter(p["request"] for p in pulses)
for pulse in pulses:
if type(pulse["request"]) is not int or pulse["request"] <= 0:
pulse["excluded"].append("invalid_request")
elif requests[pulse["request"]] != 1:
pulse["excluded"].append("conflicting_request_records")
first_events = [r for r in by_event["first_zoom"] if val(r, "t_to_first_zoom_ms") is not None
and r["t_to_first_zoom_ms"] >= 0 and val(r, "native") and r["native"] > 0
and abs(r["t_to_first_zoom_ms"] / 1000 - (r["utc"] - start)) <= .005]
first = min((r["t_to_first_zoom_ms"] for r in first_events), default=None)
ack = min((p["ack_at"] for p in pulses if p["ack_at"] is not None and p["ack_at"] >= start
and number(p["native"]) and p["native"] > 0), default=None)
early = {p["request"] for p in pulses if "interrupted_or_unclean_stop" in p["excluded"]
and p["completed"]}
early.update(key for key, values in stops.items()
if key is not None and any(r.get("clean") is False for r in values))
counts, values = summaries(by_event["zoom_block_summary"])
negative_starts = 0
prev_negative = False
previous_utc = None
predicted_margins = []
tele_s = 0.
prev_tele = False
for row in ticks:
if previous_utc is None or row["utc"] - previous_utc > limits.max_tick_gap_s:
prev_negative, prev_tele = False, False
zoom = val(row, "zoom_cmd")
negative = zoom is not None and zoom < 0
negative_starts += int(negative and not prev_negative)
measured_at, hfov = val(row, "FOV_status_utc"), fov(row, "FOV_actual")
tele = bool(measured_at is not None and hfov is not None and hfov < 18
and 0 <= row["utc"] - measured_at <= limits.max_status_gap_s)
if tele and prev_tele:
tele_s += row["utc"] - previous_utc
prev_negative, prev_tele, previous_utc = negative, tele, row["utc"]
if val(row, "margin") is not None:
predicted_margins.append(row["margin"])
observed_hfov = [h for vals in statuses.values() for h in vals]
for row in by_event[PULSE]:
for key, timestamp in (("HFOV_before", "before_at"), ("HFOV_stop_sample", "stop_status_at"),
("HFOV_first_post_stop", "first_post_stop_at"), ("HFOV_after", "after_at")):
hfov, at = fov(row, key), val(row, timestamp)
if hfov is not None and at is not None and 0 < at <= row["utc"]:
observed_hfov.append(hfov)
edge_samples = []
for row in by_event["zoom_block_summary"]:
edge = row.get("last_values", {})
edge = edge.get("edge_margin", {}) if isinstance(edge, dict) else {}
m = val(edge, "measured") if isinstance(edge, dict) else None
if m is not None and -.5 <= m <= .5:
edge_samples.append(m)
final = any(r.get("final") is True for r in by_event["zoom_block_summary"])
reported_start = first is not None or ack is not None
category = ("early_stop" if early else "positive_ack_observed" if reported_start
else "no_positive_ack_observed" if final else "incomplete_observation")
return {
"cam": camera, "camera": camera + 11, "generation": generation, "track_start_utc": start,
"final_summary_seen": final, "classification": category,
"t_to_first_zoom_s": first / 1000 if first is not None else None,
"t_to_first_observed_pulse_s": first / 1000 if first is not None else ack - start if ack is not None else None,
"min_hfov_deg": min(observed_hfov, default=None),
"tele_observed_s": tele_s, "tele_center_fraction": None, "tele_center_covered_s": 0.,
"min_independently_measured_edge_margin": None,
"tele_center_availability": "PR10 ticks omit target center coordinates",
"min_projected_margin": min(predicted_margins, default=None),
"min_sampled_measured_edge_margin": min(edge_samples, default=None),
"negative_zoom_request_runs": negative_starts,
"confirmed_safety_step_back_count": None,
"safety_step_back_availability": "PR10 does not mark delivered negative commands or their purpose",
"early_stop_requests": len(early),
"zoom_block_reason": counts, "block_last_values": values,
"top_block_reasons": sorted(counts.items(), key=lambda p: (-p[1], p[0]))[:5],
"pulses": pulses,
}, ticks
def load_observations(paths):
"""Optional independent observations indexed by PR10 episode owner."""
records = defaultdict(list)
for path in paths:
with path.open(encoding="utf-8-sig") as source:
for line_no, line in enumerate(source, 1):
if not line.strip():
continue
try:
row = json.loads(line)
cam, generation, start = (val(row, key) for key in ("cam", "generation", "track_start_utc"))
if (cam is None or generation is None or start is None or not cam.is_integer()
or not generation.is_integer() or start <= 0 or not row.get("source")):
raise ValueError("observation needs owner and source")
event = row.get("event")
if event == "frame_observation":
at, x, y = (val(row, key) for key in ("frame_utc", "dx_norm", "dy_norm"))
margin = val(row, "measured_edge_margin")
if (type(row.get("seq")) is not int or at is None or x is None or y is None
or ("measured_edge_margin" in row and
(margin is None or not -.5 <= margin <= .5))):
raise ValueError("frame observation needs seq, frame_utc and normalized offsets")
elif event == "safety_step_back_ack":
if (type(row.get("command_seq")) is not int or val(row, "utc") is None
or row["utc"] < start or row.get("native", 0) >= 0
or row.get("reason") != "tele_step_back"):
raise ValueError("step-back observation needs a delivered negative command and reason")
else:
raise ValueError("unsupported observation event")
records[(int(cam), int(generation), start)].append(row)
except (AttributeError, TypeError, ValueError) as exc:
raise ValueError(f"{path}:{line_no}: {exc}") from exc
return records
def apply_observations(ep, ticks, rows, limits):
if not rows:
return
logged_frames = {r.get("seq"): r for r in ticks if type(r.get("seq")) is int}
statuses = status_samples(ticks)
times = sorted(statuses)
samples = {}
confirmed = set()
for row in rows:
if row["event"] == "safety_step_back_ack":
if ticks and row["utc"] <= ticks[-1]["utc"] + limits.max_tick_gap_s:
confirmed.add(row["command_seq"])
continue
recorded = logged_frames.get(row["seq"])
recorded_at = val(recorded, "frame_utc") if recorded else None
if recorded_at is None or abs(recorded_at - row["frame_utc"]) > .01:
continue
at = row["frame_utc"]
i = bisect_right(times, at) - 1
tele = (i >= 0 and len(statuses[times[i]]) == 1 and max(statuses[times[i]]) < 18
and at - times[i] <= limits.max_status_gap_s)
value = (at, tele, max(abs(row["dx_norm"]), abs(row["dy_norm"])) <= .1,
row.get("measured_edge_margin"))
if row["seq"] in samples and samples[row["seq"]] != value:
raise ValueError(f"Conflicting frame observation for sequence {row['seq']}")
samples[row["seq"]] = value
frames = sorted(samples.values(), key=lambda r: r[0])
exposure = centered = 0.
for a, b in zip(frames, frames[1:]):
dt = b[0] - a[0]
if a[1] and b[1] and 0 < dt <= limits.max_tick_gap_s:
exposure += dt
centered += dt * a[2]
ep["tele_center_covered_s"] = exposure
ep["tele_center_fraction"] = centered / exposure if exposure else None
if exposure:
ep["tele_center_availability"] = "time-weighted over paired independent frames with fresh ISAPI"
ep["min_independently_measured_edge_margin"] = min((r[3] for r in frames if r[3] is not None), default=None)
if confirmed:
ep["confirmed_safety_step_back_count"] = len(confirmed)
ep["safety_step_back_availability"] = "observed independently confirmed acknowledgements; completeness unknown"
def load_profiles(path):
if path is None:
return {cam: {"nominal_gain": n, "upper_gain": u, "min_allowed_hfov_deg": 10.}
for cam, (n, u) in BASELINE.items()}
source = json.loads(path.read_text(encoding="utf-8-sig"))
result = {}
for external, row in source["cameras"].items():
cfg = row.get("predictive_zoom", row.get("replay_settings", row))
nominal, upper = (val(cfg, key) for key in ("nominal_gain", "upper_gain"))
floor = val(cfg, "min_allowed_hfov_deg") if "min_allowed_hfov_deg" in cfg else 10.
edge = val(cfg, "tele_edge_margin_ratio") if "tele_edge_margin_ratio" in cfg else .32
if (nominal is None or upper is None or not 0 < nominal <= upper
or floor is None or not 2 <= floor <= 15 or edge is None or not 0 < edge < .5):
raise ValueError(f"Invalid profile for camera {external}")
result[int(external) - 11] = cfg.copy()
return result
def range_report(pulses, profile):
completed = [p for p in pulses if p["completed"]]
accepted = [p for p in pulses if not p["excluded"]]
excluded = Counter(r for p in pulses for r in p["excluded"])
result = {"seen": len(pulses), "completed": len(completed),
"qualified": len(accepted), "exclusions": dict(sorted(excluded.items())),
"completed_put_rtt_ms": stats(p["put_rtt_ms"] for p in completed if (p["put_rtt_ms"] or 0) >= 0),
"completed_stop_rtt_ms": stats(p["stop_rtt_ms"] for p in completed if (p["stop_rtt_ms"] or 0) >= 0)}
for key in ("effective_log_rate_s", "effective_hfov_narrowing_deg_s", "pre_stop_log_rate_s",
"pre_stop_hfov_narrowing_deg_s", "post_stop_tail_deg", "stop_bracket_narrowing_deg",
"stop_bracket_log_narrowing", "put_rtt_ms", "stop_rtt_ms"):
result[key] = stats(p[key] for p in accepted)
if profile is not None:
nominal, upper = (profile[key] * FULL_SWEEP_LOG_RATE for key in ("nominal_gain", "upper_gain"))
median_observed = result["effective_log_rate_s"]["p50"]
result["native10_profile_comparison"] = {
"nominal_log_rate_s": nominal, "upper_log_rate_s": upper,
"median_observed_over_nominal": None if median_observed is None else median_observed / nominal,
"qualified_effective_rates_above_upper": sum(p["effective_log_rate_s"] > upper for p in accepted),
}
return result
def margin_during_pulse(pulse, ticks, limits):
lo, hi = pulse["put_at"], pulse["after_at"]
window = [r for r in ticks if lo <= r["utc"] <= hi]
if len(window) < 2:
return None
times = [lo, *(r["utc"] for r in window), hi]
if max(b - a for a, b in zip(times, times[1:])) > limits.max_tick_gap_s:
return None
dropped = [val(r, "dropped_before") for r in window]
if None in dropped or min(dropped) != max(dropped):
return None
margins, requirements = [], []
for row in window:
margin, required, measured_at = (val(row, k) for k in
("margin", "edge_margin_required", "FOV_status_utc"))
if (margin is None or not -.5 <= margin < .5 or measured_at is None
or not 0 <= row["utc"] - measured_at <= limits.max_status_gap_s
or fov(row, "FOV_actual") is None or row.get("stop_requested") is True):
return None
margins.append(margin)
if required is not None and 0 < required < .5:
requirements.append(required)
return min(margins), max(requirements, default=limits.edge_buffer)
def next_floor(profile, pulses_and_episodes, limits):
current = profile.get("min_allowed_hfov_deg", limits.field_floor_deg)
near = [(p, ep, ticks) for p, ep, ticks in pulses_and_episodes
if p["HFOV_before"] is not None and current <= p["HFOV_before"] < current + 2
and (p["HFOV_after"] is not None and p["HFOV_after"] <= current + .5
or p["HFOV_before"] <= current + .5 and p["HFOV_after"] is None)]
paired = [(p, ep, margin_during_pulse(p, ticks, limits)) for p, ep, ticks in near
if not p["excluded"] and ep["final_summary_seen"]]
usable = [(p, ep, frame) for p, ep, frame in paired if frame is not None]
result = {"current_deg": current, "proposed_next_test_deg": None, "near_floor_windows": len(near),
"qualified_margin_windows": len(usable), "scope": "bounded_review_only"}
if len(usable) < limits.minimum_pulses or len({ep["track_start_utc"] for _, ep, _ in usable}) < limits.minimum_tracks:
return result | {"reason": "insufficient_near_floor_status_and_framing"}
if len(usable) != len(near):
return result | {"reason": "unqualified_near_floor_windows_present"}
if any(p["HFOV_after"] is not None and p["HFOV_after"] < current - .05
for p, _, _ in pulses_and_episodes):
return result | {"reason": "observed_hfov_below_current_floor"}
worst_tail = max(p["stop_bracket_log_narrowing"] for p, _, _ in usable)
# Bound a small local step by the worst projected extent and observed
# STOP bracket. The +.02 log reserve keeps estimation/rounding conservative.
floors = []
for pulse, _, (margin, required) in usable:
required = max(limits.edge_buffer, required, profile.get("tele_edge_margin_ratio", 0.))
room = (.5 - required) / (.5 - margin)
log_budget = math.log(room) - worst_tail - .02
floors.append(angle(focal(pulse["HFOV_after"]) + log_budget))
geometric_floor = max(floors)
proposed = math.ceil(max(current - limits.floor_step_deg, geometric_floor, 2.) * 10 - 1e-9) / 10
result.update(worst_stop_bracket_log_narrowing=worst_tail, geometry_floor_deg=geometric_floor,
minimum_projected_margin=min(frame[0] for _, _, frame in usable))
if proposed >= current:
return result | {"reason": "no_lower_step_with_observed_margin"}
return result | {"proposed_next_test_deg": proposed, "reason": "limited_step_supported_by_observed_brackets"}
def analyze(episodes, profiles, limits, observations=None):
reports = []
pulses_by_camera = defaultdict(list)
grouped = defaultdict(list)
for owner, rows in sorted(episodes.items()):
ep, ticks = episode_report(owner, rows, limits)
apply_observations(ep, ticks, observations.get(owner, []) if observations else [], limits)
reports.append(ep)
for pulse in ep["pulses"]:
pulses_by_camera[owner[0]].append((pulse, ep, ticks))
grouped[(owner[0], pulse["native"], pulse["band"])].append(pulse)
ranges = defaultdict(dict)
for (cam, native, fov_band), pulses in sorted(grouped.items(), key=lambda p: repr(p[0])):
mark_rate_outliers(pulses)
ranges[cam].setdefault(str(native), {})[fov_band] = range_report(
pulses, profiles.get(cam) if native == 10 else None)
camera_reports = {}
candidates = {}
for cam in sorted({ep["cam"] for ep in reports}):
profile = profiles.get(cam)
native10 = [(p, ep, ticks) for p, ep, ticks in pulses_by_camera[cam] if p["native"] == 10]
accepted = [(p, ep) for p, ep, _ in native10 if not p["excluded"] and p["HFOV_before"] < 18]
count_tracks = len({ep["track_start_utc"] for _, ep in accepted})
floor = next_floor(profile, native10, limits) if profile is not None else {
"current_deg": None, "proposed_next_test_deg": None, "reason": "camera_profile_missing"}
ready = (profile is not None and len(accepted) >= limits.minimum_pulses
and count_tracks >= limits.minimum_tracks)
candidate = None
if ready:
nominal = median(p["effective_log_rate_s"] for p, _ in accepted) / FULL_SWEEP_LOG_RATE
# A rejected rate spike must not quietly reduce the upper envelope.
high = max(max(p["effective_log_rate_s"], p["pre_stop_log_rate_s"])
for p, _, _ in native10 if p["effective_log_rate_s"] is not None
and p["HFOV_before"] < 18)
candidate = profile | {
"nominal_gain": nominal,
"upper_gain": max(profile["upper_gain"], nominal, 1.25 * high / FULL_SWEEP_LOG_RATE),
"min_allowed_hfov_deg": (floor["proposed_next_test_deg"] if floor["proposed_next_test_deg"] is not None
else profile.get("min_allowed_hfov_deg", limits.field_floor_deg)),
}
candidates[str(cam + 11)] = {
"internal_camera": cam, "qualified_tele_pulses": len(accepted), "qualified_tracks": count_tracks,
"baseline_predictive_zoom": profile, "predictive_zoom_for_review": candidate,
"next_floor_review": floor,
"observed_start_hfov_deg": stats(p["HFOV_before"] for p, _ in accepted),
}
camera_reports[str(cam + 11)] = {
"internal_camera": cam, "pulses_by_native_and_hfov_band": ranges[cam],
"episodes": sum(ep["cam"] == cam for ep in reports),
"t_to_first_zoom_s": stats(ep["t_to_first_zoom_s"] for ep in reports if ep["cam"] == cam),
}
return {"cameras": camera_reports, "episodes": reports}, {
"production_enable": False, "scope": "offline_native10_profile_for_review", "cameras": candidates}
def md_number(value, scale=1):
return "—" if value is None else f"{value * scale:.3f}"
def markdown(report, candidate):
lines = [
"# Полевой отчёт Chameleon-C · PR №10", "",
"Время первого зума отсчитывается от TRACK до подтверждения первого положительного PUT. "
"Минимальный HFOV берётся из фактических замеров ISAPI.", "",
"| Камера | TRACK UTC (Unix s) | Статус | Первый зум, с | HFOV min, ° | Секунды с HFOV <18° | "
"В центре, % | Прогноз запаса, % | Измеренный запас, % | Запросы / подтверждённые шаги |",
"|---|---:|---|---:|---:|---:|---:|---:|---:|---:|",
]
for ep in report["episodes"]:
lines.append(
f'| PTZ{ep["camera"]} | {ep["track_start_utc"]:.3f} | {ep["classification"]} | '
f'{md_number(ep["t_to_first_zoom_s"])} | {md_number(ep["min_hfov_deg"])} | '
f'{md_number(ep["tele_observed_s"])} | {md_number(ep["tele_center_fraction"], 100)} | '
f'{md_number(ep["min_projected_margin"], 100)} | '
f'{md_number(ep["min_independently_measured_edge_margin"] if ep["min_independently_measured_edge_margin"] is not None else ep["min_sampled_measured_edge_margin"], 100)} | '
f'{ep["negative_zoom_request_runs"]} / {ep["confirmed_safety_step_back_count"] if ep["confirmed_safety_step_back_count"] is not None else "—"} |'
)
lines += ["", "Координаты центра и подтверждения защитных расширений берутся из дополнительных "
"наблюдений, когда они переданы. Без них эти метрики остаются неизвестными. "
"Запросы расширения считаются по наблюдаемым группам отрицательного zoom_cmd. "
"Измеренный запас из одного PR10 JSONL ограничен выборкой блокировок у края.", "",
"Ориентиры стенда PR №10 — 1,72 с до первого импульса на восстановленном PTZ19 при "
"220/50 мс, 100% и 99,92% у центра для PTZ19 и PTZ21 на общих отсчётах ниже 18°. "
"Сопоставимость с полевым пролётом зависит от траектории, задержки и покрытия наблюдений.", "",
"## Причины блокировки", ""]
for ep in report["episodes"]:
if ep["classification"] in ("no_positive_ack_observed", "early_stop", "incomplete_observation"):
reasons = ", ".join(f"{reason} ({count})" for reason, count in ep["top_block_reasons"]) or "сводки нет"
lines.append(f'- PTZ{ep["camera"]}, TRACK {ep["track_start_utc"]:.3f} · {reasons}')
lines += ["", "## Отклик оптики и RTT", "",
"| Камера | Native | Диапазон HFOV | Принято / завершено | До STOP, °/с (медиана) | "
"Хвост после STOP, ° (макс.) | Верхняя граница скобки STOP, ° (макс.) | RTT PUT / STOP p95, мс |",
"|---|---:|---|---:|---:|---:|---:|---:|"]
for camera, rows in report["cameras"].items():
for native, bins in rows["pulses_by_native_and_hfov_band"].items():
for name, value in sorted(bins.items(), key=lambda x: (BINS+("unknown",)).index(x[0])):
lines.append(f'| PTZ{camera} | {native} | {name} | {value["qualified"]} / {value["completed"]} | '
f'{md_number(value["pre_stop_hfov_narrowing_deg_s"]["p50"])} | '
f'{md_number(value["post_stop_tail_deg"]["max"])} | '
f'{md_number(value["stop_bracket_narrowing_deg"]["max"])} | '
f'{md_number(value["completed_put_rtt_ms"]["p95"])} / '
f'{md_number(value["completed_stop_rtt_ms"]["p95"])} |')
lines += ["", "Скорость до STOP оценивается по статусу от PUT до последнего замера перед STOP. "
"Остаточное сужение от первого замера после STOP даёт нижнюю оценку. "
"Интервал от последнего замера до STOP даёт верхнюю наблюдаемую скобку при монотонном движении.", "",
"## Следующий предел HFOV", ""]
for camera, row in candidate["cameras"].items():
f = row["next_floor_review"]
lines.append(f'- PTZ{camera} · текущий {md_number(f["current_deg"])}°, '
f'следующий на проверку {md_number(f["proposed_next_test_deg"])}° · {f["reason"]}')
lines += ["", "Предложение ограничено наблюдавшимся диапазоном и малым шагом. "
"Полный набор исключений, RTT и оценки по импульсам находятся в field_report.json.", ""]
return "\n".join(lines)
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("inputs", nargs="+", type=Path, help="episode JSONL files or directories")
parser.add_argument("--output-dir", type=Path, required=True)
parser.add_argument("--profile", type=Path, help="JSON cameras keyed by external camera number")
parser.add_argument("--observations", nargs="+", type=Path,
help="optional independent frame and step-back observations, separate from PR10 JSONL")
parser.add_argument("--max-before-age-ms", type=float, default=650.)
parser.add_argument("--max-pre-stop-age-ms", type=float, default=180.)
parser.add_argument("--max-first-post-stop-age-ms", type=float, default=250.)
parser.add_argument("--max-status-gap-ms", type=float, default=350.)
args = parser.parse_args(argv)
delays = (args.max_before_age_ms, args.max_pre_stop_age_ms,
args.max_first_post_stop_age_ms, args.max_status_gap_ms)
if not all(math.isfinite(x) and x > 0 for x in delays):
parser.error("Status thresholds must be finite and positive")
limits = Limits(*(x / 1000 for x in delays))
try:
inputs = input_files(args.inputs)
episodes, metadata = load_episodes(inputs)
if not episodes:
raise ValueError("No recognized PR10 events")
profiles = load_profiles(args.profile)
observations = load_observations(args.observations) if args.observations else {}
report, candidate = analyze(episodes, profiles, limits, observations)
metadata["independent_observation_files"] = [str(p) for p in (args.observations or [])]
report.update(input=metadata, limits=vars(limits),
baseline_profile_source=str(args.profile) if args.profile else "PR10 published replay coefficients")
args.output_dir.mkdir(parents=True, exist_ok=True)
files = {"native10_calibrated.json": json.dumps(candidate, indent=2, allow_nan=False) + "\n",
"field_report.json": json.dumps(report, indent=2, allow_nan=False) + "\n",
"field_report.md": markdown(report, candidate)}
protected = set(inputs) | {p.resolve() for p in (args.observations or [])}
if args.profile:
protected.add(args.profile.resolve())
if any((args.output_dir / name).resolve() in protected for name in files):
raise ValueError("Output path would overwrite an input")
for name, content in files.items():
(args.output_dir / name).write_text(content, encoding="utf-8")
except (OSError, KeyError, TypeError, ValueError) as exc:
parser.error(str(exc))
return 0
if __name__ == "__main__":
raise SystemExit(main())

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

@ -42,3 +42,11 @@
- Полный повтор TRACK и транспорта: run_local_replay.py принимает каталог снимков Codex, каталог пакета, корень Electro-pribory, вариант before или after и необязательный путь к материализованной серверной копии.
- Парный стенд: replay_broad_tele.py запускается с --camera 19 и --camera 21, дополнительно с --edge-stress, --put-rtt и --problem. Каталог с candidate и pins.json задаёт PTZ_BROAD_TELE_REPLAY_DIR. Нужны сохранённые записи AIM и стенд предыдущего PR в соседних каталогах снимков.
- График одного эпизода: python plot_episode.py episode.jsonl episode.svg
## Проверка задержек перед выкаткой
Из корня репозитория запустите `python integration/ptz_predictive_zoom/check_replay_latency.py latency_report`. Нужны те же локальные снимки, что для парного стенда. Скрипт сверяет SHA-256 копии PR №10 и запускает PR №8 и PR №10 на одинаковых траекториях. По умолчанию используются четыре крайние комбинации задержек видео и ISAPI и середина диапазона. Задержка PUT и STOP моделируется как RTT, физическая доставка — как половина RTT. Снимок статуса приходит через заданную задержку ISAPI после виртуального замера. Кадры поступают с шагом 100 мс и исходной меткой захвата.
Сценарии включают восстановленные пролёты PTZ19 и PTZ21 с 59°, старт с 12° с боковым ускорением и синтетическую медленную цель на 13°. В сценариях с суффиксом `_tail` линза ещё 80 мс идёт с прежней скоростью после доставки STOP. Это заданный стрессовый выбег. Отдельную проверку повторных импульсов можно запустить с `--scenario tele_centered --scenario tele_centered_tail --centered-hfov 17.5 --delay 250 60`. Каждый запуск сохраняет подробные трассы и `comparison.json` в новый каталог.
Счётчики `edge_during_narrowing_steps` и `narrowing_below_floor_steps` используют шаг физической модели 10 мс, включая моделируемый выбег. `positive_starts` показывает число запусков положительного зума, `hfov_min` — минимальный HFOV модели в сохранённых отсчётах. Полевой отклик на телеугле оценивается отдельно по замерам ISAPI.

@ -0,0 +1,88 @@
"""Stress the pinned offline replay with independent video and ISAPI delays."""
import argparse
import json
from pathlib import Path
import replay_broad_tele as replay
DELAYS = ((180, 40), (180, 60), (220, 50), (250, 40), (250, 60))
SCENARIOS = ("wide", "tele", "tele_tail", "tele_centered", "tele_centered_tail")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("output", type=Path, help="new directory for comparison and replay traces")
parser.add_argument("--scenario", action="append", choices=SCENARIOS)
parser.add_argument("--centered-hfov", type=float, default=13.)
parser.add_argument("--delay", nargs=2, action="append", type=int, metavar=("VIDEO_MS", "ISAPI_RTT_MS"))
args = parser.parse_args()
if not 10. <= args.centered_hfov < 18.:
parser.error("--centered-hfov must be at least 10 and below 18 degrees")
delays = tuple(dict.fromkeys(map(tuple, args.delay))) if args.delay else DELAYS
if any(not (180 <= video <= 250 and 40 <= api <= 60 and video % 10 == api % 10 == 0)
for video, api in delays):
parser.error("--delay must use 10 ms steps within 180–250 video and 40–60 ISAPI")
import torch
torch.set_num_threads(1)
pinned = replay.read(Path(__file__).with_name("pins.json"))
if replay.read(replay.NEW_PINS) != pinned:
raise ValueError("Local PR10 replay snapshot does not match the repository pins")
args.output.mkdir(parents=True, exist_ok=False)
field, pulses = replay.read(replay.FIELD), replay.read(replay.PULSES)
profiles = replay.read(replay.DATA / "profiles.json")["cameras"]
steering = replay.read(replay.LAB / "field-calibration-report.json")["cameras"]
report = []
for camera, (early, late) in replay.FLIGHTS.items():
episodes = pulses["episodes"][camera]
wide, narrow = (
replay.trajectory(camera, next(e for e in episodes if e["started_at"][11:19] == key), field)
for key in (late, early)
)
wide = dict(wide, duration=min(7., wide["duration"]))
narrow = dict(narrow, stress=True, edge_stress=True, duration=min(5., narrow["duration"]))
# A deliberately small, slow target creates genuine repeat-zoom
# opportunities at the floor. Keep it separate from reconstructed AIM.
centered = dict(
camera=int(camera), episode=None, duration=4.,
knots=((0., 0., 0.), (4., .24, .08)), angular_extent=(.28, .18),
initial_pose_offset_fov=(0., 0.),
)
for scenario, trace, fov, tail_ms in (
("wide", wide, 59., 0), ("tele", narrow, 12., 0), ("tele_tail", narrow, 12., 80),
("tele_centered", centered, args.centered_hfov, 0),
("tele_centered_tail", centered, args.centered_hfov, 80),
):
if args.scenario and scenario not in args.scenario:
continue
for video, api in delays:
row = dict(camera=int(camera), episode=trace["episode"], scenario=scenario,
video_ms=video, isapi_rtt_ms=api, initial_hfov_deg=fov, lens_tail_ms=tail_ms,
results={})
for revision in ("PR8", "BT"):
result = replay.run(
trace, profiles[camera]["replay_settings"], steering[camera]["fit"],
revision, video, api, fov, plant_stress=fov < 59., put_rtt=True, lens_tail_ms=tail_ms,
)
filename = f"{camera}-{scenario}-{video}-{api}-{revision}.json"
(args.output / filename).write_text(
json.dumps(result, allow_nan=False, separators=(",", ":")) + "\n", encoding="utf-8",
)
row["results"][revision] = dict(
trace=filename, metrics=result["metrics"],
before_first=result["zoom_block_reason_before_first"],
simultaneous_before_first=result["simultaneous_flags_before_first"],
)
report.append(row)
bt = row["results"]["BT"]["metrics"]
print(camera, scenario, video, api, bt["hfov_min"], bt["edge_during_narrowing_steps"],
bt["narrowing_below_floor_steps"], flush=True)
(args.output / "comparison.json").write_text(
json.dumps(report, indent=2, allow_nan=False) + "\n", encoding="utf-8",
)
if __name__ == "__main__":
main()

@ -87,18 +87,37 @@ def trajectory(camera, episode, source):
class FlightCamera(sim.Camera):
def __init__(self, parameters, pan_sign, tilt_sign, trace, initial_fov):
def __init__(self, parameters, pan_sign, tilt_sign, trace, initial_fov, lens_tail_ms=0):
super().__init__(parameters, pan_sign, tilt_sign)
self.trace = trace
self.times = [x[0] for x in trace["knots"]]
self.lens_tail_s = lens_tail_ms / 1000
self.lens_native = 0
self.lens_tail_until = 0.
self.magnification = sim.OPTICAL_ZOOM ** (
math.log(math.tan(math.radians(59/2))/math.tan(math.radians(initial_fov/2)))
/ math.log(math.tan(math.radians(59/2))/math.tan(math.radians(2/2)))
)
if initial_fov < 20:
_, az, el = trace["knots"][0]
# Keep this synthetic narrow-angle stress start inside the aperture.
self.pan, self.tilt = az-.10*initial_fov, el-.05*initial_fov
x, y = trace.get("initial_pose_offset_fov", (.10, .05))
self.pan, self.tilt = az - x * initial_fov, el - y * initial_fov
def step(self, t, dt):
previous_zoom = self.active[2]
super().step(t, dt)
zoom = self.active[2]
if zoom:
self.lens_tail_until = 0.
elif previous_zoom > 0 and self.lens_tail_s:
self.lens_tail_until = t + self.lens_tail_s
if zoom == 0 and t < self.lens_tail_until - 1e-9:
# Offline stress bound: hold the last positive speed after STOP.
# Pan/Tilt have already been stepped with the new command.
scale = 2 ** (self.lens_native * self.parameters.zoom_at_10 * dt / 10)
self.magnification = min(self.parameters.zoom_max, self.magnification * scale)
else:
self.lens_native = zoom
def target(self, t):
i = min(len(self.times)-2, max(0, bisect_right(self.times,t)-1))
@ -181,7 +200,7 @@ def blocker(row, st):
def run(trace, profile, steering, revision, video_ms, isapi_ms, initial_fov=59.,
plant_stress=False, put_rtt=False):
plant_stress=False, put_rtt=False, lens_tail_ms=0):
import numpy
import torch
@ -246,7 +265,8 @@ def run(trace, profile, steering, revision, video_ms, isapi_ms, initial_fov=59.,
stack.enter_context(patch.dict(cam_config,settings))
for key in ("ZOOM_STEP_PULSE_SEC","ZOOM_STEP_HARD_STOP_SEC"):
stack.enter_context(patch.object(config,key,values[key]))
plant = FlightCamera(cfg,float(cam_config.get("pan_sign",1)),float(cam_config.get("tilt_sign",-1)),trace,initial_fov)
plant = FlightCamera(cfg,float(cam_config.get("pan_sign",1)),float(cam_config.get("tilt_sign",-1)),
trace,initial_fov,lens_tail_ms)
initial = plant.project(0)
if initial is None:
raise ValueError("Invalid initial viewport")
@ -304,12 +324,21 @@ def run(trace, profile, steering, revision, video_ms, isapi_ms, initial_fov=59.,
interval = video_ms//10
stop_step = round(trace["duration"]*100)
optics_count=0
floor_penetration = edge_during_narrowing = 0
floor = settings["predictive_zoom"].get("min_allowed_hfov_deg",10.)
for step in range(stop_step+1):
t=step/100
now = max(t,busy_until)
f.wall,f.mono=100+now,1000+now
if step:
before_hfov = plant.hfov
plant.step(t,.01)
if plant.hfov < before_hfov:
box = plant.project(t,clipped=False)
edge_during_narrowing += (
box is None or box[0] < 0 or box[1] < 0 or box[2] >= 1280 or box[3] >= 720
)
floor_penetration += initial_fov >= floor and plant.hfov < floor - 1e-6
if step%25==0:
statuses.append((step+isapi_ms//10,step,plant.magnification,plant.hfov,plant.vfov,
plant.pan_rate*plant.pan_sign,plant.tilt_rate*plant.tilt_sign))
@ -361,7 +390,7 @@ def run(trace, profile, steering, revision, video_ms, isapi_ms, initial_fov=59.,
margin=min(x0/1280,1-x1/1280,y0/720,1-y1/720)
px=(x1-x0,y1-y0)
rows.append(dict(t=t,hfov=plant.hfov,margin=margin,center_err=error,bbox_px=px,
mode=st.get("mode"),zoom=plant.active[2],
mode=st.get("mode"),zoom=plant.active[2],lens_native=plant.lens_native,
tele_steering=st.get("tele_steering_active",False)))
first=request_starts[0] if request_starts else None
prefix=[row for row in decisions if first is None or row["t"]<=first]
@ -371,7 +400,7 @@ def run(trace, profile, steering, revision, video_ms, isapi_ms, initial_fov=59.,
trace={k:val for k,val in trace.items() if k!="knots"}, revision=revision,
tested_after_sha={file:row["after"] for file,row in pins.items()},
video_ms=video_ms,isapi_ms=isapi_ms,initial_fov=initial_fov,plant_stress=plant_stress,
put_rtt_ms=isapi_ms if put_rtt else 0,
put_rtt_ms=isapi_ms if put_rtt else 0,lens_tail_ms=lens_tail_ms,
observed_model=dict(profile=profile,pan_at_native10=cfg.pan_at_10,tilt_at_native10=cfg.tilt_at_10),
metrics=dict(first_zoom_s=first,positive_starts=len(request_starts),optics_confirmed_max=optics_count,
hfov_min=round(min(r["hfov"] for r in rows),3),
@ -385,6 +414,8 @@ def run(trace, profile, steering, revision, video_ms, isapi_ms, initial_fov=59.,
peak_center_error=round(max(errors),4) if errors else None,
narrow_lens_active_samples=sum(r["hfov"]<=15 and r["zoom"]>0 for r in rows),
narrowing_with_edge_clip_samples=sum(r["margin"]<0 and r["zoom"]>0 for r in rows),
edge_during_narrowing_steps=edge_during_narrowing,
narrowing_below_floor_steps=floor_penetration if initial_fov>=floor else None,
first_edge_clip_s=next((r["t"] for r in rows if r["margin"]<0),None),
positive_native=dict(Counter(axes[2] for _,axes in commands if axes[2]>0)),
max_bbox_short_px=max((min(r["bbox_px"]) for r in rows if r["bbox_px"]),default=0)),

Loading…
Cancel
Save