Programowo generować wideo lub animowany GIF w Pythonie?

Mam serię zdjęć, z których chcę utworzyć film. Idealnie mógłbym określić czas trwania ramki dla każdej ramki, ale stała częstotliwość klatek też byłaby w porządku. Robię to w wxPython, więc mogę renderować do wxDC lub zapisywać obrazy do plików, takich jak PNG. Czy istnieje biblioteka Python, która pozwala mi tworzyć wideo (AVI, MPG itp.) Lub animowany GIF z tych ramek?

Edycja: Próbowałem już PIL i wydaje się, że nie działa. Czy ktoś może mnie poprawić tym wnioskiem lub zasugerować inny zestaw narzędzi? Ten link wydaje się potwierdzać mój wniosek dotyczący PIL: http://www.somethinkodd.com/oddthinking/2005/12/06/python-imaging-library-pil-and-animated-gifs/

Polecam nie używać images2gif z visvis, ponieważ ma problemy z PIL / Pillow i nie jest aktywnie utrzymywany (powinienem wiedzieć, ponieważ jestem autorem).

Zamiast tego skorzystaj z imageio , który został opracowany w celu rozwiązania tego problemu i nie tylko, i który ma pozostać.

Szybkie i brudne rozwiązanie:

import imageio
images = []
for filename in filenames:
    images.append(imageio.imread(filename))
imageio.mimsave('/path/to/movie.gif', images)

W przypadku dłuższych filmów użyj metody strumieniowania:

import imageio
with imageio.get_writer('/path/to/movie.gif', mode='I') as writer:
    for filename in filenames:
        image = imageio.imread(filename)
        writer.append_data(image)

Teraz używam ImageMagick. Zapisuję swoje ramki jako pliki PNG, a następnie wywołuję program.exe.exe z Python ImageMagick, aby utworzyć animowany plik GIF. Zaletą tego podejścia jest to, że mogę określić czas trwania klatki indywidualnie dla każdej klatki. Niestety zależy to od zainstalowania ImageMagick na komputerze. Mają otoki Pythona, ale wygląda to dość kiepsko i nie jest obsługiwane. Nadal otwarte na inne sugestie.

W czerwcu 2009 r. Pierwotnie cytowany post na blogu zawiera metodę tworzenia animowanych plików GIF w komentarzach . Pobierz skrypt images2gif.py (wcześniej images2gif.py , aktualizacja dzięki uprzejmości @geographika).

Następnie, aby odwrócić ramki w gifie, na przykład:

#!/usr/bin/env python

from PIL import Image, ImageSequence
import sys, os
filename = sys.argv[1]
im = Image.open(filename)
original_duration = im.info['duration']
frames = [frame.copy() for frame in ImageSequence.Iterator(im)]    
frames.reverse()

from images2gif import writeGif
writeGif("reverse_" + os.path.basename(filename), frames, duration=original_duration/1000.0, dither=0)

Oto, jak to zrobić, używając tylko PIL (zainstaluj za pomocą :)pip install Pillow :

import glob
from PIL import Image

# filepaths
fp_in = "/path/to/image_*.png"
fp_out = "/path/to/image.gif"

# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif
img, *imgs = [Image.open(f) for f in sorted(glob.glob(fp_in))]
img.save(fp=fp_out, format='GIF', append_images=imgs,
         save_all=True, duration=200, loop=0)

Użyłem images2gif.py, który był łatwy w użyciu. Wydaje się, że podwoił rozmiar pliku ...

26 plików PNG 110 kb, spodziewałem się 26 * 110 kb = 2860 kb, ale my_gif.GIF wynosił 5,7 mb

Również dlatego, że GIF był 8-bitowy, ładne png stały się trochę rozmyte w GIF

Oto kod, którego użyłem:

__author__ = 'Robert'
from images2gif import writeGif
from PIL import Image
import os

file_names = sorted((fn for fn in os.listdir('.') if fn.endswith('.png')))
#['animationframa.png', 'animationframb.png', 'animationframc.png', ...] "

images = [Image.open(fn) for fn in file_names]

print writeGif.__doc__
# writeGif(filename, images, duration=0.1, loops=0, dither=1)
#    Write an animated gif from the specified images.
#    images should be a list of numpy arrays of PIL images.
#    Numpy images of type float should have pixels between 0 and 1.
#    Numpy images of other types are expected to have values between 0 and 255.


#images.extend(reversed(images)) #infinit loop will go backwards and forwards.

filename = "my_gif.GIF"
writeGif(filename, images, duration=0.2)
#54 frames written
#
#Process finished with exit code 0

