splitt de vidéo

README.md

@@ -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.
 
@@ -50,7 +50,7 @@ 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                                          |
@@ -58,30 +58,52 @@ Produit `Trajet_16-09-2026_15h38.mp4` à côté du GPX.
 | `--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 |
+| `--morceaux N`             | —                    | 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 |
+| `--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`.
 

gpx_video.ps1

@@ -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.
+    Chaque fichier *.gpx du répertoire courant produit une ou plusieurs vidéos
-    Les arguments supplémentaires sont transmis tels quels à gpx_video.py.
+    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

gpx_video.py

@@ -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
+Une trace longue peut être découpée en plusieurs vidéos, chacune cadrée sur sa
-identique (--morceaux, --duree-morceau), chacune cadrée sur sa portion.
+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):
+def bornes_morceaux(args, duree_trace, t_villes):
-    """Nombre de vidéos à produire selon --morceaux ou --duree-morceau."""
+    """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
+        nb = args.morceaux
-    if args.duree_morceau:
+    elif args.duree_morceau:
-        return max(math.ceil(duree_trace / 60 / args.duree_morceau), 1)
+        nb = max(math.ceil(duree_trace / 60 / args.duree_morceau), 1)
-    return 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)