Files

314 lines
17 KiB
Python
Raw Permalink Normal View History

"""Inventaire d'un dossier de station : ce qui est disponible, ce qui manque.
Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fin T] [--fichiers]
Les comptes portent sur toute la période. Avec --debut et/ou --fin, une section de plus liste, sur cette fenêtre,
les pas absents (datés, avec les capteurs qui n'ont pas de mesure) et, par capteur, les mesures rejetées (datées,
en suites de pas consécutifs ; rejetée : error_value au-dessus du seuil, références comprises), puis le nombre de
références retenues par la compensation (inlier = 1 ; inlier vide sur la fenêtre : reproj_err rempli) à chaque instant
et, datées, les suites d'instants où des références ne le sont pas (lesquelles, et pourquoi : rejetée, valeur d'inlier,
vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure
sans pose (pas de recalage), sur toute la période puis sur la fenêtre. Avant les comptes, ce que contient chaque source
(sur la fenêtre, sinon toute la période) : les colonnes de l'export, de la pose et de quality/, remplies ou vides (avec,
pour une colonne de l'export que tous les capteurs ne portent pas, combien la portent), les noms des métriques système
de metrics/, les images et les images différentielles. Les relevés en double (même capteur, même instant dans deux
exports, ou deux fois dans un) sont comptés par export. Images : par suite d'écarts égaux entre deux images (à 5 min
près ; sur la fenêtre si elle est donnée). Une suite datée qui finit le même jour n'écrit que l'heure de sa fin.
Rend des valeurs, pas de verdict.
"""
import argparse
import collections
import csv
import glob
import os
import re
import statistics
from datetime import datetime, timedelta, timezone
from donnees import charger, charger_camera, est_reference, filtrer, heure_image, instant, iso, rejetee, trouver
from resume import QUALITE
METRIQUE_RE = re.compile(r"^(.+?)_(\d{4})_(\d{2})_(\d{2})_\d{2}_\d{2}") # NIEDERHORN_BusCurrent_2026_09_22_00_00 to ….csv
def suite(a, b, n):
"""Une suite datée : le début en entier, la fin sans la date quand elle tombe le même jour."""
if n == 1:
return iso(a)
return f"{iso(a)} → {iso(b)[11:] if iso(a)[:10] == iso(b)[:10] else iso(b)} ({n})"
def doubles(chemins):
"""Relevés (même capteur, même instant) déjà lus dans un export précédent ou plus haut dans le même : charger n'en
garde qu'un, celui du dernier fichier dans l'ordre des noms. Une ligne par export qui en a."""
vus, lignes = {}, []
for p in chemins:
n = deja = autres = 0
with open(p, newline="") as fh:
for r in csv.DictReader(fh):
n += 1
cle = (r["sensor_name"].strip(), r["time_utc"])
val = tuple(v.strip() for k, v in r.items() if k not in ("sensor_name", None))
if cle in vus:
deja += 1
autres += vus[cle] != val
vus[cle] = val
if deja:
lignes.append(f" {os.path.basename(p)} : {deja} sur {n} déjà lus, dont {autres} de valeurs différentes")
if lignes:
print("Relevés en double (même capteur, même instant dans un export déjà lu, dans l'ordre des noms ; "
"les outils gardent celui du dernier fichier) :")
print("\n".join(lignes))
def liste(chemins, tout):
"""Un dossier de pompage compte des centaines de fichiers : au-delà de 5, le premier et le dernier seulement."""
if tout or len(chemins) <= 5:
shown = chemins
else:
shown = [chemins[0], chemins[-1]]
print(f" {len(chemins)} fichiers, du premier au dernier (--fichiers pour la liste complète) :")
for p in shown:
print(f" {p}")
def fichiers(f, tout=False):
print(f"Exports « advanced » (source des mesures) : {len(f['advanced'])}")
liste(f["advanced"], tout)
doubles(f["advanced"])
print(f"Exports horaires : {len(f['horaire'])} (non lus par les outils : moyennes horaires, "
"heure locale sans fuseau ; voir labeling/connaissances/colonnes-des-deplacements.md)")
liste(f["horaire"], tout)
print(f"Mouvements de la caméra (pose à chaque recalage) : {len(f['camera'])}")
liste(f["camera"], tout)
print(f"Autres fichiers : {len(f['autres'])}")
liste(f["autres"], tout)
def remplies(chemins, debut, fin):
"""CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}, {colonne: capteurs qui en ont une}),
colonnes dans l'ordre des en-têtes ; capteurs : sensor_name, s'il y en a."""
lignes, compte, qui = 0, {}, collections.defaultdict(set)
for p in chemins:
with open(p, newline="") as fh:
r = csv.DictReader(fh)
for c in r.fieldnames or []:
if c not in ("", "time_utc", "sensor_name"):
compte.setdefault(c, 0)
for row in r:
if (debut or fin) and filtrer([{"t": instant(row["time_utc"])}], debut, fin) == []:
continue
lignes += 1
for c in compte:
if (row.get(c) or "").strip():
compte[c] += 1
if row.get("sensor_name"):
qui[c].add(row["sensor_name"].strip())
return lignes, compte, qui
def contenu(dossier, f, debut=None, fin=None):
"""Ce que contient chaque source sur la fenêtre : ses colonnes, remplies ou vides, et les noms des métriques.
Des noms et des comptes, jamais de valeurs (metrics/ porte des identifiants : SIM_CCID, ip_*)."""
quoi = "sur la fenêtre" if debut or fin else "sur toute la période"
print(f"\nCe que contiennent les données, {quoi} (par colonne, les lignes qui ont une valeur ; « vide » : aucune) :")
autres = collections.defaultdict(list)
for p in f["autres"]:
autres[os.path.relpath(p, dossier).split(os.sep)[0]].append(p)
for titre, chemins in (("Export « advanced »", f["advanced"]), ("Pose de la caméra (camera/)", f["camera"]),
("Qualité d'image (quality/)", autres.pop("quality", []))):
if chemins:
n, compte, qui = remplies(chemins, debut, fin)
tous = set().union(*qui.values())
def porte(c): # nombre de capteurs qui portent la colonne, quand ce ne sont pas tous
return f" ({len(qui[c])} capteurs sur {len(tous)})" if tous and len(qui[c]) < len(tous) else ""
print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}{porte(c)}" if k else f"{c} vide" for c, k in compte.items()))
if chemins is f["advanced"]:
q = [c for c in QUALITE if compte.get(c)]
print(f" Qualité d'image de l'export (peak à snr) : " + (f"remplie ({', '.join(q)}) ; lue par qualite.py, "
"labeling/connaissances/metriques-de-qualite.md" if q else "vide"))
jours = collections.Counter() # métrique -> jours (un CSV par métrique et par jour) dans la fenêtre
for p in autres.pop("metrics", []):
m = METRIQUE_RE.match(os.path.basename(p))
if not m:
continue
jour = datetime(*map(int, m.group(2, 3, 4)), tzinfo=timezone.utc)
if (debut is None or jour.date() >= debut.date()) and (fin is None or jour.date() <= fin.date()):
nom = m.group(1)
jours[nom.split("_", 1)[1] if "_" in nom else nom] += 1
if jours:
print(f" Métriques système (metrics/, un CSV par métrique et par jour ; lues par metriques.py) : {len(jours)} : "
+ ", ".join(f"{k} ({n} j)" for k, n in sorted(jours.items())))
for titre, chemins in (("Images de la caméra", f["images"]),
("Images différentielles (images_diff/ ; aucun outil ne les lit)", glob.glob(os.path.join(dossier, "images_diff", "*")))):
heures = [h for h in map(heure_image, chemins) if h and filtrer([{"t": h}], debut, fin)]
if chemins:
print(f" {titre} : {len(heures)}")
if autres:
print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items())))
def images(chemins, debut=None, fin=None):
heures = sorted(h for h in map(heure_image, chemins) if h)
print(f"Images : {len(chemins)}" + (f", du {iso(heures[0])} au {iso(heures[-1])}" if heures else ""))
inconnues = [p for p in chemins if heure_image(p) is None]
if inconnues:
print(f" noms sans heure reconnue : {len(inconnues)}")
heures = [h for h in heures if filtrer([{"t": h}], debut, fin)]
if len(heures) < 2:
return
# Suites d'images à écart régulier (arrondi à 5 min, ce qui absorbe les quelques secondes de retard d'une prise) :
# une ligne par changement d'écart, sans rien perdre des heures couvertes.
suites = [] # [première, dernière, écart en min, nombre d'écarts]
for a, b in zip(heures, heures[1:]):
e = round((b - a).total_seconds() / 300) * 5
if suites and suites[-1][2] == e:
suites[-1][1], suites[-1][3] = b, suites[-1][3] + 1
else:
suites.append([a, b, e, 1])
quoi = "sur la fenêtre" if debut or fin else "entre la première et la dernière"
print(f" écart entre deux images {quoi}, par suite d'écarts égaux (à 5 min près) :")
for a, b, e, n in suites:
print(f" {iso(a)} → {iso(b)} : " + (f"{n + 1} images, toutes les {e} min" if n > 1 else f"un écart de {e} min"))
def mesures(par):
if not par:
print("\nAucune mesure : pas d'export « advanced » dans ce dossier.")
return
instants = sorted({m["t"] for ms in par.values() for m in ms})
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
print(f"\nPériode des mesures : {iso(instants[0])} → {iso(instants[-1])}, {len(instants)} instants")
print(f"Cadence (pas médian) : {cadence.total_seconds() / 60:.0f} min")
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(instants, instants[1:])]
trous = [x for x in trous if x[2] > 0]
print(f"Mesures manquantes (instants absents de la cadence) : {sum(n for *_, n in trous)}")
for a, b, n in trous:
print(f" entre {iso(a)} et {iso(b)} : {n}")
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
refs = [s for s in noms if est_reference(par[s])]
print(f"\nCapteurs : {len(par)} ({len(refs)} références, {len(par) - len(refs)} cibles)")
vides = [s for s in noms if not any(m["pattern_type"] for m in par[s])]
if vides:
print(f" pattern_type vide pour {len(vides)} capteurs : référence quand reproj_err ou inlier est rempli "
"(références seulement, labeling/connaissances/colonnes-des-deplacements.md)")
print(f"{'capteur':10} {'type':10} {'motif':11} {'seuil':>5} {'mesures':>7} {'rejetées':>8}")
for s in noms:
ms = par[s]
seuil = "/".join(f"{x:g}" for x in sorted({m['error_threshold'] for m in ms}))
print(f"{s:10} {'référence' if est_reference(ms) else 'cible':10} {ms[0]['pattern_type']:11} "
f"{seuil:>5} {len(ms):7} {sum(map(rejetee, ms)):8}")
def camera(dossier, par, debut=None, fin=None):
"""Poses de la caméra, et les instants de mesure sans pose (la caméra n'a pas été recalée)."""
poses = filtrer(charger_camera(dossier), debut, fin)
instants = sorted({m["t"] for ms in par.values() for m in filtrer(ms, debut, fin)})
quoi = "dans la fenêtre" if debut or fin else "sur toute la période"
if not poses:
print(f"\nPose de la caméra {quoi} : aucune")
return
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
print(f"\nPose de la caméra {quoi} : {len(poses)} recalages, {iso(poses[0]['t'])} → {iso(poses[-1]['t'])}")
suites = [] # [début, fin, nombre, rang] des instants de mesure consécutifs sans pose
for i, t in enumerate(instants):
if t.replace(second=0, microsecond=0) in avec:
continue
if suites and suites[-1][3] == i - 1:
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
else:
suites.append([t, t, 1, i])
print(f"Instants de mesure sans pose (pas de recalage) : {sum(x[2] for x in suites)} sur {len(instants)}")
if debut or fin:
for a, b, n, _ in suites:
print(f" {suite(a, b, n)}")
def fenetre(par, debut, fin):
"""Pas absents et rejets datés sur la fenêtre debut/fin."""
instants = sorted({m["t"] for ms in par.values() for m in ms})
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
series = {s: {m["t"]: m for m in filtrer(ms, debut, fin)} for s, ms in par.items()}
dans = sorted({t for d in series.values() for t in d})
print(f"\nFenêtre {iso(dans[0])} → {iso(dans[-1])} : {len(dans)} instants présents")
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
print(f"Pas absents pour tous les capteurs, entre deux instants présents (cadence de {cadence.total_seconds() / 60:.0f} min) :")
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(dans, dans[1:])]
trous = [x for x in trous if x[2] > 0]
for a, b, n in trous:
print(f" entre {iso(a)} et {iso(b)} : {n}")
if not trous:
print(" (aucun)")
print("Instants présents où des capteurs n'ont pas de mesure :")
partiels = [(t, [s for s in noms if t not in series[s]]) for t in dans]
for t, manque in partiels:
if manque:
print(f" {iso(t)} : {len(manque)} capteurs : {','.join(manque)}")
if not any(m for _, m in partiels):
print(" (aucun)")
print("Mesures rejetées dans la fenêtre, par capteur (début → fin de chaque suite de pas consécutifs, nombre) :")
for s in noms:
rej = [t for t in sorted(series[s]) if rejetee(series[s][t])]
suites = []
for t in rej:
if suites and t - suites[-1][1] <= cadence * 1.5:
suites[-1][1], suites[-1][2] = t, suites[-1][2] + 1
else:
suites.append([t, t, 1])
if rej:
print(f" {s} ({len(rej)}) : " + "; ".join(suite(a, b, n) for a, b, n in suites))
if not any(rejetee(m) for d in series.values() for m in d.values()):
print(" (aucune)")
refs = [s for s in noms if est_reference(par[s])]
# inlier dit quelles références la compensation retient ; certains exports ne le remplissent pas (et parfois
# reproj_err seulement) : on prend alors reproj_err rempli, et le titre le dit.
col = next((c for c in ("inlier", "reproj_err") if any(m[c] is not None for s in refs for m in series[s].values())), None)
if col is None:
print("Références retenues par la compensation : colonnes inlier et reproj_err absentes ou vides.")
return
retenue = (lambda m: m["inlier"] == 1) if col == "inlier" else (lambda m: m["reproj_err"] is not None)
def marque(s, t):
m = series[s].get(t)
return "absente" if m is None else "r" if rejetee(m) else "vide" if m[col] is None else f"{m[col]:g}"
hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or not retenue(series[s][t]))) for t in dans]
compte = collections.Counter(len(refs) - len(h) for _, h in hors)
quoi = "inlier = 1" if col == "inlier" else "inlier vide sur la fenêtre : reproj_err rempli à la place"
print(f"Références retenues par la compensation ({quoi}) sur {len(refs)}, nombre d'instants : "
+ ", ".join(f"{k} : {compte[k]}" for k in sorted(compte, reverse=True)))
print("Instants où des références ne sont pas retenues (suites de pas consécutifs avec les mêmes références hors ; "
f"r = rejetée, vide = {col} vide, sinon la valeur d'inlier) :")
suites = []
for i, (t, h) in enumerate(hors):
if h and suites and suites[-1][3] == h and suites[-1][4] == i - 1:
suites[-1][1], suites[-1][2], suites[-1][4] = t, suites[-1][2] + 1, i
elif h:
suites.append([t, t, 1, h, i])
for a, b, n, h, _ in suites:
print(f" {suite(a, b, n)} : {len(refs) - len(h)} retenues ; hors : "
+ ", ".join(f"{s} ({q})" for s, q in h))
if not suites:
print(" (aucun)")
def main(dossier, debut=None, fin=None, tout=False):
print(f"Dossier : {dossier}")
f = trouver(dossier)
fichiers(f, tout)
contenu(dossier, f, debut, fin)
images(f["images"], debut, fin)
par = charger(dossier)
mesures(par)
if par:
camera(dossier, par)
if par and (debut or fin):
fenetre(par, debut, fin)
camera(dossier, par, debut, fin)
if __name__ == "__main__":
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--fichiers", action="store_true", help="liste complète des fichiers (sinon : le premier et le dernier au-delà de 5)")
o = a.parse_args()
main(o.dossier, o.debut, o.fin, o.fichiers)