question:Voici un premier script : import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile # Define video file extensions and the output folder video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output' amplitude_peaks = set() def calculate_rms_loudness(audio_segment, rate): """Calculate loudness using Root Mean Square (RMS).""" if audio_segment.ndim == 2: audio_segment = np.mean(audio_segment, axis=1) # Convert to mono by averaging channels if it’s stereo rms = np.sqrt(np.mean(audio_segment**2)) return 20 * np.log10(rms) def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments in the audio data without sorting using RMS loudness.""" segment_loudness = [ calculate_rms_loudness( audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ] loudness_and_segments = [ (segment_loudness[i], i * segment_duration) for i in range(num_segments) # limit to the desired number of segments if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset ] return loudness_and_segments def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Par ordre d’apparition (pas besoin de trier car find_loudest_segments retourne déjà dans cet ordre) named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse de l’apparition named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True) # Renumerotation des segments en préservant l’ordre spécifié par named_segments. named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)] return named_segments def process_video_file(video_path, starting_offset, ending_offset): global amplitude_peaks # Indique que nous allons utiliser l’ensemble global défini en dehors de la fonction unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' # Charge la vidéo et calcule sa durée video_clip = VideoFileClip(video_path) video_duration = video_clip.duration confirmed = False while not confirmed: # Demande la longueur des segments voulue segment_length = float(input("Please enter the desired length for each video segment (sec): ")) if segment_length <= 0: print("Invalid segment length. It must be greater than 0.") continue max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length)) if max_segments <= 0: print("Segment length is too long for the video duration minus offsets.") continue print(f"Maximum number of segments obtainable: {max_segments}") confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ") if confirm == '1': confirmed = True # Après confirmation de la durée de segment, demande pour la loudness peak preference peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): ")) if peak_preference not in [1, 2, 3, 4, 5]: print("Invalid choice. Exiting.") return # Demande la préférence pour l'ordre des segments print("Please choose the order of the segments based on loudness:") print("1) In order of appearance") print("2) In reverse order") print("3) By increasing loudness") print("4) By decreasing loudness") preference = int(input("Enter your choice (1-4): ")) if preference not in [1, 2, 3, 4]: print("Invalid choice. Exiting.") return num_to_extract = int(input("How many segments do you want to extract? ")) # Génère un fichier audio temporaire video_clip.audio.write_audiofile(audio_filename) # Lis le fichier audio pour obtenir le taux d’échantillonnage et les données audio rate, audio_data = wavfile.read(audio_filename) loudness_and_segments = find_loudest_segments( audio_data, rate, num_to_extract, segment_length, video_duration, starting_offset, ending_offset, max_segments ) sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference) if not os.path.exists(output_folder): os.makedirs(output_folder) # Extrayez uniquement le nombre de segments demandé par l’utilisateur for segment_info in sorted_and_named_segments[:num_to_extract]: index = segment_info[0] segment_loudness, segment_start_time = segment_info[1:] segment_end = min(segment_start_time + segment_length, video_duration) actual_segment_length = segment_end - segment_start_time # Calcul du décalage pour le pic de loudness segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)] peak_position = find_peak_amplitude_position(segment_audio_data) # Calculez la position absolue du pic d’amplitude par rapport au début du fichier audio absolute_peak_position = int(segment_start_time * rate) + peak_position # Vérifiez si la position du pic est unique en utilisant l’ensemble global if absolute_peak_position in amplitude_peaks: print(f"Duplicate amplitude peak detected at position {absolute_peak_position}. Skipping segment.") continue # Ignore ce segment car c’est un doublon amplitude_peaks.add(absolute_peak_position) # Ajoutez cette nouvelle position de pic à l’ensemble shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6) start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset)) output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4" output_path = os.path.join(output_folder, output_filename) # Commande ffmpeg command = [ "ffmpeg", "-y", "-ss", str(start_time_adjusted), "-i", video_path, "-t", str(actual_segment_length), "-c:v", "libx264", "-c:a", "aac", "-strict", "experimental", output_path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}") continue print(f"Extracted segment {index} to {output_path}") # Supprime le fichier audio temporaire si nécessaire if os.path.exists(audio_filename): os.unlink(audio_filename) # Main if __name__ == "__main__": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): ")) for root, dirs, files in os.walk('.'): root_abs_path = os.path.abspath(root) # Obtenez le chemin absolu du répertoire courant for file in files: # Ignore les fichiers qui sont déjà des segments dans le répertoire Output if root_abs_path == output_abs_path and file.startswith("segment"): continue if any(file.lower().endswith(ext) for ext in video_extensions): video_path = os.path.join(root, file) print(f"Processing video {video_path}…") process_video_file(video_path, starting_offset, ending_offset) print("All videos have been processed.")

question:Voici un deuxième script : import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random temporary_audio_files = [] global detection_threshold # Initialisation du seuil de détection detection_threshold = 1 # La valeur de départ est 1/10ème # Define video file extensions and the output folder video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output' def update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0 def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini") def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.") def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini") def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != ''] # Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.") def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée" print("nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter") def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.") def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1' def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.") def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.") def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.") def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon def calculate_loudness(audio_data): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_values def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0 def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename) # Convert to mono if stereo if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calculate RMS values for the entire audio rms_values = calculate_loudness(audio_data) # Initialize lists for saving moments and their loudness moments = [] volumes = [] # Calculate RMS values for each segment segment_samples = int(segment_duration * rate) for i in range(0, len(audio_data), segment_samples): segment_rms = np.sqrt(np.mean(audio_data[i:i+segment_samples].astype('float32')**2)) if (i / rate + segment_duration <= video_duration - ending_offset) and (i/ rate >= starting_offset): moments.append(i / rate) # Convert sample index to time in seconds volumes.append(segment_rms) # Now moments has RMS value for each segment # If we need to sort segments by volume if len(moments) > 0 and len(volumes) > 0: # Continuous indices mapping to the moments array indices = range(len(moments)) # Sort indices based on corresponding volumes sorted_indices = sorted(indices, key=lambda i: volumes[i], reverse=True) # Sort in descending order of volume # Now we have indices of moments sorted by volume # Reconstruct moments and volumes arrays based on sorted indices sorted_moments = [moments[i] for i in sorted_indices] sorted_volumes = [volumes[i] for i in sorted_indices] return sorted_moments[:num_moments], sorted_volumes[:num_moments] else: return [], [] def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments # Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference) selected_moments = sorted_moments volumes = sorted_volumes finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'") def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2 for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}") def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume }) def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes) # Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes) def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.") def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold # Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.") if __name__ == "__main__": main()

question:Le script 1 et le script 2 identifients-ils les moments forts de la même façon ?

question:Comment le seuil doit être réglé dans le script 2, pour identifier les moments forts comme dans le script 1 ?