"""Offline integration candidate. No network, model loader, threads or PTZ worker. The producer binds source/epoch under the existing camera control lock. The classifier calls run_one on its OWN worker, never on the camera control thread. Unknown occlusion quality is not evidence that an object is unobscured. """ from collections import OrderedDict from dataclasses import dataclass from math import ceil, floor from itertools import islice from threading import Lock from .frame_time import FrameStamp from .unknown_inspection import Recognition, finite, valid_box def source_key(stamp): return stamp.source_id, stamp.stream_epoch, stamp.clock_epoch def check_stamp(stamp, *, camera, seq, owner, expected_owner, binding, now, age): return (isinstance(stamp, FrameStamp) and stamp.camera_id == camera and type(seq) is int and stamp.source_seq == seq and seq > 0 and owner is not None and owner == expected_owner and binding == source_key(stamp) and finite(now, age) and 0 <= now-stamp.decode_mono_ns/1e9 <= age) def provenance(st, result, sample, *, camera, seq, owner, mono, visual_only): """Only accepted producer stamps can tighten the controller's deadline. Called after foreign-owner early return, under the existing control lock. Binding MUST be set by source lifecycle; it is never learned from a result. """ value = sample if visual_only else result stamp = getattr(value, 'inspection_stamp', None) incoming_owner = getattr(value, 'inspection_owner', None) if not check_stamp(stamp, camera=camera, seq=seq, owner=incoming_owner, expected_owner=owner, binding=st.get('inspection_source_binding'), now=mono, age=.25 if visual_only else .65): return 'missing_or_stale_original_stamp' acquired = stamp.decode_mono_ns/1e9 if not visual_only: last = st.get('inspection_detector_stamp') if (last is not None and (source_key(last) != source_key(stamp) or stamp.source_seq <= last.source_seq or stamp.decode_mono_ns <= last.decode_mono_ns)): return 'duplicate_or_reordered_original_frame' st['inspection_detector_stamp'] = stamp st['inspection_input_mono'] = acquired return '' def current_detector(st, mono): stamp = st.get('inspection_detector_stamp') return bool(isinstance(stamp, FrameStamp) and source_key(stamp) == st.get('inspection_source_binding') and finite(mono) and 0 <= mono-stamp.decode_mono_ns/1e9 <= .65) @dataclass(frozen=True) class CropContext: camera: int inspection_id: int owner: tuple source: tuple classifier_sha: str @dataclass(frozen=True) class CropJob: context: CropContext stamp: FrameStamp bbox: tuple shape: tuple pixels: object sharpness: float clipped: bool occluded: bool | None class CropWorker: """One in-flight callback, one pending crop/result per configured camera. Replacement keeps camera FIFO position: a busy camera cannot starve others. max_pixels bounds each copied crop; full frames are never retained. A stalled classifier can delay recognition, but submit/take do not acquire its lock. """ def __init__(self, cameras, *, max_pixels=1024*1024): if (type(cameras) not in (tuple, list) or not cameras or len(cameras) > 6 or any(type(c) is not int or c < 0 for c in cameras) or len(set(cameras)) != len(cameras) or type(max_pixels) is not int or not 1 <= max_pixels <= 1024*1024): raise ValueError('Bounded physical camera set required') self.cameras, self.max_pixels = frozenset(cameras), max_pixels self._pending, self._results, self._active = OrderedDict(), {}, {} self._latest = {} self._decode_ages = {} # bounded by the configured camera set self._generation = {c: 0 for c in self.cameras} self._lock, self._worker = Lock(), Lock() def bind(self, context): from .unknown_inspection import digest if (not isinstance(context, CropContext) or context.camera not in self.cameras or type(context.inspection_id) is not int or context.inspection_id <= 0 or not context.owner or type(context.source) is not tuple or len(context.source) != 3 or not digest(context.classifier_sha)): raise ValueError('Explicit inspection/source/model context required') with self._lock: if self._active.get(context.camera) == context: return self._generation[context.camera] += 1 self._active[context.camera] = context self._pending.pop(context.camera, None) self._results.pop(context.camera, None) self._latest.pop(context.camera, None) self._decode_ages.pop(context.camera, None) def revoke(self, camera): if camera not in self.cameras: raise ValueError('Unknown physical camera') with self._lock: self._generation[camera] += 1 self._active.pop(camera, None) self._pending.pop(camera, None) self._results.pop(camera, None) self._latest.pop(camera, None) self._decode_ages.pop(camera, None) def submit(self, context, stamp, frame, bbox, *, now, occluded=None): import numpy as np if (not isinstance(context, CropContext) or context.camera not in self.cameras or not isinstance(frame, np.ndarray) or frame.dtype != np.uint8 or frame.ndim != 3 or frame.shape[2] != 3 or not valid_box(bbox, tuple(frame.shape[:2])) or occluded is not None and type(occluded) is not bool or not check_stamp(stamp, camera=context.camera, seq=getattr(stamp, 'source_seq', None), owner=context.owner, expected_owner=context.owner, binding=context.source, now=now, age=.65)): return False with self._lock: if self._active.get(context.camera) != context: return False generation = self._generation[context.camera] x1, y1, x2, y2 = bbox left, top, right, bottom = floor(x1), floor(y1), ceil(x2), ceil(y2) if (right-left)*(bottom-top) > self.max_pixels: return False # Copy belongs to this exact image and sequence; do not resize/upscale it # to meet recognition thresholds or invent source detail. pixels = frame[top:bottom, left:right].copy() if pixels.shape[0] < 3 or pixels.shape[1] < 3: return False gray = pixels.astype(np.float32).mean(axis=2) lap = -4*gray[1:-1, 1:-1]+gray[:-2, 1:-1]+gray[2:, 1:-1]+gray[1:-1, :-2]+gray[1:-1, 2:] sharpness = float(lap.var()) pixels.flags.writeable = False job = CropJob(context, stamp, tuple(bbox), tuple(frame.shape[:2]), pixels, sharpness, x1 <= 0 or y1 <= 0 or x2 >= frame.shape[1] or y2 >= frame.shape[0], occluded) with self._lock: if (self._active.get(context.camera) != context or self._generation[context.camera] != generation): return False last = self._latest.get(context.camera) if last and (stamp.source_seq <= last.source_seq or stamp.decode_mono_ns <= last.decode_mono_ns): return False self._latest[context.camera] = stamp self._pending[context.camera] = job return True def run_one(self, classify, *, clock): """Return False when busy/empty; failures leave the object UNKNOWN.""" if not self._worker.acquire(blocking=False): return False try: with self._lock: if not self._pending: return False camera, job = self._pending.popitem(last=False) generation = self._generation[camera] start_age = clock()-job.stamp.decode_mono_ns/1e9 with self._lock: if self._active.get(camera) == job.context and self._generation[camera] == generation: self._decode_ages[camera] = {'recognition_start': start_age} if not 0 <= start_age <= .65: return False try: scores = tuple(islice(classify(job.pixels), 5)) from .unknown_inspection import TARGETS, NON_TARGETS if (len(scores) != 4 or any(type(p) is not tuple or len(p) != 2 or type(p[0]) is not str or not finite(p[1]) or not 0 <= p[1] <= 1 for p in scores) or {p[0] for p in scores} != TARGETS | NON_TARGETS or abs(sum(p[1] for p in scores)-1) > 1e-4): return False except Exception: return False # The callback cannot bless clipping, missing occlusion quality, # completion time, source or owner. It returns semantic scores only. rec = Recognition(camera, job.context.inspection_id, job.context.owner, job.stamp.source_seq, job.stamp.decode_utc_ns/1e9, job.context.classifier_sha, job.bbox, job.shape, scores, job.sharpness, job.clipped, job.occluded is not False) with self._lock: if (self._active.get(camera) != job.context or self._generation[camera] != generation): return False complete_age = clock()-job.stamp.decode_mono_ns/1e9 self._decode_ages[camera]['recognition_complete'] = complete_age if not 0 <= complete_age <= .65: return False self._results[camera] = (job.context, job.stamp, rec) return True finally: self._worker.release() def take(self, context, *, now): row = self.take_stamped(context, now=now) return row[1] if row else None def take_stamped(self, context, *, now): """Exact original stamp accompanies a delayed classifier result.""" with self._lock: if self._active.get(context.camera) != context: return None row = self._results.get(context.camera) if not row or row[0] != context: return None self._results.pop(context.camera) if not 0 <= now-row[1].decode_mono_ns/1e9 <= .65: return None return row[1], row[2] def counts(self): with self._lock: return len(self._pending), len(self._results) def decode_ages(self): """Latest bounded local decode ages, never camera exposure/capture lag.""" with self._lock: return {camera: dict(row) for camera, row in self._decode_ages.items()}