youtube screenshot extractor

Extracteur de captures d'écran YouTube (mais pas seulement pour YouTube !) et rassembleur d'ensembles de données

Aperçu

Ce script Python est un outil polyvalent pour extraire des captures d'écran de haute qualité à partir de vidéos YouTube, de fichiers vidéo locaux ou de toute autre source vidéo à laquelle vous pouvez penser ! Il est particulièrement utile pour préparer des ensembles de données pour des projets d'apprentissage automatique, tels que la formation de Loras ou de points de contrôle, ou simplement pour récupérer l'image parfaite de votre film préféré.

Caractéristiques

• Téléchargez YouTube et d'autres vidéos en utilisant yt-dlp
• Traiter les fichiers vidéo locaux
• Plusieurs méthodes d'extraction de trames :
  • Extraction basée sur des intervalles
  • Extraction de toutes les images
  • Extraction d'images clés
  • Détection de scène
• Évaluation de la qualité des cadres
• Détection de flou
• Suppression automatique des barres noires
• Détection de filigrane de base
• Traitement parallèle pour une exécution plus rapide
• Accélération GPU (si disponible)
• Reprendre les extractions interrompues
• Générer des montages miniatures
• Options de sortie personnalisables (JPG ou PNG)
• Option de journalisation détaillée et d’exécution à sec
• Charger les paramètres à partir d'un fichier de configuration
• Filtres de post-traitement :
  • Gradfun (réduit les bandes de couleur, moins agressif)
  • Déblocage (réduction des artefacts de compression)
  • Deband (réduit les bandes de couleur, plus agressif)

Exigences