Oto 3 z 26 ramek:

zmniejszenie zdjęć zmniejszyło rozmiar:

size = (150,150)
for im in images:
    im.thumbnail(size, Image.ANTIALIAS)

Aby utworzyć wideo, możesz użyć opencv ,

#load your frames
frames = ...
#create a video writer
writer = cvCreateVideoWriter(filename, -1, fps, frame_size, is_color=1)
#and write your frames in a loop if you want
cvWriteFrame(writer, frames[i])

Natrafiłem na ten post i żadne z rozwiązań nie zadziałało, więc oto moje rozwiązanie, które działa

Dotychczasowe problemy z innymi rozwiązaniami:
1) Brak jednoznacznego rozwiązania dotyczącego sposobu modyfikacji czasu trwania
2) Brak rozwiązania dla iteracji katalogu poza kolejnością, co jest niezbędne w przypadku plików GIF
3) Brak wyjaśnienia, jak zainstalować imageio dla Pythona 3

zainstaluj imageio w ten sposób: python3 -m pip zainstaluj imageio

Uwaga: musisz upewnić się, że ramki mają indeks w nazwie pliku, aby można je było posortować, w przeciwnym razie nie będziesz w stanie wiedzieć, gdzie zaczyna się lub kończy GIF

import imageio
import os

path = '/Users/myusername/Desktop/Pics/' # on Mac: right click on a folder, hold down option, and click "copy as pathname"

image_folder = os.fsencode(path)

filenames = []

for file in os.listdir(image_folder):
    filename = os.fsdecode(file)
    if filename.endswith( ('.jpeg', '.png', '.gif') ):
        filenames.append(filename)

filenames.sort() # this iteration technique has no built in order, so sort the frames

images = list(map(lambda filename: imageio.imread(filename), filenames))

imageio.mimsave(os.path.join('movie.gif'), images, duration = 0.04) # modify duration as needed

Jak powiedział Warren w zeszłym roku , to stare pytanie. Ponieważ ludzie nadal wydają się przeglądać stronę, chciałbym przekierować ich do bardziej nowoczesnego rozwiązania. Jak powiedział tu Blakev , na github istnieje przykład poduszki .

 import ImageSequence
 import Image
 import gifmaker
 sequence = []

 im = Image.open(....)

 # im is your original image
 frames = [frame.copy() for frame in ImageSequence.Iterator(im)]

 # write GIF animation
 fp = open("out.gif", "wb")
 gifmaker.makedelta(fp, frames)
 fp.close()

Uwaga: ten przykład jest nieaktualny ( gifmakernie jest modułem do importowania, tylko skrypt). Poduszka ma GifImagePlugin (którego źródłem jest GitHub ), ale dokument na ImageSequence wydaje się wskazywać na ograniczone wsparcie (tylko do odczytu)

To nie jest biblioteka Pythona, ale mencoder może to zrobić: Kodowanie z wielu wejściowych plików obrazów . Możesz uruchomić mencoder z Pythona w następujący sposób:

import os

os.system("mencoder ...")

Stare pytanie, wiele dobrych odpowiedzi, ale wciąż może być zainteresowanie inną alternatywą ...

