Programmatically generate video or animated GIF in Python?

I'd recommend not using images2gif from visvis because it has problems with PIL/Pillow and is not actively maintained (I should know, because I am the author).

Instead, please use imageio, which was developed to solve this problem and more, and is intended to stay.

Quick and dirty solution:

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

For longer movies, use the streaming approach:

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) 

To edit each frame duration, you can use kwarg duration (in milliseconds) or fps. Those kwargs can be used both for mimsave() and get_writer().

Here's how you do it using only PIL (install with: pip install Pillow):

import glob import contextlib from PIL import Image # filepaths fp_in = "/path/to/image_*.png" fp_out = "/path/to/image.gif" # use exit stack to automatically close opened images with contextlib.ExitStack() as stack: # lazily load images imgs = (stack.enter_context(Image.open(f)) for f in sorted(glob.glob(fp_in))) # extract first image from iterator img = next(imgs) # https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif img.save(fp=fp_out, format='GIF', append_images=imgs, save_all=True, duration=200, loop=0) 

See docs: https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif

As of June 2009 the originally cited blog post has a method to create animated GIFs in the comments. Download the script images2gif.py (formerly images2gif.py, update courtesy of @geographika).

Then, to reverse the frames in a gif, for instance:

#!/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) 

I used images2gif.py which was easy to use. It did seem to double the file size though..

26 110kb PNG files, I expected 26*110kb = 2860kb, but my_gif.GIF was 5.7mb

Also because the GIF was 8bit, the nice png's became a little fuzzy in the GIF

Here is the code I used:

__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 

Here are 3 of the 26 frames:

shrinking the images reduced the size:

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

To create a video, you could use 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]) 

I came across this post and none of the solutions worked, so here is my solution that does work

Problems with other solutions thus far:
1) No explicit solution as to how the duration is modified
2) No solution for the out of order directory iteration, which is essential for GIFs
3) No explanation of how to install imageio for python 3

install imageio like this: python3 -m pip install imageio

Note: you'll want to make sure your frames have some sort of index in the filename so they can be sorted, otherwise you'll have no way of knowing where the GIF starts or ends

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 

from PIL import Image import glob #use it if you want to read all of the certain file type in the directory imgs=[] for i in range(596,691): imgs.append("snap"+str(i)+'.png') print("scanned the image identified with",i) 

starting and ending value+1 of the index that identifies different file names

imgs = glob.glob("*.png") #do this if you want to read all files ending with .png 

my files were: snap596.png, snap597.png ...... snap690.png

frames = [] for i in imgs: new_frame = Image.open(i) frames.append(new_frame) 

Save into a GIF file that loops forever

frames[0].save('fire3_PIL.gif', format='GIF', append_images=frames[1:], save_all=True, duration=300, loop=0) 

I found flickering issue with imageio and this method fixed it.

Installation

pip install imageio-ffmpeg pip install imageio 

Code

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

Quality is raised and size is reduced from 8Mb to 80Kb when saving as mp4 than gif

Like Warren said last year, this is an old question. Since people still seem to be viewing the page, I'd like to redirect them to a more modern solution. Like blakev said here, there is a Pillow example on github.

 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() 

Note: This example is outdated (gifmaker is not an importable module, only a script). Pillow has a GifImagePlugin (whose source is on GitHub), but the doc on ImageSequence seems to indicate limited support (reading only)

Old question, lots of good answers, but there might still be interest in another alternative...

The numpngw module that I recently put up on github (https://github.com/WarrenWeckesser/numpngw) can write animated PNG files from numpy arrays. (Update: numpngw is now on pypi: https://pypi.python.org/pypi/numpngw.)

For example, this script:

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) 

creates:

You'll need a browser that supports animated PNG (either directly or with a plugin) to see the animation.

As one member mentioned above, imageio is a great way to do this. imageio also allows you to set the frame rate, and I actually wrote a function in Python that allows you to set a hold on the final frame. I use this function for scientific animations where looping is useful but immediate restart isn't. Here is the link and the function:

How to make a GIF using Python

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) 

It's not a python library, but mencoder can do that: Encoding from multiple input image files. You can execute mencoder from python like this:

import os os.system("mencoder ...") 

Have you tried PyMedia? I am not 100% sure but it looks like this tutorial example targets your problem.

With windows7, python2.7, opencv 3.0, the following works for me:

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) 

The easiest thing that makes it work for me is calling a shell command in Python.

If your images are stored such as dummy_image_1.png, dummy_image_2.png ... dummy_image_N.png, then you can use the function:

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

Just execute:

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

This will construct your gif file my_output.gif.

Addition to Smart Manoj answers: Make a .mp4 movie from all images in a folder

Installation:

pip install imageio-ffmpeg pip install imageio 

Code:

import os import imageio root = r'path_to_folder_with_images' images = [] for subdir, dirs, files in os.walk(root): for file in files: images.append(imageio.imread(os.path.join(root,file))) savepath = r'path_to_save_folder' imageio.mimsave(os.path.join(savepath,'movie.mp4'), images) 

PS: Make sure your "files" list is sorted the way you want, you will save some time if you already save your images accordingly

The task can be completed by running the two line python script from the same folder as the sequence of picture files. For png formatted files the script is -

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

I was looking for a single line code and found the following to work for my application. Here is what I did:

First Step: Install ImageMagick from the link below

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

Second Step: Point the cmd line to the folder where the images (in my case .png format) are placed

Third Step: Type the following command

magick -quality 100 *.png outvideo.mpeg 

Thanks FogleBird for the idea!

A simple function that makes GIFs:

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() 

I just tried the following and was very useful:

First Download the libraries Figtodat and images2gif to your local directory.

Secondly Collect the figures in an array and convert them to an animated 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) 

I came upon PIL's ImageSequence module, which offers for a better (and more standard) GIF aninmation. I also use Tk's after() method this time, which is better than 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() 

It's really incredible ... All are proposing some special package for playing an animated GIF, at the moment that it can be done with Tkinter and the classic PIL module!

Here is my own GIF animation method (I created a while ago). Very simple:

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() 

You can set your own means to stop the animation. Let me know if you like to get the full version with play/pause/quit buttons.

Note: I am not sure if the consecutive frames are read from memory or from the file (disk). In the second case it would be more efficient if they all read at once and saved into an array (list). (I'm not so interested to find out! :)

I understand you asked about converting images to a gif; however, if the original format is MP4, you could use FFmpeg:

ffmpeg -i input.mp4 output.gif