• Python3.6+
• FFmpeg (requis pour l'extraction d'images clés et certains filtres de post-traitement)
• Dépendances répertoriées dans requirements.txt
• PyCUDA (facultatif, requis uniquement pour l'accélération GPU. Version minimale : 2022.1)

Installation

1. Clonez ce dépôt :

    git clone https://github.com/EnragedAntelope/youtube-screenshot-extractor.git
   cd youtube-screenshot-extractor
   

2. Installez les dépendances requises :

    pip install -r requirements.txt
   

3. Installez FFmpeg (requis pour l'extraction d'images clés et certains filtres) :

   • Suivez les instructions sur : https://ffmpeg.org/download.html

4. (Facultatif) Installez PyCUDA pour l'accélération GPU :

    pip install pycuda>=2022.1
   

   Remarque : PyCUDA nécessite que CUDA soit installé sur votre système. Pour les instructions d'installation, reportez-vous à la documentation PyCUDA.

Usage

Syntaxe de base :

 python youtube-screenshot-script.py [SOURCE] [OPTIONS]

Où [SOURCE] peut être soit une URL YouTube, soit un chemin d'accès à un fichier vidéo local.

Remarque : Si vous prévoyez d'utiliser l'accélération GPU (option --use-gpu), assurez-vous que PyCUDA est installé.

Exemple de démarrage rapide

Extrayez des images toutes les 5 secondes d'une vidéo YouTube et enregistrez-les dans un dossier personnalisé :

 python youtube-screenshot-script.py https://www.youtube.com/watch?v=dQw4w9WgXcQ --output my_awesome_screenshots

C'est aussi simple que ça ! Passons maintenant à toutes les options configurables.

Possibilités

• --method {interval,all,keyframes,scene} : Méthode d'extraction d'image (par défaut : intervalle)
• --interval INTERVAL : Intervalle entre les images en secondes (par défaut : 5.0, utilisé uniquement avec la méthode 'interval')
• --quality QUALITY : Seuil de qualité pour la sélection des images (0-100, par défaut : 12,0)
• --blur BLUR : Seuil de flou pour la sélection d'image (par défaut : 10.0)
• --detect-watermarks : Activer la détection de filigrane de base
• --watermark-threshold THRESHOLD : Sensibilité de détection du filigrane (0-1, par défaut : 0,8)
• --max-resolution RESOLUTION : Résolution maximale pour le téléchargement de vidéos YouTube (par exemple, 720, 1080). Ignoré pour les fichiers locaux.
• --output OUTPUT : Nom du dossier de sortie personnalisé
• --png : Enregistre les images au format PNG au lieu de JPG
• --disable-parallel : Désactive le traitement parallèle des images
• --use-gpu : Utiliser l'accélération GPU si disponible
• --fast-scene : Utiliser le mode rapide pour la détection de scène (résultats moins précis)
• --resume : Reprendre un processus d'extraction interrompu
• --thumbnail : Générer un montage miniature des images extraites
• --verbose : Activer la journalisation détaillée
• --dry-run : Montre ce qui serait fait sans réellement traiter
• --config CONFIG : Charger les paramètres depuis un fichier de configuration
• --gradfun : appliquez le filtre gradfun pour réduire les bandes de couleur (moins agressif, préserve plus de détails)
• --deblock : Appliquer un filtre de déblocage pour réduire les artefacts de compression
• --deband : appliquez un filtre de débandage pour réduire les bandes de couleur (plus agressif, meilleur pour les bandes sévères)

Exemples

1. Extrayez les images clés d'un fichier vidéo local :

    python youtube-screenshot-script.py path/to/your/video.mp4 --method keyframes
   

2. Utilisez la détection de scène sur une vidéo YouTube avec un dossier de sortie personnalisé :

    python youtube-screenshot-script.py https://www.youtube.com/watch?v=dQw4w9WgXcQ --method scene --output my_scene_shots
   

3. Extrayez les images toutes les 10 secondes avec un seuil de qualité inférieur et une sortie PNG :

    python youtube-screenshot-script.py https://www.youtube.com/watch?v=dQw4w9WgXcQ --interval 10 --quality 30 --png
   

4. Utilisez l'accélération GPU et générez un montage miniature :

    python youtube-screenshot-script.py path/to/your/video.mp4 --use-gpu --thumbnail
   

5. Téléchargez une vidéo YouTube à une résolution maximale de 720p et extrayez les images :

    python youtube-screenshot-script.py https://www.youtube.com/watch?v=dQw4w9WgXcQ --max-resolution 720
   

6. Extrayez les images avec des filtres de post-traitement :

    python youtube-screenshot-script.py path/to/your/video.mp4 --gradfun --deblock --deband
   

À quoi s'attendre

• Temps de traitement :

  • Les méthodes « intervalle » et « images clés » sont généralement les plus rapides.
  • La méthode « toutes » les images peut prendre beaucoup de temps pour les vidéos plus longues.
  • La détection de scène est généralement la méthode la plus longue, en particulier pour les vidéos plus longues.
  • L'accélération GPU peut accélérer considérablement le traitement pour toutes les méthodes.
  • L'utilisation de filtres de post-traitement (gradfun, deblock, deband) augmentera le temps de traitement.

• Résolution vidéo :

  • Lors du téléchargement de vidéos YouTube, le script utilisera par défaut la qualité disponible la plus élevée. Utilisez l'option --max-resolution pour limiter la qualité du téléchargement si nécessaire.
  • Pour les fichiers vidéo locaux, la résolution d'origine est toujours utilisée et l'option --max-resolution est ignorée.

• Sortie : les images sont enregistrées sous forme d'images JPG ou PNG dans le dossier de sortie spécifié (ou un dossier par défaut nommé d'après le titre de la vidéo).

• Noms de fichiers de cadres : suivez le format frame_NNNNNN_qXX_bYY[_watermarked].(jpg|png) , où :

  • NNNNNN : Numéro de trame
  • XX : Score de qualité (0-99, plus c'est élevé, mieux c'est)
  • YY : score de flou (des nombres plus élevés indiquent moins de flou)
  • _watermarked : Suffixe ajouté si un filigrane est détecté

• Filtres de post-traitement :

  • Gradfun est moins agressif et préserve plus de détails, ce qui convient aux problèmes de bandes subtils.
  • Le débandage est plus agressif et meilleur pour les problèmes de bandes graves, en particulier dans les scènes sombres ou les dégradés de ciel.
  • Deblock aide à réduire les artefacts de compression.
  • L'utilisation de filtres augmentera le temps de traitement, en particulier les filtres basés sur FFmpeg (gradfun et deband).

Conseils

