Adriano
9eb5942459
Rotte nuove nel servizio camera: POST /camera/anteprima (JPEG ridotto con nitidezza, saturati e media sul frame pieno), GET/PUT /camera/parametri (esposizione e guadagno con i relativi auto), POST /camera/parametri/salva. I settaggi salvati vengono ricaricati alla prima apertura della camera. GET /acquisizione serve la stessa pagina di /calibrazione. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB
426 lines
20 KiB
Python
426 lines
20 KiB
Python
"""Servizio camera minimo di stazione (TieMeasureFlow, #72).
|
|
|
|
Cosa fa: espone via HTTP l'acquisizione di una camera (vs-camera: GigE/GenTL,
|
|
OpenCV, cartella di immagini) con lo stesso contratto di `vs-gui`, ma solo
|
|
`grab` (copiato da TieVision-Studio, src/visionsuite/gui/server.py):
|
|
GET /camera/sources -> {"sources": [{name, kind, label}]}
|
|
POST /camera/grab json {source, trigger="continuo", timeout_ms=5000,
|
|
grezzo=false} -> PNG
|
|
#84: se la sorgente ha una mappa di distorsione salvata il frame esce
|
|
raddrizzato (header X-Raddrizzato: si|no); "grezzo": true lo dà com'è.
|
|
Errori: 400 parametri, 404 sorgente inesistente, 503 guasto camera, 504 timeout.
|
|
|
|
Calibrazione a scacchiera per sorgente (#83, logica in scripts/calibrazione.py):
|
|
GET /camera/calibration?source=<src> -> 200 {source, px_per_mm, mm_per_px,
|
|
rms_px, n_corners, cols, rows, square_mm, image_width, image_height,
|
|
scale_spread_pct, calibrated_at} | 404 "sorgente non calibrata"
|
|
POST /camera/calibrate multipart: source, square_mm, image (file, opzionale:
|
|
senza, grab GREZZO dalla sorgente), save=false, cols/rows (opzionali).
|
|
#84: SENZA cols/rows = calibrazione densa (default): una foto di
|
|
scacchiera che riempie il campo, griglia trovata da sola, mappa di
|
|
distorsione salvata accanto al JSON (.npz); mm/px e px/mm sono quelli
|
|
dell'immagine RADDRIZZATA. CON cols/rows (angoli interni) = metodo
|
|
planare di prima. Campi: quelli di C1 + overlay_png (b64) + saved +
|
|
metodo ("densa"|"planare"), distorsione (bool) e, per la densa,
|
|
residuo_rms_px, residuo_max_px, copertura_pct;
|
|
422 scacchiera non trovata o parametri invalidi
|
|
DELETE /camera/calibration?source=<src> -> 204 (toglie JSON e mappa)
|
|
GET /calibrazione -> pagina HTML autonoma (offline) per fare tutto a mano
|
|
GET /acquisizione -> stessa pagina (#87)
|
|
Acquisizione (#87): anteprima, esposizione/guadagno, settaggi di default:
|
|
POST /camera/anteprima json {source, grezzo=false, lato_max=1280 (320..4096),
|
|
timeout_ms=5000} -> JPEG ridotto (lato lungo <= lato_max, mai ingrandito).
|
|
Header: X-Raddrizzato si|no, X-Larghezza/X-Altezza (frame PIENO),
|
|
X-Nitidezza (varianza del Laplaciano), X-Saturati-Pct (% pixel >= 250),
|
|
X-Media (livello medio 0-255), tutti sul frame pieno in grigio.
|
|
GET /camera/parametri?source=<src> -> {source, regolabile, parametri:
|
|
{esposizione, esposizione_auto, guadagno, guadagno_auto: dominio}};
|
|
dominio = GenicamSource.dominio (valore, tipo, min/max/passo o scelte).
|
|
Esposizione in us, guadagno in dB. Sorgente senza capacita': regolabile=false.
|
|
PUT /camera/parametri json {source, valori: {nome: valore}} -> come GET.
|
|
Scrive prima gli *_auto, poi esposizione/guadagno (assesta=3).
|
|
400 nome ignoto o corpo errato, 409 non regolabile, 422 camera rifiuta
|
|
POST /camera/parametri/salva json {source} -> {source, salvati, file}
|
|
scrive <config-dir>/settaggi/<nome>-<sha1>.json; alla prima apertura
|
|
della camera nel servizio il file, se c'e', viene ricaricato.
|
|
Il risultato salvato sta in un JSON per sorgente in --config-dir (default
|
|
%ProgramData%/Tielogic/TieMeasureFlow/acquisitore su Windows, ./acquisitore altrove).
|
|
|
|
Serve perche' vs-gui ascolta solo su 127.0.0.1 e il container `client` non lo
|
|
raggiunge; questo servizio permette di scegliere l'host di ascolto.
|
|
|
|
Uso (dalla radice del repo):
|
|
vendor/visionsuite/.venv/bin/python scripts/camera_service.py \
|
|
[--host 127.0.0.1] [--port 8765] [--folder <cartella immagini>] \
|
|
[--config-dir <cartella calibrazioni>]
|
|
--folder abilita la sorgente finta `camera:folder` (loop sulle immagini).
|
|
Da Docker su Linux: --host 172.17.0.1 (gateway di docker0).
|
|
|
|
Dipende da: venv di VisionSuite (`uv sync --all-packages` in vendor/visionsuite):
|
|
vs-camera, fastapi, uvicorn, opencv, python-multipart (rotta /camera/calibrate),
|
|
visionsuite.calibration (vs-core).
|
|
|
|
AVVERTENZA: nessuna autenticazione. Un --host diverso dal loopback espone la
|
|
camera a chiunque raggiunga la porta: solo su rete isolata.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import logging
|
|
import os
|
|
import sys
|
|
import threading
|
|
from contextlib import asynccontextmanager
|
|
from pathlib import Path
|
|
|
|
import cv2
|
|
import numpy as np
|
|
from fastapi import Body, FastAPI, File, Form, HTTPException, UploadFile
|
|
from fastapi.concurrency import run_in_threadpool # #83: il grab bloccante fuori dall'event loop
|
|
from fastapi.responses import HTMLResponse, Response
|
|
|
|
from visionsuite.camera.camera_interface import CameraError, CameraGrabError, CameraStateError
|
|
from visionsuite.camera.sources import SourceNotFound, list_sources, open_source
|
|
|
|
# #83: calibrazione e pagina stanno accanto a questo file (che non e' un pacchetto)
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
import calibrazione # noqa: E402
|
|
from calibrazione_pagina import PAGINA # noqa: E402
|
|
|
|
_TRIGGER = ("continuo",)
|
|
_log = logging.getLogger("camera_service") # #87: errori non bloccanti (settaggi)
|
|
# #87: i quattro parametri regolabili, nell'ordine di presentazione
|
|
_PARAMETRI = ("esposizione", "esposizione_auto", "guadagno", "guadagno_auto")
|
|
# #87: in scrittura prima gli automatismi (un valore manuale con auto acceso viene riscritto)
|
|
_ORDINE_SCRITTURA = ("esposizione_auto", "guadagno_auto", "esposizione", "guadagno")
|
|
|
|
# errori noti di vs-camera (inglese) -> italiano; esatti, poi per prefisso
|
|
_MESSAGGI = {
|
|
"Camera is not open": "La camera non è aperta",
|
|
"Camera is not grabbing": "La camera non sta acquisendo",
|
|
"Grab cancelled (grabbing stopped)": "Acquisizione annullata (acquisizione fermata)",
|
|
"Failed to read frame from RTSP stream": "Lettura del fotogramma dallo stream RTSP non riuscita",
|
|
}
|
|
_PREFISSI = (
|
|
("Failed to open OpenCV device", "Apertura del dispositivo OpenCV non riuscita"),
|
|
("Failed to open RTSP stream", "Apertura dello stream RTSP non riuscita"),
|
|
("Failed to reconnect to RTSP stream", "Riconnessione allo stream RTSP non riuscita"),
|
|
("Failed to read frame after", "Lettura del fotogramma non riuscita dopo"),
|
|
)
|
|
|
|
|
|
def _traduci(messaggio: str) -> str:
|
|
if messaggio in _MESSAGGI:
|
|
return _MESSAGGI[messaggio]
|
|
for inglese, italiano in _PREFISSI:
|
|
if messaggio.startswith(inglese):
|
|
return italiano + messaggio[len(inglese):]
|
|
return messaggio
|
|
|
|
|
|
def _config_dir_default() -> Path:
|
|
"""#83: cartella delle calibrazioni salvate."""
|
|
if os.name == "nt":
|
|
base = os.environ.get("ProgramData") or "C:/ProgramData"
|
|
return Path(base) / "Tielogic" / "TieMeasureFlow" / "acquisitore"
|
|
return Path("acquisitore")
|
|
|
|
|
|
def create_app(folder: Path | str | None = None,
|
|
config_dir: Path | str | None = None) -> FastAPI:
|
|
archivio = calibrazione.Archivio(config_dir if config_dir is not None
|
|
else _config_dir_default()) # #83
|
|
aperte: dict = {}
|
|
lock = threading.Lock() # protegge SOLO i dizionari, mai un'apertura
|
|
lock_sorgenti: dict = {} # nome sorgente -> Lock che serializza apertura e grab
|
|
|
|
def _config() -> dict:
|
|
if folder is None:
|
|
return {}
|
|
return {"folder": {"folder": str(folder), "loop": True}}
|
|
|
|
def _lock_di(nome: str) -> threading.Lock:
|
|
with lock:
|
|
return lock_sorgenti.setdefault(nome, threading.Lock())
|
|
|
|
@asynccontextmanager
|
|
async def _vita(_app):
|
|
yield
|
|
with lock: # alla chiusura rilascia le camere aperte
|
|
sorgenti = list(aperte.values())
|
|
aperte.clear()
|
|
for s in sorgenti:
|
|
try:
|
|
s.close()
|
|
except Exception:
|
|
pass
|
|
|
|
app = FastAPI(title="TMF camera service", lifespan=_vita)
|
|
|
|
@app.get("/camera/sources")
|
|
def camera_sources():
|
|
voci = list_sources(None, cameras=True, config=_config())
|
|
return {"sources": [{"name": v.name, "kind": v.kind, "label": v.label}
|
|
for v in voci if v.kind in ("camera", "virtual")]}
|
|
|
|
def _apri(nome: str):
|
|
"""#87: sorgente aperta (o da aprire); da chiamare SOLO sotto _lock_di(nome)."""
|
|
with lock:
|
|
sorgente = aperte.get(nome)
|
|
if sorgente is None:
|
|
sorgente = open_source(nome, None, config=_config())
|
|
_carica_settaggi(nome, sorgente) # #87: predefiniti salvati, se ci sono
|
|
with lock:
|
|
aperte[nome] = sorgente
|
|
return sorgente
|
|
|
|
def _file_settaggi(nome: str) -> Path:
|
|
# #87: stesso schema di nome della calibrazione, in una sottocartella
|
|
return archivio.cartella / "settaggi" / archivio._file(nome).name
|
|
|
|
def _carica_settaggi(nome: str, sorgente) -> None:
|
|
percorso = _file_settaggi(nome)
|
|
if not percorso.is_file() or not hasattr(sorgente, "carica_settaggi"):
|
|
return
|
|
try:
|
|
sorgente.carica_settaggi(percorso)
|
|
except Exception as e: # noqa: BLE001 - un file rotto non blocca l'apertura
|
|
_log.warning("settaggi di %s non caricati (%s): %s", nome, percorso, e)
|
|
|
|
def _con_sorgente(nome: str, fn):
|
|
"""#87: fn(sorgente) sotto il lock della sorgente; errori camera -> HTTP."""
|
|
try:
|
|
with _lock_di(nome): # solo questa sorgente; le altre non aspettano
|
|
return fn(_apri(nome))
|
|
except SourceNotFound as e:
|
|
raise HTTPException(404, _traduci(str(e)))
|
|
except TimeoutError as e:
|
|
raise HTTPException(504, _traduci(str(e)) or "timeout")
|
|
except (CameraGrabError, CameraError) as e:
|
|
raise HTTPException(503, _traduci(str(e)))
|
|
|
|
def _grab(nome: str, timeout: int):
|
|
"""Un frame dalla sorgente (apre e tiene aperta); errori camera -> HTTP."""
|
|
return _con_sorgente(nome, lambda s: s.grab(timeout)) # #87: corpo in _con_sorgente
|
|
|
|
@app.post("/camera/grab")
|
|
def camera_grab(corpo: dict = Body(default=None)):
|
|
nome = corpo.get("source") if isinstance(corpo, dict) else None
|
|
if not isinstance(nome, str) or not nome.strip():
|
|
raise HTTPException(400, "manca «source»")
|
|
nome = nome.strip()
|
|
trigger = corpo.get("trigger", "continuo")
|
|
if trigger not in _TRIGGER:
|
|
raise HTTPException(400, "«trigger» supportato: solo continuo")
|
|
grezzo = corpo.get("grezzo", False) # #84: true = frame non raddrizzato
|
|
if not isinstance(grezzo, bool):
|
|
raise HTTPException(400, "«grezzo» deve essere true o false")
|
|
timeout = corpo.get("timeout_ms", 5000)
|
|
if isinstance(timeout, bool) or not isinstance(timeout, int) or not 1 <= timeout <= 10000:
|
|
raise HTTPException(400, "«timeout_ms» deve essere un intero fra 1 e 10000")
|
|
frame = _grab(nome, timeout) # #83: corpo estratto in _grab, invariato
|
|
raddrizzato = False
|
|
if not grezzo: # #84: sorgente calibrata (densa) -> frame raddrizzato dalla mappa in cache
|
|
mappa = archivio.leggi_mappa(nome)
|
|
if mappa is not None:
|
|
corretto = calibrazione.raddrizza(frame, mappa)
|
|
if corretto is not None: # None = dimensioni diverse da quelle calibrate
|
|
frame, raddrizzato = corretto, True
|
|
ok, buf = cv2.imencode(".png", frame)
|
|
if not ok:
|
|
raise HTTPException(500, "codifica PNG fallita")
|
|
return Response(buf.tobytes(), media_type="image/png",
|
|
headers={"X-Raddrizzato": "si" if raddrizzato else "no"})
|
|
|
|
# ---- #83: calibrazione a scacchiera per sorgente
|
|
|
|
def _sorgente(valore) -> str:
|
|
if not isinstance(valore, str) or not valore.strip():
|
|
raise HTTPException(400, "manca «source»")
|
|
return valore.strip()
|
|
|
|
@app.get("/camera/calibration")
|
|
def calibrazione_leggi(source: str = ""):
|
|
dati = archivio.leggi(_sorgente(source))
|
|
if dati is None:
|
|
raise HTTPException(404, "sorgente non calibrata")
|
|
return dati
|
|
|
|
@app.delete("/camera/calibration", status_code=204)
|
|
def calibrazione_elimina(source: str = ""):
|
|
archivio.elimina(_sorgente(source))
|
|
return Response(status_code=204)
|
|
|
|
@app.post("/camera/calibrate")
|
|
async def calibrazione_calcola(
|
|
source: str = Form(...),
|
|
square_mm: float = Form(...),
|
|
cols: int | None = Form(None), # #84: opzionali, senza = calibrazione densa
|
|
rows: int | None = Form(None),
|
|
image: UploadFile | None = File(None),
|
|
save: bool = Form(False),
|
|
):
|
|
nome = _sorgente(source)
|
|
contenuto = await image.read() if image is not None else b""
|
|
if contenuto:
|
|
frame = cv2.imdecode(np.frombuffer(contenuto, np.uint8), cv2.IMREAD_UNCHANGED)
|
|
if frame is None:
|
|
raise HTTPException(422, "l'immagine caricata non è leggibile")
|
|
else:
|
|
frame = await run_in_threadpool(_grab, nome, 5000) # come /camera/grab (404/503/504)
|
|
if (cols is None) != (rows is None):
|
|
raise HTTPException(422, "cols e rows vanno indicati insieme (o nessuno dei due)")
|
|
mappa = None
|
|
try:
|
|
if cols is None: # #84: densa, nessuna griglia da dichiarare
|
|
risultato, mappa = await run_in_threadpool(
|
|
calibrazione.calibra_scacchiera_densa, frame, square_mm)
|
|
else: # metodo planare di #83, invariato
|
|
risultato = calibrazione.calibra_scacchiera(frame, cols, rows, square_mm)
|
|
except calibrazione.CalibrazioneError as e:
|
|
raise HTTPException(422, str(e))
|
|
corpo = {"source": nome,
|
|
**{k: v for k, v in risultato.items() if k != "overlay_png"},
|
|
"calibrated_at": calibrazione.ora_iso()}
|
|
if save:
|
|
archivio.salva(nome, corpo, mappa) # #84: la mappa (se densa) va in .npz accanto
|
|
return {**corpo, "overlay_png": risultato["overlay_png"], "saved": bool(save)}
|
|
|
|
# ---- #87: acquisizione (anteprima, parametri, settaggi)
|
|
|
|
def _regolabile(s) -> bool:
|
|
# #87: ha il vocabolario delle capacita' e ne supporta almeno una delle quattro
|
|
if not (hasattr(s, "supporta") and hasattr(s, "dominio")):
|
|
return False
|
|
return any(s.supporta(n) for n in _PARAMETRI)
|
|
|
|
def _parametri(nome: str, s) -> dict:
|
|
"""#87: forma di GET /camera/parametri; da chiamare sotto lock."""
|
|
parametri: dict = {}
|
|
if _regolabile(s):
|
|
for n in _PARAMETRI:
|
|
if not s.supporta(n):
|
|
continue
|
|
try:
|
|
parametri[n] = s.dominio(n)
|
|
except CameraStateError as e: # capacita' dichiarata ma non leggibile: si salta
|
|
_log.warning("dominio di %s su %s non letto: %s", n, nome, e)
|
|
return {"source": nome, "regolabile": bool(parametri), "parametri": parametri}
|
|
|
|
def _grigio8(frame):
|
|
g = frame if frame.ndim == 2 else cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
|
|
if g.dtype == np.uint16: # #87: 16 bit -> 8 bit, per soglia e media coerenti
|
|
g = (g >> 8).astype(np.uint8)
|
|
elif g.dtype != np.uint8:
|
|
g = cv2.convertScaleAbs(g, alpha=255.0 / max(float(g.max()), 1.0))
|
|
return g
|
|
|
|
@app.post("/camera/anteprima")
|
|
def camera_anteprima(corpo: dict = Body(default=None)):
|
|
corpo = corpo if isinstance(corpo, dict) else {}
|
|
nome = _sorgente(corpo.get("source"))
|
|
grezzo = corpo.get("grezzo", False)
|
|
if not isinstance(grezzo, bool):
|
|
raise HTTPException(400, "«grezzo» deve essere true o false")
|
|
lato = corpo.get("lato_max", 1280)
|
|
if isinstance(lato, bool) or not isinstance(lato, int) or not 320 <= lato <= 4096:
|
|
raise HTTPException(400, "«lato_max» deve essere un intero fra 320 e 4096")
|
|
timeout = corpo.get("timeout_ms", 5000)
|
|
if isinstance(timeout, bool) or not isinstance(timeout, int) or not 1 <= timeout <= 10000:
|
|
raise HTTPException(400, "«timeout_ms» deve essere un intero fra 1 e 10000")
|
|
frame = _grab(nome, timeout)
|
|
raddrizzato = False
|
|
if not grezzo: # come /camera/grab
|
|
mappa = archivio.leggi_mappa(nome)
|
|
if mappa is not None:
|
|
corretto = calibrazione.raddrizza(frame, mappa)
|
|
if corretto is not None:
|
|
frame, raddrizzato = corretto, True
|
|
alt, larg = frame.shape[:2]
|
|
grigio = _grigio8(frame) # misure sul frame PIENO, non sul ridotto
|
|
nitidezza = float(cv2.Laplacian(grigio, cv2.CV_64F).var())
|
|
saturati = float((grigio >= 250).mean() * 100.0)
|
|
media = float(grigio.mean())
|
|
if frame.dtype != np.uint8: # il JPEG vuole 8 bit
|
|
frame = grigio
|
|
scala = lato / max(alt, larg)
|
|
if scala < 1.0: # mai ingrandita
|
|
frame = cv2.resize(frame, (max(1, round(larg * scala)), max(1, round(alt * scala))),
|
|
interpolation=cv2.INTER_AREA)
|
|
ok, buf = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
|
|
if not ok:
|
|
raise HTTPException(500, "codifica JPEG fallita")
|
|
return Response(buf.tobytes(), media_type="image/jpeg", headers={
|
|
"X-Raddrizzato": "si" if raddrizzato else "no",
|
|
"X-Larghezza": str(larg), "X-Altezza": str(alt),
|
|
"X-Nitidezza": f"{nitidezza:.1f}", "X-Saturati-Pct": f"{saturati:.2f}",
|
|
"X-Media": f"{media:.1f}"})
|
|
|
|
@app.get("/camera/parametri")
|
|
def parametri_leggi(source: str = ""):
|
|
nome = _sorgente(source)
|
|
return _con_sorgente(nome, lambda s: _parametri(nome, s))
|
|
|
|
@app.put("/camera/parametri")
|
|
def parametri_scrivi(corpo: dict = Body(default=None)):
|
|
corpo = corpo if isinstance(corpo, dict) else {}
|
|
nome = _sorgente(corpo.get("source"))
|
|
valori = corpo.get("valori")
|
|
if not isinstance(valori, dict) or not valori:
|
|
raise HTTPException(400, "manca «valori»")
|
|
for n, v in valori.items():
|
|
if n not in _PARAMETRI:
|
|
raise HTTPException(400, f"parametro non riconosciuto: «{n}»")
|
|
if isinstance(v, bool) or not isinstance(v, (int, float, str)):
|
|
raise HTTPException(400, f"valore non valido per «{n}»")
|
|
|
|
def scrivi(s):
|
|
if not _regolabile(s):
|
|
raise HTTPException(409, "questa sorgente non ha parametri regolabili")
|
|
for n in _ORDINE_SCRITTURA: # prima gli *_auto
|
|
if n in valori:
|
|
try:
|
|
s.scrivi(n, valori[n], assesta=3)
|
|
except CameraStateError as e:
|
|
raise HTTPException(422, _traduci(str(e)))
|
|
return _parametri(nome, s) # valori riletti dalla camera
|
|
|
|
return _con_sorgente(nome, scrivi)
|
|
|
|
@app.post("/camera/parametri/salva")
|
|
def parametri_salva(corpo: dict = Body(default=None)):
|
|
nome = _sorgente(corpo.get("source") if isinstance(corpo, dict) else None)
|
|
|
|
def salva(s):
|
|
if not _regolabile(s) or not hasattr(s, "salva_settaggi"):
|
|
raise HTTPException(409, "questa sorgente non ha parametri regolabili")
|
|
percorso = _file_settaggi(nome)
|
|
percorso.parent.mkdir(parents=True, exist_ok=True)
|
|
s.salva_settaggi(percorso)
|
|
return {"source": nome, "salvati": True, "file": percorso.name}
|
|
|
|
return _con_sorgente(nome, salva)
|
|
|
|
@app.get("/calibrazione", response_class=HTMLResponse)
|
|
@app.get("/acquisizione", response_class=HTMLResponse) # #87: stessa pagina
|
|
def calibrazione_pagina():
|
|
return HTMLResponse(PAGINA)
|
|
|
|
return app
|
|
|
|
|
|
def main() -> None:
|
|
import uvicorn
|
|
p = argparse.ArgumentParser(description="Servizio camera minimo di stazione (#72)")
|
|
p.add_argument("--host", default="127.0.0.1")
|
|
p.add_argument("--port", type=int, default=8765)
|
|
p.add_argument("--folder", default=None, help="cartella immagini per camera:folder")
|
|
p.add_argument("--config-dir", default=None,
|
|
help="cartella delle calibrazioni salvate (default: ProgramData su Windows)") # #83
|
|
a = p.parse_args()
|
|
uvicorn.run(create_app(a.folder, a.config_dir), host=a.host, port=a.port)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|