416 lines
14 KiB
Python
416 lines
14 KiB
Python
import time
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
import cv2
|
|
import numpy as np
|
|
|
|
import flywms_navigation as nav
|
|
|
|
try:
|
|
import dearpygui.dearpygui as dpg
|
|
except ModuleNotFoundError as exc:
|
|
dpg = None
|
|
DEARPYGUI_IMPORT_ERROR = exc
|
|
else:
|
|
DEARPYGUI_IMPORT_ERROR = None
|
|
|
|
|
|
TEXTURE_MAIN = "texture_main"
|
|
TEXTURE_SNAPSHOT = "texture_snapshot"
|
|
TEXTURE_REGISTRY = "texture_registry"
|
|
IMAGE_MAIN = "image_main"
|
|
IMAGE_SNAPSHOT = "image_snapshot"
|
|
TEXT_STATUS = "text_status"
|
|
TEXT_COMMANDS = "text_commands"
|
|
TEXT_TRACKS = "text_tracks"
|
|
TEXT_METRICS = "text_metrics"
|
|
BUTTON_RUN = "button_run"
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class DemoFrameState:
|
|
frame_id: int
|
|
elapsed: float
|
|
source_frame: np.ndarray
|
|
display_frame: np.ndarray
|
|
snapshot_frame: np.ndarray | None
|
|
tracks: list[nav.Track]
|
|
detections_count: int
|
|
snapshots: list[nav.NavigationSnapshot]
|
|
yolo_ms: float
|
|
fps_text: str
|
|
|
|
|
|
class NavigationDemoEngine:
|
|
"""One-step navigation simulator used by the DearPyGUI shell.
|
|
|
|
The original flywms_navigation.py command-line program stays untouched.
|
|
This class reuses its detector/tracker/navigation objects and exposes a
|
|
frame-by-frame API suitable for a GUI event loop.
|
|
"""
|
|
|
|
def __init__(self, args):
|
|
self.args = args
|
|
nav.require_file(args.weights, "modello Ultralytics")
|
|
self.detector = nav.UltralyticsDetector(args.weights, args.ultralytics_device)
|
|
self.cap, self.source_name = nav.open_capture(args.video)
|
|
if not self.cap.isOpened():
|
|
raise RuntimeError(f"impossibile aprire sorgente video: {self.source_name}")
|
|
|
|
video_fps = self.cap.get(cv2.CAP_PROP_FPS)
|
|
preview_fps = args.preview_fps if args.preview_fps and args.preview_fps > 0 else video_fps
|
|
if args.preview_fps and args.preview_fps > 0 and (args.video is None or str(args.video).isdigit()):
|
|
self.cap.set(cv2.CAP_PROP_FPS, float(args.preview_fps))
|
|
self.frame_delay = (
|
|
1.0 / preview_fps
|
|
if args.realtime_playback and preview_fps and preview_fps > 1
|
|
else 0.0
|
|
)
|
|
self.yolo_interval = 1.0 / args.yolo_fps if args.yolo_fps and args.yolo_fps > 0 else 0.0
|
|
self.tracker = nav.LightweightTracker(
|
|
max_missed=args.max_track_missed,
|
|
min_match_score=args.min_match_score,
|
|
max_center_distance_ratio=args.max_center_distance_ratio,
|
|
)
|
|
self.navigator = nav.NavigationController(args)
|
|
self.frame_id = 0
|
|
self.start_time = time.perf_counter()
|
|
self.last_loop_end = self.start_time
|
|
self.yolo_total_ms = 0.0
|
|
self.yolo_cycles = 0
|
|
self.next_yolo_time = self.start_time
|
|
self.last_yolo_ms = 0.0
|
|
self.gaylords: list[nav.Detection] = []
|
|
self.tracks: list[nav.Track] = []
|
|
self.stop_reason = ""
|
|
|
|
def close(self) -> None:
|
|
self.cap.release()
|
|
|
|
def step(self) -> DemoFrameState | None:
|
|
if self.frame_delay > 0:
|
|
now = time.perf_counter()
|
|
sleep_for = self.frame_delay - (now - self.last_loop_end)
|
|
if sleep_for > 0:
|
|
time.sleep(sleep_for)
|
|
self.last_loop_end = time.perf_counter()
|
|
|
|
ok, frame = self.cap.read()
|
|
if not ok:
|
|
self.stop_reason = "Fine stream"
|
|
return None
|
|
|
|
self.frame_id += 1
|
|
timestamp = time.perf_counter()
|
|
if self.args.max_frames > 0 and self.frame_id > self.args.max_frames:
|
|
self.stop_reason = f"Raggiunto max_frames={self.args.max_frames}"
|
|
return None
|
|
|
|
new_snapshots: list[nav.NavigationSnapshot] = []
|
|
run_yolo = self.yolo_interval <= 0 or timestamp >= self.next_yolo_time
|
|
if run_yolo:
|
|
self.next_yolo_time = timestamp + self.yolo_interval
|
|
detections, self.last_yolo_ms = self.detector.detect(
|
|
frame,
|
|
self.args.min_confidence,
|
|
self.args.input_size,
|
|
)
|
|
self.yolo_total_ms += self.last_yolo_ms
|
|
self.yolo_cycles += 1
|
|
|
|
self.gaylords = [
|
|
det for det in detections
|
|
if det.class_name.strip().lower() == self.args.target_class.strip().lower()
|
|
]
|
|
self.tracks = self.tracker.update(self.gaylords, self.frame_id, frame.shape[1])
|
|
|
|
if (
|
|
self.args.motion_report_interval > 0
|
|
and self.yolo_cycles % self.args.motion_report_interval == 0
|
|
):
|
|
self.navigator.set_motion_text(
|
|
nav.estimate_motion_from_tracks(self.tracks, self.args.motion_min_pixels)
|
|
)
|
|
|
|
for track in self.tracks:
|
|
if track.missed == 0:
|
|
snapshot = self.navigator.process_track(
|
|
track,
|
|
frame,
|
|
self.frame_id,
|
|
timestamp,
|
|
)
|
|
if snapshot is not None:
|
|
new_snapshots.append(snapshot)
|
|
|
|
for snapshot in new_snapshots:
|
|
self.navigator.simulate_remote_response(snapshot)
|
|
|
|
elapsed = max(time.perf_counter() - self.start_time, 0.001)
|
|
fps_text = (
|
|
f"frame={self.frame_id} fps={self.frame_id / elapsed:.1f} "
|
|
f"yolo_fps={self.yolo_cycles / elapsed:.1f} yolo={self.last_yolo_ms:.0f}ms "
|
|
f"det={len(self.gaylords)} tracks={len(self.tracks)} "
|
|
f"snap={self.navigator.snapshot_counter}"
|
|
)
|
|
display = nav.draw_navigation_debug(
|
|
frame,
|
|
self.tracks,
|
|
self.args,
|
|
self.navigator.last_command_text,
|
|
fps_text,
|
|
)
|
|
|
|
return DemoFrameState(
|
|
frame_id=self.frame_id,
|
|
elapsed=elapsed,
|
|
source_frame=frame,
|
|
display_frame=display,
|
|
snapshot_frame=self.navigator.last_ocr_payload_frame,
|
|
tracks=self.tracks,
|
|
detections_count=len(self.gaylords),
|
|
snapshots=new_snapshots,
|
|
yolo_ms=self.last_yolo_ms,
|
|
fps_text=fps_text,
|
|
)
|
|
|
|
|
|
class NavigationDemoGui:
|
|
def __init__(self, args):
|
|
self.args = args
|
|
self.engine: NavigationDemoEngine | None = None
|
|
self.running = False
|
|
self.main_texture_size: tuple[int, int] | None = None
|
|
self.snapshot_texture_size: tuple[int, int] | None = None
|
|
self.main_texture_tag = TEXTURE_MAIN
|
|
self.snapshot_texture_tag = TEXTURE_SNAPSHOT
|
|
self.last_state: DemoFrameState | None = None
|
|
|
|
def start(self) -> None:
|
|
if self.engine is None:
|
|
self.engine = NavigationDemoEngine(self.args)
|
|
dpg.set_value(TEXT_STATUS, f"Sorgente: {self.engine.source_name}")
|
|
self.running = True
|
|
dpg.configure_item(BUTTON_RUN, label="Pausa")
|
|
|
|
def pause(self) -> None:
|
|
self.running = False
|
|
dpg.configure_item(BUTTON_RUN, label="Avvia")
|
|
|
|
def toggle_run(self) -> None:
|
|
if self.running:
|
|
self.pause()
|
|
else:
|
|
self.start()
|
|
|
|
def reset(self) -> None:
|
|
self.pause()
|
|
if self.engine is not None:
|
|
self.engine.close()
|
|
self.engine = NavigationDemoEngine(self.args)
|
|
self.last_state = None
|
|
self.main_texture_size = None
|
|
self.snapshot_texture_size = None
|
|
dpg.set_value(TEXT_COMMANDS, "Nessun comando generato")
|
|
dpg.set_value(TEXT_TRACKS, "Nessuna track")
|
|
dpg.set_value(TEXT_METRICS, "Metriche non disponibili")
|
|
dpg.set_value(TEXT_STATUS, f"Reset completato. Sorgente: {self.engine.source_name}")
|
|
|
|
def step_once(self) -> None:
|
|
if self.engine is None:
|
|
self.engine = NavigationDemoEngine(self.args)
|
|
state = self.engine.step()
|
|
if state is None:
|
|
self.pause()
|
|
dpg.set_value(TEXT_STATUS, self.engine.stop_reason if self.engine else "Stop")
|
|
return
|
|
self.last_state = state
|
|
self._update_ui(state)
|
|
|
|
def tick(self) -> None:
|
|
if self.running:
|
|
self.step_once()
|
|
|
|
def close(self) -> None:
|
|
if self.engine is not None:
|
|
self.engine.close()
|
|
|
|
def _update_ui(self, state: DemoFrameState) -> None:
|
|
self._set_image_texture(
|
|
frame=state.display_frame,
|
|
image_tag=IMAGE_MAIN,
|
|
size_attr="main_texture_size",
|
|
tag_attr="main_texture_tag",
|
|
max_display_width=960,
|
|
)
|
|
if state.snapshot_frame is not None:
|
|
self._set_image_texture(
|
|
frame=nav.resize_preview(state.snapshot_frame, 520),
|
|
image_tag=IMAGE_SNAPSHOT,
|
|
size_attr="snapshot_texture_size",
|
|
tag_attr="snapshot_texture_tag",
|
|
max_display_width=520,
|
|
)
|
|
|
|
assert self.engine is not None
|
|
avg_yolo = self.engine.yolo_total_ms / max(self.engine.yolo_cycles, 1)
|
|
dpg.set_value(
|
|
TEXT_METRICS,
|
|
"\n".join([
|
|
state.fps_text,
|
|
f"YOLO ultimo: {state.yolo_ms:.1f} ms",
|
|
f"YOLO medio: {avg_yolo:.1f} ms",
|
|
self.engine.navigator.motion_text,
|
|
f"Snapshot salvati: {self.engine.navigator.snapshot_counter}",
|
|
f"Output: {Path(self.args.snapshot_output_dir).resolve()}",
|
|
]),
|
|
)
|
|
dpg.set_value(
|
|
TEXT_COMMANDS,
|
|
"\n".join(self.engine.navigator.last_command_lines)
|
|
if self.engine.navigator.last_command_lines
|
|
else "Nessun comando generato",
|
|
)
|
|
dpg.set_value(TEXT_TRACKS, self._format_tracks(state.tracks))
|
|
if state.snapshots:
|
|
dpg.set_value(
|
|
TEXT_STATUS,
|
|
f"Snapshot {state.snapshots[-1].snapshot_id:04d} acquisito "
|
|
f"su {state.snapshots[-1].simulated_position}",
|
|
)
|
|
|
|
def _set_image_texture(
|
|
self,
|
|
frame: np.ndarray,
|
|
image_tag: str,
|
|
size_attr: str,
|
|
tag_attr: str,
|
|
max_display_width: int,
|
|
) -> None:
|
|
h, w = frame.shape[:2]
|
|
rgba = bgr_to_rgba_float(frame)
|
|
display_scale = min(1.0, max_display_width / float(w))
|
|
display_w = max(1, int(w * display_scale))
|
|
display_h = max(1, int(h * display_scale))
|
|
old_size = getattr(self, size_attr)
|
|
if old_size != (w, h):
|
|
old_texture_tag = getattr(self, tag_attr)
|
|
new_texture_tag = dpg.generate_uuid()
|
|
dpg.add_dynamic_texture(
|
|
w,
|
|
h,
|
|
rgba,
|
|
tag=new_texture_tag,
|
|
parent=TEXTURE_REGISTRY,
|
|
)
|
|
dpg.configure_item(
|
|
image_tag,
|
|
texture_tag=new_texture_tag,
|
|
width=display_w,
|
|
height=display_h,
|
|
)
|
|
if dpg.does_item_exist(old_texture_tag):
|
|
dpg.delete_item(old_texture_tag)
|
|
setattr(self, tag_attr, new_texture_tag)
|
|
setattr(self, size_attr, (w, h))
|
|
return
|
|
dpg.configure_item(image_tag, width=display_w, height=display_h)
|
|
dpg.set_value(getattr(self, tag_attr), rgba)
|
|
|
|
@staticmethod
|
|
def _format_tracks(tracks: list[nav.Track]) -> str:
|
|
if not tracks:
|
|
return "Nessuna track"
|
|
lines = []
|
|
for track in tracks[:12]:
|
|
cx, cy = nav.bbox_center(track.bbox)
|
|
lines.append(
|
|
f"#{track.id:03d} {track.state:<11} "
|
|
f"conf={track.confidence:.2f} hits={track.hits:<3} "
|
|
f"missed={track.missed:<2} center=({cx:.0f},{cy:.0f}) "
|
|
f"trend={track.area_trend():+.2f} {track.last_candidate_reason}"
|
|
)
|
|
return "\n".join(lines)
|
|
|
|
|
|
def bgr_to_rgba_float(frame: np.ndarray) -> np.ndarray:
|
|
rgba = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)
|
|
return np.asarray(rgba, dtype=np.float32).ravel() / 255.0
|
|
|
|
|
|
def build_ui(app: NavigationDemoGui) -> None:
|
|
dpg.create_context()
|
|
|
|
with dpg.font_registry():
|
|
default_font = dpg.add_font("C:/Windows/Fonts/segoeui.ttf", 17)
|
|
mono_font = dpg.add_font("C:/Windows/Fonts/consola.ttf", 15)
|
|
|
|
with dpg.texture_registry(show=False, tag=TEXTURE_REGISTRY):
|
|
blank = np.zeros((32, 32, 4), dtype=np.float32).ravel()
|
|
dpg.add_dynamic_texture(32, 32, blank, tag=TEXTURE_MAIN)
|
|
dpg.add_dynamic_texture(32, 32, blank, tag=TEXTURE_SNAPSHOT)
|
|
|
|
with dpg.window(tag="main_window", label="FlyWMS Navigation Demo"):
|
|
with dpg.group(horizontal=True):
|
|
dpg.add_button(label="Avvia", tag=BUTTON_RUN, callback=lambda: app.toggle_run())
|
|
dpg.add_button(label="Step", callback=lambda: app.step_once())
|
|
dpg.add_button(label="Reset", callback=lambda: app.reset())
|
|
dpg.add_text("Pronto", tag=TEXT_STATUS)
|
|
|
|
dpg.add_separator()
|
|
|
|
with dpg.group(horizontal=True):
|
|
with dpg.child_window(width=980, height=-1, border=False):
|
|
dpg.add_image(TEXTURE_MAIN, tag=IMAGE_MAIN)
|
|
|
|
with dpg.child_window(width=560, height=-1, border=False):
|
|
dpg.add_text("Metriche")
|
|
dpg.add_text("Metriche non disponibili", tag=TEXT_METRICS)
|
|
dpg.bind_item_font(TEXT_METRICS, mono_font)
|
|
dpg.add_separator()
|
|
dpg.add_text("Comandi")
|
|
dpg.add_text("Nessun comando generato", tag=TEXT_COMMANDS)
|
|
dpg.bind_item_font(TEXT_COMMANDS, mono_font)
|
|
dpg.add_separator()
|
|
dpg.add_text("Payload OCR")
|
|
dpg.add_image(TEXTURE_SNAPSHOT, tag=IMAGE_SNAPSHOT)
|
|
dpg.add_separator()
|
|
dpg.add_text("Track")
|
|
dpg.add_text("Nessuna track", tag=TEXT_TRACKS)
|
|
dpg.bind_item_font(TEXT_TRACKS, mono_font)
|
|
|
|
dpg.bind_font(default_font)
|
|
dpg.create_viewport(title="FlyWMS Navigation Demo", width=1600, height=980)
|
|
dpg.setup_dearpygui()
|
|
dpg.show_viewport()
|
|
dpg.set_primary_window("main_window", True)
|
|
|
|
|
|
def main() -> int:
|
|
if dpg is None:
|
|
print(
|
|
"DearPyGUI non e' installato. Installa il pacchetto con:\n"
|
|
" python -m pip install dearpygui\n"
|
|
f"Dettaglio import: {DEARPYGUI_IMPORT_ERROR}",
|
|
flush=True,
|
|
)
|
|
return 1
|
|
|
|
args = nav.parse_args()
|
|
args.no_display = True
|
|
app = NavigationDemoGui(args)
|
|
build_ui(app)
|
|
try:
|
|
while dpg.is_dearpygui_running():
|
|
app.tick()
|
|
dpg.render_dearpygui_frame()
|
|
finally:
|
|
app.close()
|
|
dpg.destroy_context()
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|