• Commencez par la méthode « intervalle » pour des résultats rapides. Utilisez la détection de scène pour les vidéos comportant des changements de scène distincts, mais préparez-vous à des temps de traitement plus longs.
• Utilisez l'option --dry-run pour prévisualiser le processus d'extraction sans réellement enregistrer les images.
• Pour les vidéos volumineuses ou les processus de longue durée :
  • Utilisez l'option --resume au cas où le processus serait interrompu.
  • Pensez à utiliser l'option --max-resolution pour limiter la qualité du téléchargement afin d'accélérer le traitement et d'économiser l'espace de stockage.
    • Remarque : L'option --max-resolution s'applique uniquement lors du téléchargement de vidéos YouTube. Cela n'a aucun effet lors du traitement des fichiers vidéo locaux.
• Pour optimiser la qualité et les performances :
  • Expérimentez avec différents seuils de qualité et de flou pour trouver le meilleur équilibre pour vos besoins. Commencez par des seuils inférieurs (par exemple, --quality 30 --blur 50 ) et ajustez si nécessaire.
  • Si le traitement est trop lent, essayez de désactiver la détection du filigrane ou d'utiliser l'accélération GPU si disponible.
  • Utilisez l'option --fast-scene pour des résultats de détection de scène plus rapides (mais moins précis).
• Lors de l'utilisation de filtres de post-traitement :
  • Sachez que l'application de filtres augmentera le temps de traitement, en particulier les filtres basés sur FFmpeg (gradfun et deband).
  • Choisissez entre gradfun et deband en fonction de vos besoins :
    • Utilisez gradfun pour des problèmes de bandes subtils ou pour conserver plus de détails.
    • Utilisez la suppression de bandes pour les problèmes de bandes plus graves, en particulier dans les scènes sombres ou les dégradés de ciel.
  • Expérimentez avec différentes combinaisons de filtres pour obtenir la qualité de sortie souhaitée.

Dépannage

• Aucune image extraite :

  • Réduisez les seuils de qualité et de flou (par exemple, --quality 20 --blur 30 ).
  • Vérifiez si le fichier vidéo est corrompu ou si yt-dlp n'a pas réussi à le télécharger correctement.

• Problèmes d'extraction d'images clés :

  • Assurez-vous que FFmpeg est correctement installé et accessible dans le PATH de votre système.
  • Essayez de mettre à jour FFmpeg vers la dernière version.

• Détection de scène extrêmement lente ou crash :

  • Utilisez l'option --fast-scene pour des résultats plus rapides mais moins précis.
  • Essayez d'abord de traiter un segment plus court de la vidéo pour tester.
  • Assurez-vous que vous disposez de suffisamment de RAM disponible.

• L'accélération GPU ne fonctionne pas :

  • Vérifiez que vous disposez d'un GPU compatible CUDA et des bibliothèques CUDA nécessaires installées.
  • Vérifiez si PyCUDA est installé correctement ( pip install pycuda ).
  • Si les problèmes persistent, revenez au traitement du processeur en supprimant l'indicateur --use-gpu .

• Détection de filigrane produisant des faux positifs :

  • Ajustez le seuil du filigrane (par exemple, --watermark-threshold 0.9 pour une détection plus stricte).
  • Si cela n'est pas nécessaire, désactivez la détection des filigranes en supprimant l'indicateur --detect-watermarks .

• Le processus s'arrête de manière inattendue pour les vidéos volumineuses :

  • Utilisez l'option --resume pour continuer là où elle s'est arrêtée.
  • Essayez de traiter la vidéo en segments plus petits.
  • Assurez-vous de disposer de suffisamment d'espace disque libre.

• Sortie de mauvaise qualité ou floue :

  • Augmentez les seuils de qualité et de flou.
  • Vérifiez si la vidéo source est de qualité suffisante.

• Les filtres de post-traitement ne fonctionnent pas :

  • Assurez-vous que FFmpeg est installé et accessible dans le PATH de votre système pour les filtres gradfun et deband.
  • Vérifiez si OpenCV (cv2) est correctement installé pour le filtre de déblocage.
  • Si les problèmes persistent avec des filtres spécifiques, essayez de les utiliser individuellement pour isoler le problème.

Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.

Contribuer

Les contributions sont les bienvenues ! N'hésitez pas à soumettre une Pull Request.