(Insect Detect) webapp.py

Aus TippvomTibb
Zur Navigation springen Zur Suche springen

Allgemeines

Dieses Porgramm stellt ueber den Port 5000 (bzw. 8443 SSL) eine Browserzugriffsmoeglichkeit bereit. Es wird ein Videostream und eine Manipulatinsmoeglich der Detectionsparamter bereitsgestellt.

Der Kern des Programmes nutzt NiceGUI (https://github.com/zauberzeug/nicegui).

NiceGUI

Config

Code Analyse

ChatGPT meint:

Ich kann keine Zeilennummern auseinandernehmen, aber anhand von

  • requirements.txt (u. a. nicegui, depthai, PyYAML, ruamel.yaml, psutil, APScheduler, av, nmcli) (GitHub)
  • der Doku („Use the web app to configure your custom settings“) (GitHub)

lässt sich ziemlich gut rekonstruieren, was webapp.py tut und wie es grob aufgebaut ist.


1. Rolle von webapp.py im System

webapp.py ist die Konfigurations- und Steuer-Oberfläche für Insect Detect:

  • Startest du mit

    env_insdet/bin/python3 insect-detect/webapp.py

    läuft ein NiceGUI-Webserver auf dem Pi (HTTP/HTTPS je nach Zertifikaten). (GitHub)

  • Darüber konfigurierst du alle relevanten Parameter, die ansonsten in configs/config_custom.yaml stehen würden (Model, Auflösungen, Trigger-Intervalle, Pfade, Power-Management, Upload etc.). (GitHub)

  • Die Web-App schreibt diese Einstellungen in die YAML-Files und steuert damit indirekt das Verhalten von startup.py und trigger_capture.py.

Kurz gesagt: webapp.py = Frontend zum Bearbeiten der Config + Anzeigen von Systemstatus + Start/Stop / Test-Funktionen.


2. Verwendete Bibliotheken → Hinweis auf Aufbau

Aus requirements.txt erkennt man:

  • nicegui → Framework für das Web-UI (ersetzt Flask/Bokeh).
  • depthai, opencv-python, av → Live-Video-Vorschau von der OAK-Kamera / HQ/LQ-Streams.
  • PyYAML + ruamel.yaml → Lesen/Schreiben der YAML-Configs (config_custom.yaml, config_selector.yaml).
  • pandas → Tabellenhafte Anzeige / Bearbeitung (z. B. Metadaten, Log-/Upload-Listen).
  • psutil → Systeminfos (CPU-Last, Temperatur, Speicher, SSD-Belegung).
  • APScheduler → Timer/Jobs, z. B. periodische Systemchecks, Uploads.
  • nmcli → WLAN-/Netzwerk-Konfiguration über die Web-Oberfläche. (GitHub)

Daraus lässt sich recht eindeutig folgendes Layout ableiten.


3. Typische Struktur von webapp.py (logisch, nicht 1:1 Code)

3.1. Imports & Konstanten

Ganz oben:

  • Imports von nicegui (z. B. from nicegui import app, ui o. ä.)
  • Imports aus utils (z. B. für path-Handling, Kamera-Preview, Power-Management)
  • Pfad-Konstanten:
    • CONFIG_DIR = "configs"
    • CONFIG_CUSTOM = "configs/config_custom.yaml"
    • CONFIG_SELECTOR = "configs/config_selector.yaml"

3.2. Config-Handling (YAML)

Hilfsfunktionen in etwa:

  • load_config() → liest config_custom.yaml mit ruamel.yaml ein
  • save_config(data) → schreibt die aktuelle Konfiguration zurück
  • load_config_selector() / save_config_selector() → welcher Config-Name ist aktiv? (mehrere Profile möglich)

Damit werden die Werte, die du in der Web-App änderst, nachhaltig in die YAML-Dateien geschrieben, sodass startup.py / trigger_capture.py sie beim Booten nutzen. (GitHub)

3.3. NiceGUI-UI: Seiten / Tabs

Typischerweise wird dann ein Layout mit mehreren Tabs/Seiten definiert, z. B.:

  1. Dashboard / Status
    • Anzeige von:
      • aktueller aktiver Config
      • Systemstatus (CPU-Temp, Last, RAM, freier Speicher) via psutil
      • ggf. ob trigger_capture.py läuft (per psutil.process_iter() oder PID-File).
    • Buttons:
      • „Start Aufnahme“ / „Stop Aufnahme“
      • „Starte Live-Vorschau“
  2. Kamera & Modell
    • Auswahl des OAK-Modells (models/…blob)
    • Einstellen von:
      • LQ-Auflösung, FPS
      • HQ-Auflösung
    • evtl. Dropdown, welches YOLO-Blob genutzt wird (v5/v6/v7/v8). (GitHub)
  3. Detection & Trigger-Einstellungen
    • Schieberegler / Eingabefelder für:
      • Konfidenz-Schwelle (confidence_threshold)
      • minimale Box-Fläche / Size (zur Filterung von Rauschen)
      • capture_interval_triggered (wie oft bei Insekten ein HQ-Frame gespeichert wird)
      • capture_interval_timelapse (Time-Lapse ohne Insekten). (GitHub)
  4. Power-Management
    • Aktivierung von WittyPi / PiJuice
    • Grenzen für Batteriestand / Aufnahmezeiten
    • evtl. Anzeige der aktuellen Batterie-Infos.
  5. Upload / Rclone
    • Eingabe von Rclone-Remote-Name, Zielpfad, Upload-Zeiten
    • Schalter „Upload aktivieren“
    • evtl. Log über letzte Uploads.
  6. Netzwerk
    • Oberfläche, die unter der Haube nmcli aufruft:
      • WLANs scannen, verbinden
      • Status anzeigen

All das sind typische Dinge, die du laut Doku „über die Web-App konfigurieren“ kannst, statt in der YAML zu editieren. (GitHub)

3.4. Live-Preview

Mit depthai, opencv und av im Requirements-File ist fast sicher, dass webapp.py auch eine Live-Preview anbietet:

  • Button „Live Preview starten“ → startet einen kleinen Stream von der OAK-Kamera (LQ-Bild), der im Browser angezeigt wird (z. B. als MJPEG oder periodisch aktualisiertes Bild).
  • NiceGUI kann dafür ui.image() oder ein <video>/MJPEG-Element nutzen; im Backend wird ein Generator laufen, der Frames aus depthai liest und encodiert.

Das ist nützlich, um Kameraposition, Schärfe und Belichtung direkt im Feld zu checken.

3.5. Prozess-Steuerung / Scheduler

Mit APScheduler und psutil wird wahrscheinlich folgendes gemacht:

  • Geplante Tasks:

      1. B. nächtlicher Upload per Rclone
    • ggf. täglicher Reboot oder Statistik-Update

  • Start/Stop der Aufnahme:

    • Entweder

      • os.system("env_insdet/bin/python3 insect-detect/trigger_capture.py &")
      • oder subprocess.Popen + PID-Verwaltung.

    • Stop über psutil (process.name() == "trigger_capture.py" etc.) und process.terminate().


4. Typischer Datenfluss

  1. Du öffnest im Browser die IP / das HTTPS der Pi-Kamera.
  2. webapp.py (NiceGUI-Server) rendert die UI.
  3. Wenn du Regler/Felder änderst → der zugehörige Callback schreibt die neuen Werte in config_custom.yaml (und evtl. in config_selector.yaml, wenn du Profile wechselst).
  4. Beim Start von startup.py oder trigger_capture.py wird genau diese YAML geladen und bestimmt:
    • Welches Modell
    • Welche Capture-Intervalle
    • Power/Upload-Verhalten → webapp.py selbst detektiert keine Insekten; es konfiguriert nur alles, was das Recording-Script dann nutzt.


5. Was kannst du praktisch damit tun / anpassen?

Ohne in den Code schauen zu müssen, kannst du dir klar machen:

  • Neuen Parameter hinzufügen (z. B. „Minimale Insekten-Größe“):
    • YAML erweitern
    • trigger_capture.py so ändern, dass es den Parameter nutzt
    • In webapp.py das entsprechende UI-Element ergänzen, das diesen YAML-Key schreibt.
  • Eigenen Button einbauen (z. B. „Jetzt manuell Bild aufnehmen“):
    • In der NiceGUI-Page einen Button definieren, dessen Callback entweder
      • direkt ein Einzelbild von der OAK abholt und speichert
      • oder einen kleinen Hilfs-Script aufruft.

Wenn du lokal Zugriff auf den Code hast, kannst du im Editor einfach nach z. B. "config_custom.yaml" oder "nicegui" suchen – dann siehst du genau, wo diese Logik sitzt.


6. Kurzfassung

  • webapp.py startet eine NiceGUI-basierte Weboberfläche auf dem Pi. (GitHub)
  • Darüber kannst du:
    • Configs bearbeiten (Detection, Kamera, Trigger, Power, Upload, Netzwerk).
    • Systemstatus ansehen (CPU, RAM, Disk, ggf. Akku).
    • Live-Preview der Kamera ansehen.
    • Aufnahme-Script starten/stoppen.
  • Alle Einstellungen landen in den YAML-Configfiles, die von trigger_capture.py und startup.py genutzt werden, d. h. webapp.py steuert das System indirekt über die Configs.
Abgerufen von „https://tippvomtibb.de/wiki/index.php?title=(Insect_Detect)_webapp.py&oldid=4629“