Alex/python-GPX-traceEtCompteurVitesse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

splitt de vidéo

Browse Source
This commit is contained in:
Alex 2026-09-23 19:01:24 +02:00
parent c81724a7ed
commit f08c599113
3 changed files with 91 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
README.md
View File

@ -27,7 +27,7 @@
- Compteur analogique 0-200 km/h (paramétrable), aiguille et vitesse numérique, placé automatiquement dans le coin le moins encombré par la trace ; l'aiguille part de 0 et y revient sur la première et la dernière seconde.
- Villes traversées obtenues par géocodage inverse [Nominatim](https://nominatim.org/) (OpenStreetMap), affichées sur la carte dès le début, avec placement des étiquettes qui évite chevauchements et trace.
- Option zoom : à l'arrivée du véhicule dans une ville, son nom s'affiche en grand au centre de l'image (moitié de la largeur), avec fondu d'apparition et de disparition.
- Découpage des longs trajets en plusieurs vidéos de même durée de trajet, chacune cadrée sur sa portion et n'affichant que ses villes (évite les noms qui se superposent) ; l'aiguille ne retombe à 0 qu'au vrai début et à la vraie fin du trajet.
- Découpage des longs trajets en plusieurs vidéos (de même durée de trajet ou avec un nombre de villes donné), chacune cadrée sur sa portion et n'affichant que ses villes (évite les noms qui se superposent) ; l'aiguille ne retombe à 0 qu'au vrai début et à la vraie fin du trajet.
- Cache des villes dans `<trace>.villes.json` : les exécutions suivantes n'accèdent plus au réseau.
- Rendu anticrénelé (suréchantillonnage ×2), encodage H.264 `yuv420p` via ffmpeg, sans fichiers intermédiaires.
@ -49,39 +49,61 @@ python gpx_video.py Trajet_16-09-2026_15h38.gpx
Produit `Trajet_16-09-2026_15h38.mp4` à côté du GPX.
| Option | Défaut | Rôle |
| ---------------- | -------------------- | ----------------------------------------------------- |
| `-o`, `--sortie` | nom du GPX en `.mp4` | fichier de sortie |
| `--duree` | `60` | durée de la vidéo, de chaque morceau si découpage (s) |
| `--fps` | `30` | images par seconde |
| `--vmax` | `200` | graduation max du compteur (km/h) |
| `--sans-villes` | — | ne pas géocoder ni afficher les villes |
| `--zoom-villes` | — | nom de la ville en grand quand le véhicule y arrive |
| `--duree-zoom` | `2` | durée d'affichage du nom zoomé (secondes de vidéo) |
| `--morceaux` | — | découpe le trajet en N vidéos de même durée de trajet |
| `--duree-morceau`| — | découpe en morceaux égaux d'au plus N minutes de trajet |
| Option | Défaut | Rôle |
| -------------------------- | -------------------- | ----------------------------------------------------------- |
| `-o`, `--sortie` | nom du GPX en `.mp4` | fichier de sortie |
| `--duree` | `60` | durée de la vidéo, de chaque morceau si découpage (s) |
| `--fps` | `30` | images par seconde |
| `--vmax` | `200` | graduation max du compteur (km/h) |
| `--sans-villes` | — | ne pas géocoder ni afficher les villes |
| `--zoom-villes` | — | nom de la ville en grand quand le véhicule y arrive |
| `--duree-zoom` | `2` | durée d'affichage du nom zoomé (secondes de vidéo) |
| `--morceaux N` | — | découpe le trajet en N vidéos de même durée de trajet |
| `--duree-morceau MIN` | — | découpe en morceaux égaux d'au plus MIN minutes de trajet |
| `--villes-par-morceau [N]` | `20` si N omis | découpe en morceaux d'au plus N villes chacun |
Exemple : `python gpx_video.py trace.gpx -o balade.mp4 --duree 90 --fps 25 --zoom-villes`
Découpage : `python gpx_video.py trace.gpx --morceaux 3` produit `trace_1.mp4`, `trace_2.mp4`, `trace_3.mp4` (avec `-o balade.mp4` : `balade_1.mp4`, ...). `--duree-morceau 120` sur un trajet de 10 h 15 donne 6 morceaux d'environ 1 h 42. Les deux options sont exclusives. Chaque ville est affectée au morceau où le véhicule passe à son étiquette.
Notes :
- Le premier lancement interroge Nominatim (1 requête/s, un point par km de trajet) : compter environ 1 s par km.
- En cas d'erreurs réseau, la vidéo est générée sans villes et le cache n'est pas écrit. Supprimer `<trace>.villes.json` pour forcer un nouveau géocodage.
- Les itinéraires planifiés (ex. export Liberty Rider en `<rte>`) ne contiennent pas d'horodatage et sont refusés : il faut une trace enregistrée.
### Découpage en plusieurs vidéos
Sur un long trajet, la carte entière est trop petite et les noms de villes se superposent. Le trajet peut alors être découpé en plusieurs vidéos, chacune cadrée sur sa portion de trace et n'affichant que les villes de cette portion. Trois modes, exclusifs entre eux :
| Mode | Coupe | Exemple (trajet de 10 h 15, 66 villes) |
| -------------------------- | ---------------------------------------------------------- | ---------------------------------------------- |
| `--morceaux N` | N morceaux de même durée de trajet | `--morceaux 3` → 3 × 3 h 25 |
| `--duree-morceau MIN` | morceaux égaux d'au plus MIN minutes de trajet | `--duree-morceau 120` → 6 × 1 h 42 |
| `--villes-par-morceau [N]` | groupes d'au plus N villes consécutives (20 si N omis) | `--villes-par-morceau` → 4 morceaux de 16-17 villes |
```powershell
python gpx_video.py trace.gpx --villes-par-morceau # 20 villes max par vidéo
python gpx_video.py trace.gpx --villes-par-morceau 10 --zoom-villes
python gpx_video.py trace.gpx --morceaux 3 -o balade.mp4 # balade_1.mp4 … balade_3.mp4
```
- Fichiers produits : `<sortie>_1.mp4`, `<sortie>_2.mp4`… (numéros complétés de zéros au-delà de 9 morceaux). Une seule vidéo, sans suffixe, si le découpage ne donne qu'un morceau.
- `--duree` fixe la durée de **chaque** vidéo : les morceaux d'un même trajet n'ont donc pas la même vitesse de défilement si leurs durées de trajet diffèrent (cas de `--villes-par-morceau`).
- `--villes-par-morceau` équilibre les groupes plutôt que de remplir les premiers : 66 villes avec N = 20 donnent 16, 17, 17 et 16 villes, et non 20, 20, 20 et 6. La coupure se place à mi-temps entre la dernière ville d'un morceau et la première du suivant. Sans villes (`--sans-villes` ou géocodage en échec), ce mode est ignoré avec un avertissement et une seule vidéo est produite.
- Chaque ville est affectée au morceau où le véhicule passe à son étiquette ; une ville à cheval sur une coupure n'apparaît que dans un des deux morceaux.
- L'aiguille ne part de 0 qu'au début du premier morceau et n'y revient qu'à la fin du dernier.
### Traitement par lot (PowerShell)
`gpx_video.ps1` génère une vidéo pour chaque fichier `*.gpx` du **répertoire courant**, avec le Python du venv `.venv` placé à côté du script (créé et équipé de `requirements.txt` automatiquement s'il n'existe pas ; inutile de l'activer).
`gpx_video.ps1` génère les vidéos de chaque fichier `*.gpx` du **répertoire courant**, avec zoom sur les villes (`--zoom-villes`) et découpage en morceaux d'au plus 20 villes (`--villes-par-morceau 20`), avec le Python du venv `.venv` placé à côté du script (créé et équipé de `requirements.txt` automatiquement s'il n'existe pas ; inutile de l'activer).
```powershell
cd D:\Traces\Septembre
& "H:\...\GPX - Compteur de vitesse\gpx_video.ps1"
& "H:\...\GPX - Compteur de vitesse\gpx_video.ps1" --duree 90 --zoom-villes
& "H:\...\GPX - Compteur de vitesse\gpx_video.ps1" --duree 90
& "H:\...\GPX - Compteur de vitesse\gpx_video.ps1" --morceaux 3
```
Les arguments sont transmis tels quels à `gpx_video.py` pour chaque trace (sauf `-o`, qui écraserait la même sortie). Les traces en échec sont listées à la fin et le script retourne le code 1. En cas d'erreur, la fenêtre reste ouverte jusqu'à un appui sur Entrée (utile en double-clic / « Exécuter avec PowerShell ») ; pas de pause avec `-NonInteractive`.
Les arguments sont transmis tels quels à `gpx_video.py` pour chaque trace (sauf `-o`, qui écraserait la même sortie). Une autre option de découpage (`--morceaux`, `--duree-morceau`, `--villes-par-morceau N`) ou `--sans-villes` remplace le découpage par défaut. Les traces en échec sont listées à la fin et le script retourne le code 1. En cas d'erreur, la fenêtre reste ouverte jusqu'à un appui sur Entrée (utile en double-clic / « Exécuter avec PowerShell ») ; pas de pause avec `-NonInteractive`.
Si la politique d'exécution bloque le script : `powershell -ExecutionPolicy Bypass -File gpx_video.ps1`.

23
gpx_video.ps1
View File

@ -5,12 +5,17 @@
.DESCRIPTION
Utilise le venv .venv situé à côté de ce script (il est créé et les
dépendances de requirements.txt installées s'il n'existe pas encore).
Chaque fichier *.gpx du répertoire courant produit une vidéo MP4 du même nom.
Les arguments supplémentaires sont transmis tels quels à gpx_video.py.
Chaque fichier *.gpx du répertoire courant produit une ou plusieurs vidéos
MP4 du même nom : noms des villes zoomés (--zoom-villes) et découpage en
morceaux d'au plus 20 villes (--villes-par-morceau 20).
Les arguments supplémentaires sont transmis tels quels à gpx_video.py ; une
autre option de découpage (--morceaux, --duree-morceau, --villes-par-morceau)
ou --sans-villes remplace le découpage par défaut.
.EXAMPLE
.\gpx_video.ps1
.\gpx_video.ps1 --duree 90 --zoom-villes
.\gpx_video.ps1 --duree 90
.\gpx_video.ps1 --villes-par-morceau 10
#>
$ErrorActionPreference = 'Stop'
@ -40,19 +45,27 @@ try {
throw "Aucun fichier .gpx dans $(Get-Location)."
}
# Options par défaut, placées avant celles de l'utilisateur. Le découpage
# par villes est omis si l'utilisateur en choisit un autre (options
# exclusives) ou désactive les villes.
$defaut = @('--zoom-villes')
$autreDecoupage = @($args | Where-Object {
$_ -match '^--(morceaux|duree-morceau|villes-par-morceau|sans-villes)(=|$)' })
if ($autreDecoupage.Count -eq 0) { $defaut += @('--villes-par-morceau', '20') }
$echecs = @()
$i = 0
foreach ($trace in $traces) {
$i++
Write-Host "[$i/$($traces.Count)] $($trace.Name)" -ForegroundColor Cyan
& $python $script $trace.FullName @args
& $python $script $trace.FullName @defaut @args
if ($LASTEXITCODE -ne 0) { $echecs += $trace.Name }
}
if ($echecs.Count -gt 0) {
throw "Échec pour : $($echecs -join ', ')"
}
Write-Host "Terminé : $($traces.Count) vidéo(s) générée(s)." -ForegroundColor Green
Write-Host "Terminé : $($traces.Count) trace(s) traitée(s)." -ForegroundColor Green
}
catch {
Write-Host "ERREUR : $($_.Exception.Message)" -ForegroundColor Red

49
gpx_video.py
View File

@ -4,12 +4,14 @@ Contenu de la vidéo : trace blanche sur fond noir, cercle blanc figurant le
véhicule, compteur de vitesse analogique à aiguille et noms des villes
traversées (géocodage inverse Nominatim / OpenStreetMap, mis en cache).
Une trace longue peut être découpée en plusieurs vidéos de durée de trajet
identique (--morceaux, --duree-morceau), chacune cadrée sur sa portion.
Une trace longue peut être découpée en plusieurs vidéos, chacune cadrée sur sa
portion : de durée de trajet identique (--morceaux, --duree-morceau) ou avec un
nombre de villes donné (--villes-par-morceau).
Usage :
python gpx_video.py trace.gpx [-o sortie.mp4] [--duree 60] [--fps 30]
[--morceaux N | --duree-morceau MIN]
[--morceaux N | --duree-morceau MIN |
--villes-par-morceau [N]]
"""
import argparse
@ -342,13 +344,22 @@ def rendu_zoom(nom):
return masques[0], masques[1], (TAILLE // 2 - l1 // 2, TAILLE // 2 - h1 // 2)
def nombre_morceaux(args, duree_trace):
"""Nombre de vidéos à produire selon --morceaux ou --duree-morceau."""
def bornes_morceaux(args, duree_trace, t_villes):
"""Temps (s) de début/fin des morceaux, selon l'option de découpage."""
if args.villes_par_morceau:
# Groupes consécutifs de villes (au plus N, tailles équilibrées),
# coupés à mi-temps entre la dernière ville d'un groupe et la suivante.
tv = sorted(t_villes)
nb = max(math.ceil(len(tv) / args.villes_par_morceau), 1)
debuts = [round(k * len(tv) / nb) for k in range(1, nb)]
coupes = [(tv[i - 1] + tv[i]) / 2 for i in debuts]
return np.array([0.0, *coupes, duree_trace])
nb = 1
if args.morceaux:
return args.morceaux
if args.duree_morceau:
return max(math.ceil(duree_trace / 60 / args.duree_morceau), 1)
return 1
nb = args.morceaux
elif args.duree_morceau:
nb = max(math.ceil(duree_trace / 60 / args.duree_morceau), 1)
return np.linspace(0, duree_trace, nb + 1)
def extraire_morceau(lat, lon, t, vitesse, t0, t1):
@ -367,16 +378,20 @@ def generer_video(args):
villes = [] if args.sans_villes else trouver_villes(args.gpx, lat, lon)
sortie = Path(args.sortie or Path(args.gpx).with_suffix(".mp4"))
nb = nombre_morceaux(args, t[-1])
if args.villes_par_morceau and not villes:
print("Attention : aucune ville (géocodage indisponible ou --sans-villes), "
"--villes-par-morceau ignoré : vidéo unique.")
args.villes_par_morceau = None
# Chaque ville va dans le morceau où le véhicule passe à son point d'étiquette.
t_villes = [t[int(np.argmin((lat - la) ** 2 + ((lon - lo) * math.cos(math.radians(la))) ** 2))]
for _, la, lo in villes]
bornes = bornes_morceaux(args, t[-1], t_villes)
nb = len(bornes) - 1
if nb == 1:
rendre_video(lat, lon, t, vitesse, villes, sortie, args)
return
# Découpage en morceaux de même durée de trajet ; chaque ville va dans le
# morceau où le véhicule passe à son point d'étiquette.
t_villes = [t[int(np.argmin((lat - la) ** 2 + ((lon - lo) * math.cos(math.radians(la))) ** 2))]
for _, la, lo in villes]
bornes = np.linspace(0, t[-1], nb + 1)
chiffres = len(str(nb))
for k in range(nb):
t0, t1 = bornes[k], bornes[k + 1]
@ -510,11 +525,15 @@ def main():
help="découper le trajet en N vidéos de même durée de trajet (sortie_1.mp4, ...)")
decoupage.add_argument("--duree-morceau", type=float,
help="découper le trajet en morceaux égaux d'au plus MIN minutes de trajet chacun")
decoupage.add_argument("--villes-par-morceau", type=int, nargs="?", const=20, metavar="N",
help="découper le trajet en morceaux d'au plus N villes chacun (défaut 20)")
args = parser.parse_args()
if args.morceaux is not None and args.morceaux < 1:
parser.error("--morceaux doit être >= 1")
if args.duree_morceau is not None and args.duree_morceau <= 0:
parser.error("--duree-morceau doit être > 0")
if args.villes_par_morceau is not None and args.villes_par_morceau < 1:
parser.error("--villes-par-morceau doit être >= 1")
generer_video(args)