Discussion :

[Xerator]

Bonjour, je me permets de solliciter votre aide car je suis actuellement en train de réaliser un projet mais malheureusement je bloque sur la fonction qui demande :


" Ecrire et tester la fonction recursive_zoom_mp4(input_prefix: str, i_max: int, output_filename: str, duration: int) qui crée le fichier vidéo final.
Les fichiers images de nom {input_prefix}_{i} pour i allant de 1 à i_max sont supposés exister. Par exemple si l’on se base sur les images baby_1.jpg, baby_2.jpg,…, baby_8.jpg calculées précédemment, il faudra choisir "baby" comme valeur de input_prefix et 8 comme valeur de i_max.

Pour chacune de ces images on calcule un fichier mp4 de durée duration correspondant à un zoom vers son centre. On utilise ensuite la commande ffmpeg pour concaténer les fichiers mp4 obtenus. Le nom du fichier résultat sera output_filename. "

Voici le code que j'ai déjà réaliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import cv2
import numpy as np
import os
 
def linear_range(val1,val2, n):
    pas = (val2-val1)/(n-1)
    L=[]
    for i in range(n):
   	  L.append(int(val1+i*pas))
    return L
 
def rect_morphing(rect_src:tuple, rect_dest:tuple,nb_steps:int):
    L=[]
    a=linear_range(rect_src[0],rect_dest[0],nb_steps)
    b=linear_range(rect_src[1],rect_dest[1],nb_steps)
    c=linear_range(rect_src[2],rect_dest[2],nb_steps)
    d=linear_range(rect_src[3],rect_dest[3],nb_steps)
    for i in range(nb_steps):
   	  tple=(a[i],b[i],c[i],d[i])
   	  L.append(tple)
    return L
 
def make_movie(img: np.ndarray, rect_src: tuple, rect_dest: tuple, output_filename: str, w: int, h: int, fps: int, duration: int):
    nb_image = fps * duration
    nb_pas = nb_image - 1
    rect_intermediaire = rect_morphing(rect_src, rect_dest, nb_pas)
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    video_writer = cv2.VideoWriter(output_filename, fourcc, fps, (w, h))
    for rect in rect_intermediaire:
   	  cropped_img = img[rect[1]:rect[3], rect[0]:rect[2]]
   	  resized_img = cv2.resize(cropped_img, (w, h))
   	  video_writer.write(resized_img)
    video_writer.release()
 
def zoom_x2_mp4(input_filename: str, output_filename: str, duration: int):
    # Chargement de l'image
    im_src = cv2.imread(input_filename)
 
    # Vérification si l'image a été chargée avec succès
    if im_src is None:
        print(f"Erreur: Impossible de charger l'image à partir de '{input_filename}'")
        return
 
    # Obtention des dimensions de l'image
    (h, w) = im_src.shape[:2]
 
    # Calcul des dimensions de la zone centrale zoomée
    w_half, h_half = w // 2, h // 2
 
    # Nombre de frames
    fps = 30
    nb_img = duration * fps
    nb_pas = nb_img - 1
 
    # Calcul des rectangles intermédiaires
    rect_intermediaire = rect_morphing((0, 0, w, h),
                                       (w_half // 2, h_half // 2, w - w_half // 2, h - h_half // 2),
                                       nb_pas)
 
    # Initialisation de l'objet VideoWriter pour écrire la vidéo
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_filename, fourcc, fps, (w, h))
 
    # Boucle sur les rectangles intermédiaires pour créer la vidéo zoomée
    for rect in rect_intermediaire:
        cropped_img = im_src[rect[1]:rect[3], rect[0]:rect[2]]
        resized_img = cv2.resize(cropped_img, (w, h))
        out.write(resized_img)
 
    # Libération de la ressource VideoWriter
    out.release()
 
def recursive_zoom_mp4(input_prefix: str, i_max: int, output_filename: str, duration: int):
    mp4_files = []
    for i in range(1, i_max + 1):
        input_filename = f"{input_prefix}_{i}.jpg"
        output_filename_i = f"{input_prefix}_{i}.mp4"
        zoom_x2_mp4(input_filename, output_filename_i, duration)
        mp4_files.append(output_filename_i)
 
    # Création du fichier de liste pour ffmpeg
    list_filename = "mp4_list.txt"
    with open(list_filename, 'w') as f:
        for mp4_file in mp4_files:
            f.write(f"file '{mp4_file}'\n")
 
    # Concaténation des fichiers mp4 en utilisant la concaténation de FFmpeg
    output_path = os.path.join(output_filename)
    os.system(f'ffmpeg -f concat -safe 0 -i {list_filename} -c copy "{output_path}"')
 
    # Suppression du fichier de liste et des fichiers vidéo temporaires
    os.remove(list_filename)
    for file in mp4_files:
        os.remove(file)

La où je bloque c'est que toute les images sont bien appelé, toutes les sous vidéos sont créer correctement, le fichier texte avec les noms des vidéo est bien créer mais malheureusement la vidéo finale concatener n'est pas créer et de plus j'ai un message d'erreur qui dis :

" Remote server is not conected. Please reinitialize or disconnect he remote interpreter"

Voilà, merci d'avance pour ceux qui m'aideront.

[Sve@r]

Bonjour

Voici le code que j'ai déjà réalisé

Et tu penses qu'on va pouvoir en faire quelque chose ? Tu ne te dis pas en le relisant qu'il manque clairement de tabulations ? Tu es au courant au-moins que les tabulations sont plutôt assez importantes en python...

Sinon pourquoi une fonction qui prend des fichiers et qui les concatène doit-elle être récursive ?

toute les images sont bien appelé sont bien appelé, toutes les sous vidéos sont créer

Tes accords en genre et en nombre ; ainsi que tes participes passés sont tirés aux dés ? L'orthographe est une marque de politesse. Bien écrire pour que les lecteurs lisent aisément sans lagguer à revenir sans cesse au début parce que le sens des mots ne correspond pas au sens général de la phrase.

[Xerator]

Pardon, je vous prie de bien vouloir m'excuser pour mon orthographe.

Dans mon fichier source de mon code, les tabulations sont bien respectées.

Quant au nom du fichier qui contient "récursive", c'est juste par rapport au fait que la vidéo fait un zoom central et que ce zoom est constitué de plusieurs petites vidéos de zoom. En aucun cas, on utilise de la récursivité à proprement parler.

Là où je rencontre des difficultés, c'est lors de l'utilisation de la fonction "ffmpeg". Pouvez-vous m'aider sur celle-ci ?

Merci d'avance.

[papajoker]

bonjour

As-tu testé ton script en console ? cela ressemble à un problème de ton éditeur (un mode debug "distant" ?)

EDIT

C'est à dire ? Comment dois-je m'y prendre ?

Un minimum est de répondre à la question ... fonctionne en console ? C'est quand même le but premier d'un script python : être utilisé sans éditeur !

Ensuite, si oui, le minimum est de retourner le nom de ton usine à gaz d'éditeur mais surtout lire sa documentation et de bien le configurer.

[Xerator]

C'est à dire ? Comment dois-je m'y prendre ?

[Xerator]

D'accord, pardon.

Donc si j'ai bien compris, je dois exécuter mon code dans la console, c'est ça ?

Et personnellement, j'utilise EduPython.