VisPy is a high-performance interactive 2D/3D data visualization library in Python. It offers an interface for high-quality visualization and manipulation of large data sets in 2D/3D. Leaning on the power of the GPU, it provides both efficient and interactive visualizations. VisPy leverages the computational power of modern Graphics Processing Units (GPUs) through the OpenGL library to display very large datasets.

From creating simple figures to generating complex, interactive visualizations of large data sets, VisPy is designed to help scientists and data analysts extract critical information from their data. The library is designed to be easy to use, while still providing a powerful, customizable platform for more advanced users. With its robust set of tools and capabilities, VisPy offers a unique and compelling platform for data visualization in Python.

Installation

VisPy can be installed using several methods. The preferred method is to use the Python package installer (pip). You can install VisPy by running the following command in your terminal:

pip install vispy

Alternatively, you can use Conda, a package manager that comes with the Anaconda distribution of Python. To install VisPy with Conda, use the following command:

conda install -c conda-forge vispy

If you want to be on the cutting edge of VisPy development, you can install VisPy directly from its GitHub repository. This is not recommended for most users, as this version of the library may be unstable. To install from GitHub, use the following commands:

git clone <https://github.com/vispy/vispy.git>
cd vispy
python setup.py install

Finally, you can also install VisPy from Test PyPI, a separate instance of the Python Package Index that allows you to try distribution tools and processes without affecting the real index. To install from Test PyPI, use the following command:

pip install --index-url <https://test.pypi.org/simple/> vispy

Note that VisPy requires PyQt5. You can install this package by running the following command in your terminal:

pip install PyQt5

Usage

Line plot with colorbar

A line plot displays information as a series of data points connected by line segments. It is the most basic type of chart among others. While similar to a scatter plot, a line plot has ordered points joined by straight line segments. Typically, a line plot is used in exploratory data analysis to analyze trends over time.

In this example, we will create a line plot with a colorbar using VisPy. First, we will import the VisPy library. Then, we will create a figure object using the Fig() function of VisPy, specifying the dimensions of our plot. Next, we will create a plot widget using fig[0, 0].

import vispy.plot as vp

fig = vp.Fig(size=(600, 500), show=False)
plotwidget = fig[0, 0]

To add a title to our plot, we can use the fig.title command. The main part of the visualization involves building the line plot using the plot() function of the plot widget. We will use a for loop to add the x and y values. To add a colorbar, we will use the colorbar() function of the plot widget, specifying the position and style of the bar with the camp parameter.

Finally, to view the plot we will use the show() function of the figure object.

fig.title = "Line Plot with a colorbar"
plotwidget.plot([(x, x**2) for x in range(0, 100)], title="y = x^2")
plotwidget.colorbar(position="top", cmap="autumn")

fig.show(run=True)

Output:

Spectrogram and Line Plot

A spectrogram is a type of visualization that represents the spectrum of frequencies of a sound or any other signal. This visualization is commonly used in signal analysis and the field of acoustics to analyze different components of a signal. It is particularly useful for analyzing sounds that change over time.

To build this visualization, we will first import all the necessary libraries, such as NumPy and VisPy. Next, we will create a dummy logarithmic chirp signal. To do this, we will use parameters like the sampling frequency (fs), the number of samples (N), and the start (f0) and end (f1) frequencies. After creating this signal, we will store it in the ‘data’ variable.

Now we will create a figure object using the vispy.Fig() function, specifying the size of the figure. Next, we will create the spectrogram using the spectrogram() function, passing our ‘data’ variable. We will then create a line plot for our signal using the plot() function. Finally, we will display the figure using the fig.show(run=True) function. This will open a window with the visualization and start the application’s event loop.

import numpy as np

from vispy import plot as vp

# Create a logarithmic chirp
fs = 1000.
N = 10000
t = np.arange(N) / float(fs)
f0, f1 = 1., 500.
phase = (t[-1] / np.log(f1 / f0)) * f0 * (pow(f1 / f0, t / t[-1]) - 1.0)
data = np.cos(2 * np.pi * phase)

fig = vp.Fig(size=(800, 400), show=False)
fig[0:2, 0].spectrogram(data, fs=fs, clim=(-100, -20))
fig[2, 0].plot(np.array((t, data)).T, marker_size=0)

fig.show(run=True)

Output:

Displaying a cube

A cube is a three-dimensional figure that is equally interesting to visualize. With VisPy, we can create an interactive cube with customizable color and size.

To visualize a cube, first, we will import the necessary libraries, which are ‘scene’ from ‘vispy’ and ‘Color’ from ‘vispy.color’. We then create a scene canvas that is interactive, set its size, and make it visible.

Now we will set up a viewbox to display the cube with an interactive arcball. We will set the background color of the canvas to ‘black’ using the bgcolor attribute. We will set the camera type to ‘turntable’ and the padding to 100 for proper visualization.

import sys
from vispy import scene
from vispy.color import Color

