# 5 Best Ways to Make 3D Plots Interactive in Jupyter Notebook with Python and Matplotlib

Rate this post

π‘ Problem Formulation: Data visualization in three dimensions (3D) is essential for understanding complex datasets. When using Python in a Jupyter Notebook, you may want to create an interactive 3D plot to explore data more thoroughly. This article provides methods to create dynamic 3D plots using Matplotlib, enhancing your data analysis experience. The examples below show how to transform a static 3D plot into an interactive visualization that responds to user input and manipulation.

## Method 1: Using mpl_toolkits.mplot3d

This method involves mpl_toolkits.mplot3d, a Matplotlib toolkit for 3D plotting which adds functionalities such as pan, zoom, and rotate to the plot within a Jupyter Notebook.

Here’s an example:

```from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
X = np.linspace(-5, 5, 100)
Y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2))

ax.plot_surface(X, Y, Z, cmap='viridis')

plt.show()```

Running this code will generate an interactive 3D surface plot of a sine wave, which you can manipulate within the Jupyter Notebook interface.

This code snippet sets up a 3D plot using Matplotlib’s `Axes3D`. It creates a surface plot for a sine wave function over a grid. The interactive features such as pan and zoom are available by default when using this method in a Jupyter Notebook.

## Method 2: Interactive Widgets with ipywidgets

ipywidgets provide interactive widgets for Jupyter notebooks. This method allows you to use sliders, buttons, and other widgets to change the parameters of the 3D plot dynamically.

Here’s an example:

```from ipywidgets import interactive
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np

def plot_3d(a=1):
fig = plt.figure()
X = np.linspace(-5, 5, 100)
Y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(X, Y)
Z = a*np.sin(np.sqrt(X**2 + Y**2))

ax.plot_surface(X, Y, Z, cmap='viridis')
plt.show()

interactive_plot = interactive(plot_3d, a=(-1, 1, 0.1))
interactive_plot```

The output is an interactive 3D plot with a slider that allows real-time manipulation of the ‘a’ parameter in the sine wave equation.

The above code snippet uses `ipywidgets.interactive` to create an interactive slider for the ‘a’ parameter which scales the sine wave. When you move the slider, the 3D plot updates automatically, giving immediate visual feedback.

## Method 3: Using %matplotlib notebook

Using the magic command `%matplotlib notebook` makes Matplotlib plots interactive within a Jupyter Notebook. This allows rotation and zooming of 3D plots.

Here’s an example:

```%matplotlib notebook
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis')

plt.show()```

The interactive plot can be zoomed and rotated using the toolbar that appears in the Jupyter Notebook.

This method enhances a regular 3D plot by preceding it with `%matplotlib notebook`, which adds toolbar functionalities like zoom and rotate directly in the Jupyter Notebook, giving more control over the visualization process.

## Method 4: Using Plotly

Plotly is an interactive graphing library. It can be used with Jupyter Notebooks to render interactive 3D plots that are more visually appealing and user-friendly than Matplotlib.

Here’s an example:

```import plotly.graph_objs as go
from plotly.offline import iplot
import numpy as np

x, y, z = np.meshgrid(np.linspace(-5, 5, 10),
np.linspace(-5, 5, 10),
np.linspace(-5, 5, 10))
u, v, w = np.sin(x), np.cos(y), np.tan(z)
streamline = go.Cone(x=x.flatten(), y=y.flatten(), z=z.flatten(),
u=u.flatten(), v=v.flatten(), w=w.flatten(),
sizemode="absolute", sizeref=2)
iplot([streamline])```

It generates an interactive 3D streamline plot that allows you to rotate, zoom, and pan for better data visualization.

By utilizing Plotly’s `Cone` trace, you can create an interactive 3D streamline plot, which is rendered using `iplot`. Plotly’s interactive capabilities are vast, providing a rich set of options for user interactivity.

## Bonus One-Liner Method 5: Animate with FuncAnimation

For those looking to add motion to their 3D plots, the `FuncAnimation` in Matplotlib provides a simple way to create animations that can help in visualizing changes over time or iterations.

Here’s an example:

```from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.animation import FuncAnimation

fig = plt.figure()

def update(frame):
ax.cla()
X = np.linspace(-5, 5, 100)
Y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2 + np.sin(frame)))
ax.plot_surface(X, Y, Z, cmap='viridis')

ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128), interval=50)
plt.show()```

The output is an animated 3D surface plot that evolves over time.

`FuncAnimation` creates an animation by repeatedly calling the `update` function, which redefines the Z values to create the appearance of motion. This is a great way to visualize dynamic systems or simulations.

## Summary/Discussion

• Method 1: Using mpl_toolkits.mplot3d. Provides basic interactivity with Matplotlib’s 3D capabilities. Simple to use but limited in advanced interactive features.
• Method 2: Interactive Widgets with ipywidgets. Rich interactivity with dynamic widget controls. It requires additional coding for widget setup.
• Method 3: Using %matplotlib notebook. Easy activation of interactive tools. Limited to functionalities provided by Matplotlib’s notebook backend.
• Method 4: Using Plotly. Advanced interactivity and visually appealing plots. It may be overwhelming for beginners and requires knowledge of Plotly’s syntax and features.
• Bonus Method 5: Animate with FuncAnimation. Adds motion to plots for dynamic presentations. However, it might be computationally intensive for complex animations.