5 Best Ways to Convert a Python NumPy Array to Video

by

💡 Problem Formulation: Converting NumPy arrays into video format is a common task in data visualization, machine learning, and scientific computing. For instance, you may want to transform a sequence of images stored as NumPy arrays into a video file for presentation purposes. The input would be a series of NumPy arrays representing frames, and the desired output is a video file that can be played on standard media players.

Method 1: Using OpenCV

OpenCV provides extensive support for video processing and can be used to convert NumPy arrays into video files. It is highly efficient and supports various codecs and video formats. Users can specify the desired frame rate and resolution for the output video.

Here’s an example:

import cv2
import numpy as np

# Create a random NumPy array sequence
frame_array = [np.random.randint(0, 256, (480, 640, 3), dtype=np.uint8) for _ in range(60)]

# Set up the video writer
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640, 480))

# Write frames to the video file
for frame in frame_array:
    out.write(frame)
    
out.release()

The output is an AVI video file named ‘output.avi’ containing 60 frames of random noise at a resolution of 640×480 pixels and a frame rate of 20 fps.

This code snippet initializes a video writer object with the specified codec, frame rate, and resolution. Random frames are generated and written into this object, which then produces the output video file when released.

Method 2: Using matplotlib and FFMpeg

Matplotlib, in collaboration with FFMpeg, offers another avenue to turn a series of NumPy arrays into a video. This method is beneficial for those who are already using matplotlib for data plotting and visualization.

Here’s an example:

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# Create a figure and a list of frames
fig = plt.figure()
frames = [plt.imshow(np.random.rand(10, 10), animated=True) for _ in range(10)]

ani = animation.ArtistAnimation(fig, frames, interval=200, blit=True)
ani.save('output.mp4', writer='ffmpeg')

The output is an MP4 video named ‘output.mp4’ showcasing a simple animation of random 10×10 matrices refreshed at an interval of 200 milliseconds.

This snippet generates a series of plot frames using the imshow function from matplotlib, then creates an animation with these frames. The animation is saved into a video file using FFMpeg as the backend.

Method 3: Using imageio

Imageio is a powerful library for reading and writing a wide range of image data, including multi-dimensional arrays. It comes with built-in support for creating video files from NumPy arrays.

Here’s an example:

import imageio
import numpy as np

frames = [np.random.rand(480, 640, 3).astype('float32') for _ in range(60)]

with imageio.get_writer('output.gif', mode='I', fps=20) as writer:
    for frame in frames:
        writer.append_data((frame * 255).astype('uint8'))

The output is a GIF file named ‘output.gif’ that cycles through frames of random color patterns, each frame with dimensions 640×480 and a frame rate of 20 fps.

By using imageio, this code snippet produces a GIF from a sequence of NumPy arrays, handling the conversion of data types internally. The ‘append_data’ method adds each frame to the gif.

Method 4: Using moviepy

Moviepy leverages FFMpeg behind the scenes and provides a high-level interface for video editing, including creating videos from NumPy arrays.

Here’s an example:

from moviepy.editor import ImageSequenceClip
import numpy as np

# Generate a sequence of frames
frames = [np.random.rand(480, 640, 3) for _ in range(60)]
clip = ImageSequenceClip(list(frames), fps=20)

clip.write_videofile('output.mp4')

The result is an MP4 video file ‘output.mp4’, playing a sequence of randomly generated frames at 20 fps with a resolution of 640×480 pixels.

In this code snippet, an ‘ImageSequenceClip’ object is created using the moviepy library, where it takes a list of NumPy arrays as frames. The clip is then written to a video file with the specified frame rate.

Bonus One-Liner Method 5: Using NumPy and ffmpeg-python

When you want a quick and concise way to transform your NumPy array into a video, ffmpeg-python provides a Pythonic wrapper around ffmpeg’s comprehensive video processing capabilities.

Here’s an example:

import ffmpeg
import numpy as np

# Generate a sequence of frames
frames = np.random.randint(0, 256, (60, 480, 640, 3), dtype=np.uint8)
process = (
    ffmpeg
    .input('pipe:', format='rawvideo', pix_fmt='rgb24', s='640x480', r='20')
    .output('output.mp4', pix_fmt='yuv420p')
    .run_async(pipe_stdin=True)
)
process.communicate(input=frames.tobytes())

This one-liner (spread across multiple lines for readability) feeds a sequence of frame data directly to ffmpeg, creating an MP4 video named ‘output.mp4’.

The code combines NumPy’s ability to generate and handle array byte data with the simplicity of the ffmpeg-python API to produce a video file with minimal overhead.

Summary/Discussion

  • Method 1: OpenCV. Supports many codecs and formats. Efficient for video processing. Requires familiarity with OpenCV.
  • Method 2: Matplotlib and FFMpeg. Ideal for current matplotlib users. Seamless integration with data plots. May be less efficient for large videos.
  • Method 3: Imageio. Simple and straightforward. Limited to formats supported by imageio. Great for quick conversions without complex dependencies.
  • Method 4: Moviepy. High-level video editing. User-friendly. It might introduce overhead and is slower for processing large datasets.
  • Bonus Method 5: ffmpeg-python. Direct access to ffmpeg’s functionality. Potentially one of the fastest methods for large data. Requires understanding of ffmpeg command-line arguments.