numpngwModuł, który niedawno wystawiony na github ( https://github.com/WarrenWeckesser/numpngw ) można napisać animowanych plików PNG z NumPy tablic. ( Aktualizacja : numpngwjest teraz na pypi: https://pypi.python.org/pypi/numpngw .)

Na przykład ten skrypt:

import numpy as np
import numpngw


img0 = np.zeros((64, 64, 3), dtype=np.uint8)
img0[:32, :32, :] = 255
img1 = np.zeros((64, 64, 3), dtype=np.uint8)
img1[32:, :32, 0] = 255
img2 = np.zeros((64, 64, 3), dtype=np.uint8)
img2[32:, 32:, 1] = 255
img3 = np.zeros((64, 64, 3), dtype=np.uint8)
img3[:32, 32:, 2] = 255
seq = [img0, img1, img2, img3]
for img in seq:
    img[16:-16, 16:-16] = 127
    img[0, :] = 127
    img[-1, :] = 127
    img[:, 0] = 127
    img[:, -1] = 127

numpngw.write_apng('foo.png', seq, delay=250, use_palette=True)

tworzy:

Aby zobaczyć animację, potrzebujesz przeglądarki obsługującej animowany PNG (bezpośrednio lub za pomocą wtyczki).

Jak wspomniał jeden z członków, imageio to świetny sposób na zrobienie tego. imageio pozwala również ustawić liczbę klatek na sekundę, a tak naprawdę napisałem funkcję w Pythonie, która pozwala ci zatrzymać ostatnią klatkę. Używam tej funkcji do animacji naukowych, w których zapętlenie jest przydatne, ale natychmiastowe ponowne uruchomienie nie. Oto link i funkcja:

Jak zrobić GIF za pomocą Pythona

import matplotlib.pyplot as plt
import os
import imageio

def gif_maker(gif_name,png_dir,gif_indx,num_gifs,dpi=90):
    # make png path if it doesn't exist already
    if not os.path.exists(png_dir):
        os.makedirs(png_dir)

    # save each .png for GIF
    # lower dpi gives a smaller, grainier GIF; higher dpi gives larger, clearer GIF
    plt.savefig(png_dir+'frame_'+str(gif_indx)+'_.png',dpi=dpi)
    plt.close('all') # comment this out if you're just updating the x,y data

    if gif_indx==num_gifs-1:
        # sort the .png files based on index used above
        images,image_file_names = [],[]
        for file_name in os.listdir(png_dir):
            if file_name.endswith('.png'):
                image_file_names.append(file_name)       
        sorted_files = sorted(image_file_names, key=lambda y: int(y.split('_')[1]))

        # define some GIF parameters

        frame_length = 0.5 # seconds between frames
        end_pause = 4 # seconds to stay on last frame
        # loop through files, join them to image array, and write to GIF called 'wind_turbine_dist.gif'
        for ii in range(0,len(sorted_files)):       
            file_path = os.path.join(png_dir, sorted_files[ii])
            if ii==len(sorted_files)-1:
                for jj in range(0,int(end_pause/frame_length)):
                    images.append(imageio.imread(file_path))
            else:
                images.append(imageio.imread(file_path))
        # the duration is the time spent on each image (1/duration is frame rate)
        imageio.mimsave(gif_name, images,'GIF',duration=frame_length)

Czy próbowałeś PyMedia ? Nie jestem w 100% pewien, ale wygląda na to, że ten przykład samouczka dotyczy twojego problemu.

W systemie Windows7, python2.7, opencv 3.0, dla mnie działa:

import cv2
import os

vvw           =   cv2.VideoWriter('mymovie.avi',cv2.VideoWriter_fourcc('X','V','I','D'),24,(640,480))
frameslist    =   os.listdir('.\\frames')
howmanyframes =   len(frameslist)
print('Frames count: '+str(howmanyframes)) #just for debugging

for i in range(0,howmanyframes):
    print(i)
    theframe = cv2.imread('.\\frames\\'+frameslist[i])
    vvw.write(theframe)

Najłatwiejszą rzeczą, która sprawia, że ​​to działa, jest wywołanie polecenia powłoki w Pythonie.

Jeśli przechowywane są takie obrazy, jak dummy_image_1.png, dummy_image_2.png ... dummy_image_N.png, możesz użyć funkcji:

import subprocess
def grid2gif(image_str, output_gif):
    str1 = 'convert -delay 100 -loop 1 ' + image_str  + ' ' + output_gif
    subprocess.call(str1, shell=True)

Po prostu wykonaj:

grid2gif("dummy_image*.png", "my_output.gif")

Spowoduje to utworzenie pliku gif my_output.gif.

Zadanie można wykonać, uruchamiając dwuwierszowy skrypt Pythona z tego samego folderu, co sekwencja plików obrazów. W przypadku plików sformatowanych png skrypt to -

from scitools.std import movie
movie('*.png',fps=1,output_file='thisismygif.gif')

Szukałem kodu jednoliniowego i znalazłem następujące elementy do mojej aplikacji. Oto co zrobiłem:

Pierwszy krok: zainstaluj ImageMagick z linku poniżej

https://www.imagemagick.org/script/download.php

Drugi krok: skieruj linię cmd do folderu, w którym znajdują się obrazy (w moim przypadku .png)

Trzeci krok: wpisz następujące polecenie

magick -quality 100 *.png outvideo.mpeg

Dzięki FogleBird za pomysł!

Właśnie wypróbowałem następujące i bardzo się przydałem:

Najpierw pobierz biblioteki Figtodati images2gifdo lokalnego katalogu.

Po drugie Zbierz figurki z tablicy i przekonwertuj je na animowany gif:

import sys
sys.path.insert(0,"/path/to/your/local/directory")
import Figtodat
from images2gif import writeGif
import matplotlib.pyplot as plt
import numpy

figure = plt.figure()
plot   = figure.add_subplot (111)

plot.hold(False)
    # draw a cardinal sine plot
images=[]
y = numpy.random.randn(100,5)
for i in range(y.shape[1]):
    plot.plot (numpy.sin(y[:,i]))  
    plot.set_ylim(-3.0,3)
    plot.text(90,-2.5,str(i))
    im = Figtodat.fig2img(figure)
    images.append(im)

writeGif("images.gif",images,duration=0.3,dither=0)

Natknąłem się na moduł ImageSequence firmy PIL , który oferuje lepszą (i bardziej standardową) animację GIF. Tym razem używam również metody after () Tk , co jest lepsze niż time.sleep () .

from Tkinter import * 
from PIL import Image, ImageTk, ImageSequence

def stop(event):
  global play
  play = False
  exit() 

root = Tk()
root.bind("<Key>", stop) # Press any key to stop
GIFfile = {path_to_your_GIF_file}
im = Image.open(GIFfile); img = ImageTk.PhotoImage(im)
delay = im.info['duration'] # Delay used in the GIF file 
lbl = Label(image=img); lbl.pack() # Create a label where to display images
play = True;
while play:
  for frame in ImageSequence.Iterator(im):
    if not play: break 
    root.after(delay);
    img = ImageTk.PhotoImage(frame)
    lbl.config(image=img); root.update() # Show the new frame/image

root.mainloop()

Prosta funkcja tworząca GIF-y:

import imageio
import pathlib
from datetime import datetime


def make_gif(image_directory: pathlib.Path, frames_per_second: float, **kwargs):
    """
    Makes a .gif which shows many images at a given frame rate.
    All images should be in order (don't know how this works) in the image directory

    Only tested with .png images but may work with others.

    :param image_directory:
    :type image_directory: pathlib.Path
    :param frames_per_second:
    :type frames_per_second: float
    :param kwargs: image_type='png' or other
    :return: nothing
    """
    assert isinstance(image_directory, pathlib.Path), "input must be a pathlib object"
    image_type = kwargs.get('type', 'png')

    timestampStr = datetime.now().strftime("%y%m%d_%H%M%S")
    gif_dir = image_directory.joinpath(timestampStr + "_GIF.gif")

    print('Started making GIF')
    print('Please wait... ')

    images = []
    for file_name in image_directory.glob('*.' + image_type):
        images.append(imageio.imread(image_directory.joinpath(file_name)))
    imageio.mimsave(gif_dir.as_posix(), images, fps=frames_per_second)

    print('Finished making GIF!')
    print('GIF can be found at: ' + gif_dir.as_posix())


def main():
    fps = 2
    png_dir = pathlib.Path('C:/temp/my_images')
    make_gif(png_dir, fps)

if __name__ == "__main__":
    main()

Rozumiem, że pytałeś o konwersję obrazów do gif; jednak jeśli oryginalnym formatem jest MP4, możesz użyć FFmpeg :

ffmpeg -i input.mp4 output.gif

To naprawdę niewiarygodne ... Wszyscy proponują teraz specjalny pakiet do gry w animowany GIF, który można teraz zrobić za pomocą Tkintera i klasycznego modułu PIL!

Oto moja własna metoda animacji GIF (stworzyłem jakiś czas temu). Bardzo prosty:

from Tkinter import * 
from PIL import Image, ImageTk
from time import sleep

def stop(event):
  global play
  play = False
  exit() 

root = Tk()
root.bind("<Key>", stop) # Press any key to stop
GIFfile = {path_to_your_GIF_file}    
im = Image.open(GIFfile); img = ImageTk.PhotoImage(im)
delay = float(im.info['duration'])/1000; # Delay used in the GIF file 
lbl = Label(image=img); lbl.pack() # Create a label where to display images
play = True; frame = 0
while play:
  sleep(delay);
  frame += 1
  try:
    im.seek(frame); img = ImageTk.PhotoImage(im)
    lbl.config(image=img); root.update() # Show the new frame/image
  except EOFError:
    frame = 0 # Restart

root.mainloop()

Możesz ustawić własne środki, aby zatrzymać animację. Daj mi znać, jeśli chcesz uzyskać pełną wersję z przyciskami odtwarzania / pauzy / wyjścia.

Uwaga: Nie jestem pewien, czy kolejne klatki są odczytywane z pamięci czy z pliku (dysku). W drugim przypadku byłoby bardziej wydajne, gdyby wszyscy czytali jednocześnie i zapisywali w tablicy (liście). (Nie jestem tak zainteresowany, aby się dowiedzieć! :)