canvas = scene.SceneCanvas(keys='interactive', size=(800, 600), show=True)

# Set up a viewbox to display the cube with interactive arcball
view = canvas.central_widget.add_view()
view.bgcolor = 'black'
view.camera = 'turntable'
view.padding = 100

Next, we will define the color of the cube as yellow using the `Color` class.

To create the cube, we will use the `Box` class from `scene.visuals`. We will specify the dimensions of the cube as 1, 1, 1, set the color to yellow as defined earlier, set the edge color to black, and parent it to the scene of the view.

Finally, we will run the script directly using the `canvas.app.run()` function. This script will open a window with an interactive cube that you can rotate and zoom.

color = Color("yellow")

cube = scene.visuals.Box(1, 1, 1, color=color, edge_color="black",
                         parent=view.scene)
if __name__ == '__main__' and sys.flags.interactive == 0:
    canvas.app.run()

Output:

Different Visuals

Creating various shapes can be crucial in many applications. In this section, we will render different shapes such as a polygon, ellipse, rectangle, and regular polygon using the VisPy library.

To build this visualization, we will first import the necessary modules from VisPy, including app, scene, and color. From the scene.visuals module, we will import the classes for the shapes we want to create: Polygon, Ellipse, Rectangle, and RegularPolygon.

Next, we will define colors using the Color class from the vispy.color module. Colors are defined using hexadecimal color codes. For example, we will define white as “#ecf0f1” and gray as “#121212”.

from vispy import app
import sys
from vispy.scene import SceneCanvas
from vispy.scene.visuals import Polygon, Ellipse, Rectangle, RegularPolygon
from vispy.color import Color

white = Color("#ecf0f1")
gray = Color("#121212")
red = Color("#e74c3c")
blue = Color("#2980b9")
orange = Color("#e88834")

Now we will create an object of SceneCanvas that is interactive and visible. We will add a view to the central widget of the canvas, set its background color to gray, and specify the camera type as ‘panzoom’.

Let’s start by creating a polygon. First, we will define its coordinates. Then, we will create an object of the Polygon class, specifying its color, border color, and border width.

canvas = SceneCanvas(keys='interactive', title='Polygon Example',
                     show=True)
v = canvas.central_widget.add_view()
v.bgcolor = gray
v.camera = 'panzoom'

cx, cy = (0.2, 0.2)
halfx, halfy = (0.1, 0.1)

poly_coords = [(cx - halfx, cy - halfy),
               (cx + halfx, cy - halfy),
               (cx + halfx, cy + halfy),
               (cx - halfx, cy + halfy)]
poly = Polygon(poly_coords, color=red, border_color=white,
               border_width=3, parent=v.scene)

Similarly, we will create an ellipse shape by specifying its center, radius, color, border width, number of segments, and border color. We will also set its start and span angles.

ellipse = Ellipse(center=(0.4, 0.2), radius=(0.1, 0.05),
                  color=blue, border_width=2, border_color=white,
                  num_segments=1,
                  parent=v.scene)

ellipse.num_segments = 10
ellipse.start_angle = 0
ellipse.span_angle = 120

Next, we will create a rectangle shape by specifying its center, width, height, color, border color, and radius.

rect = Rectangle(center=(0.6, 0.2), width=0.1, height=0.2,
                 color=orange, border_color=white,
                 radius=0.02, parent=v.scene)

Finally, we will create a regular polygon (a hexagon in this case) by specifying its center, radius, number of sides (6 for a hexagon), color, border color, and border width.

regular_poly = RegularPolygon(center=(0.8, 0.2),
                              radius=0.1, sides=6, color=blue,
                              border_color=white, border_width=2,
                              parent=v.scene)

To run the application, we use the app.run() function. This opens a window with the interactive shapes that we can move and zoom.

if __name__ == '__main__':
    if sys.flags.interactive != 1:
        app.run()

This script demonstrates how powerful and flexible VisPy is in creating and manipulating visualizations.

Output:

Benefits of VisPy

Beyond the basic features, VisPy also provides many advanced features that offer even more power and flexibility to our visualizations. Here are some of them:

GPU Shaders

VisPy allows the use of Graphics Processing Unit (GPU) shaders to increase the performance of our visualizations. Shaders are used to perform rendering effects directly on the GPU, which can increase the performance and visual quality of large datasets.

Multiple Rendering Backends

VisPy has multiple rendering backends, such as OpenGL and WebGL. This means that we can use VisPy to create visualizations that can run on any OS or platform, from desktop computers to web browsers.

Custom Visuals

In addition to building normal visualizations using built-in visuals, we can create our own custom visuals using VisPy. This means we can create highly customized visualizations that perfectly suit our needs.

Conclusion

By now, you should have understood how to build interactive visualizations using VisPy. It’s an excellent tool for anyone needing to create 3D visualizations in Python, offering many advanced features like GPU shaders, multiple rendering backends, and the ability to build custom visualizations.